'use strict';

var chunk3T7FP546_cjs = require('../chunk-3T7FP546.cjs');
var promises = require('fs/promises');
var https = require('https');
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 mime = require('hono/utils/mime');
var fs = require('fs');
var process$1 = require('process');
var html = require('hono/html');
var tools = require('@mastra/core/tools');
var serverAdapter = require('@mastra/server/server-adapter');
var util = require('util');
var buffer = require('buffer');
var bodyLimit = require('hono/body-limit');
var streaming = require('hono/streaming');
var auth = require('@mastra/server/auth');
var browserStream = require('@mastra/server/browser-stream');
var store = require('@mastra/server/a2a/store');
var hono = require('hono');
var compress = require('hono/compress');
var cors = require('hono/cors');
var logger = require('hono/logger');
var timeout = require('hono/timeout');
var httpException = require('hono/http-exception');

var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n.default = e;
  return Object.freeze(n);
}

var https__namespace = /*#__PURE__*/_interopNamespace(https);
var crypto__default = /*#__PURE__*/_interopDefault(crypto);
var util__default = /*#__PURE__*/_interopDefault(util);

var RequestError = class extends Error {
  constructor(message, options) {
    super(message, options);
    this.name = "RequestError";
  }
};
var toRequestError = (e) => {
  if (e instanceof RequestError) {
    return e;
  }
  return new RequestError(e.message, { cause: e });
};
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 newHeadersFromIncoming = (incoming) => {
  const headerRecord = [];
  const rawHeaders = incoming.rawHeaders;
  for (let i = 0; i < rawHeaders.length; i += 2) {
    const { [i]: key, [i + 1]: value } = rawHeaders;
    if (key.charCodeAt(0) !== /*:*/
    58) {
      headerRecord.push([key, value]);
    }
  }
  return new Headers(headerRecord);
};
var wrapBodyStream = /* @__PURE__ */ Symbol("wrapBodyStream");
var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
  const init = {
    method,
    headers,
    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 if (incoming[wrapBodyStream]) {
      let reader;
      init.body = new ReadableStream({
        async pull(controller) {
          try {
            reader ||= stream.Readable.toWeb(incoming).getReader();
            const { done, value } = await reader.read();
            if (done) {
              controller.close();
            } else {
              controller.enqueue(value);
            }
          } catch (error) {
            controller.error(error);
          }
        }
      });
    } else {
      init.body = stream.Readable.toWeb(incoming);
    }
  }
  return new Request(url, init);
};
var getRequestCache = /* @__PURE__ */ Symbol("getRequestCache");
var requestCache = /* @__PURE__ */ Symbol("requestCache");
var incomingKey = /* @__PURE__ */ Symbol("incomingKey");
var urlKey = /* @__PURE__ */ Symbol("urlKey");
var headersKey = /* @__PURE__ */ Symbol("headersKey");
var abortControllerKey = /* @__PURE__ */ Symbol("abortControllerKey");
var getAbortController = /* @__PURE__ */ Symbol("getAbortController");
var requestPrototype = {
  get method() {
    return this[incomingKey].method || "GET";
  },
  get url() {
    return this[urlKey];
  },
  get headers() {
    return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
  },
  [getAbortController]() {
    this[getRequestCache]();
    return this[abortControllerKey];
  },
  [getRequestCache]() {
    this[abortControllerKey] ||= new AbortController();
    return this[requestCache] ||= newRequestFromIncoming(
      this.method,
      this[urlKey],
      this.headers,
      this[incomingKey],
      this[abortControllerKey]
    );
  }
};
[
  "body",
  "bodyUsed",
  "cache",
  "credentials",
  "destination",
  "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.defineProperty(requestPrototype, /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom"), {
  value: function(depth, options, inspectFn) {
    const props = {
      method: this.method,
      url: this.url,
      headers: this.headers,
      nativeRequest: this[requestCache]
    };
    return `Request (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
  }
});
Object.setPrototypeOf(requestPrototype, Request.prototype);
var newRequest = (incoming, defaultHostname) => {
  const req = Object.create(requestPrototype);
  req[incomingKey] = incoming;
  const incomingUrl = incoming.url || "";
  if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
  (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
    if (incoming instanceof http2.Http2ServerRequest) {
      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
    }
    try {
      const url2 = new URL(incomingUrl);
      req[urlKey] = url2.href;
    } catch (e) {
      throw new RequestError("Invalid absolute URL", { cause: e });
    }
    return req;
  }
  const host = (incoming instanceof http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
  if (!host) {
    throw new RequestError("Missing host header");
  }
  let scheme;
  if (incoming instanceof http2.Http2ServerRequest) {
    scheme = incoming.scheme;
    if (!(scheme === "http" || scheme === "https")) {
      throw new RequestError("Unsupported scheme");
    }
  } else {
    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
  }
  const url = new URL(`${scheme}://${host}${incomingUrl}`);
  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
    throw new RequestError("Invalid host header");
  }
  req[urlKey] = url.href;
  return req;
};
var responseCache = /* @__PURE__ */ Symbol("responseCache");
var getResponseCache = /* @__PURE__ */ Symbol("getResponseCache");
var cacheKey = /* @__PURE__ */ 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) {
    let headers;
    this.#body = body;
    if (init instanceof _Response) {
      const cachedGlobalResponse = init[responseCache];
      if (cachedGlobalResponse) {
        this.#init = cachedGlobalResponse;
        this[getResponseCache]();
        return;
      } else {
        this.#init = init.#init;
        headers = new Headers(init.#init.headers);
      }
    } else {
      this.#init = init;
    }
    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
      this[cacheKey] = [init?.status || 200, body, headers || init?.headers];
    }
  }
  get headers() {
    const cache = this[cacheKey];
    if (cache) {
      if (!(cache[2] instanceof Headers)) {
        cache[2] = new Headers(
          cache[2] || { "content-type": "text/plain; charset=UTF-8" }
        );
      }
      return cache[2];
    }
    return this[getResponseCache]().headers;
  }
  get status() {
    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
  }
  get ok() {
    const status = this.status;
    return status >= 200 && status < 300;
  }
};
["body", "bodyUsed", "redirected", "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.defineProperty(Response2.prototype, /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom"), {
  value: function(depth, options, inspectFn) {
    const props = {
      status: this.status,
      headers: this.headers,
      ok: this.ok,
      nativeResponse: this[responseCache]
    };
    return `Response (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
  }
});
Object.setPrototypeOf(Response2, GlobalResponse);
Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
async function readWithoutBlocking(readPromise) {
  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
}
function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
  const cancel = (error) => {
    reader.cancel(error).catch(() => {
    });
  };
  writable.on("close", cancel);
  writable.on("error", cancel);
  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
  return reader.closed.finally(() => {
    writable.off("close", cancel);
    writable.off("error", cancel);
  });
  function handleStreamError(error) {
    if (error) {
      writable.destroy(error);
    }
  }
  function onDrain() {
    reader.read().then(flow, handleStreamError);
  }
  function flow({ done, value }) {
    try {
      if (done) {
        writable.end();
      } else if (!writable.write(value)) {
        writable.once("drain", onDrain);
      } else {
        return reader.read().then(flow, handleStreamError);
      }
    } catch (e) {
      handleStreamError(e);
    }
  }
}
function writeFromReadableStream(stream2, writable) {
  if (stream2.locked) {
    throw new TypeError("ReadableStream is locked.");
  } else if (writable.destroyed) {
    return;
  }
  return writeFromReadableStreamDefaultReader(stream2.getReader(), writable);
}
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 X_ALREADY_SENT = "x-hono-already-sent";
if (typeof global.crypto === "undefined") {
  global.crypto = crypto__default.default;
}
var outgoingEnded = /* @__PURE__ */ Symbol("outgoingEnded");
var incomingDraining = /* @__PURE__ */ Symbol("incomingDraining");
var DRAIN_TIMEOUT_MS = 500;
var MAX_DRAIN_BYTES = 64 * 1024 * 1024;
var drainIncoming = (incoming) => {
  const incomingWithDrainState = incoming;
  if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
    return;
  }
  incomingWithDrainState[incomingDraining] = true;
  if (incoming instanceof http2.Http2ServerRequest) {
    try {
      incoming.stream?.close?.(http2.constants.NGHTTP2_NO_ERROR);
    } catch {
    }
    return;
  }
  let bytesRead = 0;
  const cleanup = () => {
    clearTimeout(timer);
    incoming.off("data", onData);
    incoming.off("end", cleanup);
    incoming.off("error", cleanup);
  };
  const forceClose = () => {
    cleanup();
    const socket = incoming.socket;
    if (socket && !socket.destroyed) {
      socket.destroySoon();
    }
  };
  const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
  timer.unref?.();
  const onData = (chunk) => {
    bytesRead += chunk.length;
    if (bytesRead > MAX_DRAIN_BYTES) {
      forceClose();
    }
  };
  incoming.on("data", onData);
  incoming.on("end", cleanup);
  incoming.on("error", cleanup);
  incoming.resume();
};
var handleRequestError = () => new Response(null, {
  status: 400
});
var handleFetchError = (e) => new Response(null, {
  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
});
var handleResponseError = (e, outgoing) => {
  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
    console.info("The user aborted a request.");
  } else {
    console.error(e);
    if (!outgoing.headersSent) {
      outgoing.writeHead(500, { "Content-Type": "text/plain" });
    }
    outgoing.end(`Error: ${err.message}`);
    outgoing.destroy(err);
  }
};
var flushHeaders = (outgoing) => {
  if ("flushHeaders" in outgoing && outgoing.writable) {
    outgoing.flushHeaders();
  }
};
var responseViaCache = async (res, outgoing) => {
  let [status, body, header] = res[cacheKey];
  let hasContentLength = false;
  if (!header) {
    header = { "content-type": "text/plain; charset=UTF-8" };
  } else if (header instanceof Headers) {
    hasContentLength = header.has("content-length");
    header = buildOutgoingHttpHeaders(header);
  } else if (Array.isArray(header)) {
    const headerObj = new Headers(header);
    hasContentLength = headerObj.has("content-length");
    header = buildOutgoingHttpHeaders(headerObj);
  } else {
    for (const key in header) {
      if (key.length === 14 && key.toLowerCase() === "content-length") {
        hasContentLength = true;
        break;
      }
    }
  }
  if (!hasContentLength) {
    if (typeof body === "string") {
      header["Content-Length"] = Buffer.byteLength(body);
    } else if (body instanceof Uint8Array) {
      header["Content-Length"] = body.byteLength;
    } else if (body instanceof Blob) {
      header["Content-Length"] = body.size;
    }
  }
  outgoing.writeHead(status, header);
  if (typeof body === "string" || body instanceof Uint8Array) {
    outgoing.end(body);
  } else if (body instanceof Blob) {
    outgoing.end(new Uint8Array(await body.arrayBuffer()));
  } else {
    flushHeaders(outgoing);
    await writeFromReadableStream(body, outgoing)?.catch(
      (e) => handleResponseError(e, outgoing)
    );
  }
  outgoing[outgoingEnded]?.();
};
var isPromise = (res) => typeof res.then === "function";
var responseViaResponseObject = async (res, outgoing, options = {}) => {
  if (isPromise(res)) {
    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);
  if (res.body) {
    const reader = res.body.getReader();
    const values = [];
    let done = false;
    let currentReadPromise = void 0;
    if (resHeaderRecord["transfer-encoding"] !== "chunked") {
      let maxReadCount = 2;
      for (let i = 0; i < maxReadCount; i++) {
        currentReadPromise ||= reader.read();
        const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
          console.error(e);
          done = true;
        });
        if (!chunk) {
          if (i === 1) {
            await new Promise((resolve) => setTimeout(resolve));
            maxReadCount = 3;
            continue;
          }
          break;
        }
        currentReadPromise = void 0;
        if (chunk.value) {
          values.push(chunk.value);
        }
        if (chunk.done) {
          done = true;
          break;
        }
      }
      if (done && !("content-length" in resHeaderRecord)) {
        resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
      }
    }
    outgoing.writeHead(res.status, resHeaderRecord);
    values.forEach((value) => {
      outgoing.write(value);
    });
    if (done) {
      outgoing.end();
    } else {
      if (values.length === 0) {
        flushHeaders(outgoing);
      }
      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
    }
  } else if (resHeaderRecord[X_ALREADY_SENT]) ; else {
    outgoing.writeHead(res.status, resHeaderRecord);
    outgoing.end();
  }
  outgoing[outgoingEnded]?.();
};
var getRequestListener = (fetchCallback, options = {}) => {
  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
  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);
      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
      if (!incomingEnded) {
        incoming[wrapBodyStream] = true;
        incoming.on("end", () => {
          incomingEnded = true;
        });
        if (incoming instanceof http2.Http2ServerRequest) {
          outgoing[outgoingEnded] = () => {
            if (!incomingEnded) {
              setTimeout(() => {
                if (!incomingEnded) {
                  setTimeout(() => {
                    drainIncoming(incoming);
                  });
                }
              });
            }
          };
        }
        outgoing.on("finish", () => {
          if (!incomingEnded) {
            drainIncoming(incoming);
          }
        });
      }
      outgoing.on("close", () => {
        const abortController = req[abortControllerKey];
        if (abortController) {
          if (incoming.errored) {
            req[abortControllerKey].abort(incoming.errored.toString());
          } else if (!outgoing.writableFinished) {
            req[abortControllerKey].abort("Client connection prematurely closed.");
          }
        }
        if (!incomingEnded) {
          setTimeout(() => {
            if (!incomingEnded) {
              setTimeout(() => {
                drainIncoming(incoming);
              });
            }
          });
        }
      });
      res = fetchCallback(req, { incoming, outgoing });
      if (cacheKey in res) {
        return responseViaCache(res, outgoing);
      }
    } catch (e) {
      if (!res) {
        if (options.errorHandler) {
          res = await options.errorHandler(req ? e : toRequestError(e));
          if (!res) {
            return;
          }
        } else if (!req) {
          res = handleRequestError();
        } else {
          res = handleFetchError(e);
        }
      } else {
        return handleResponseError(e, outgoing);
      }
    }
    try {
      return await responseViaResponseObject(res, outgoing, options);
    } catch (e) {
      return handleResponseError(e, outgoing);
    }
  };
};
var createAdaptorServer = (options) => {
  const fetchCallback = options.fetch;
  const requestListener = getRequestListener(fetchCallback, {
    hostname: options.hostname,
    overrideGlobalObjects: options.overrideGlobalObjects,
    autoCleanupIncoming: options.autoCleanupIncoming
  });
  const createServer2 = options.createServer || http.createServer;
  const server = createServer2(options.serverOptions || {}, requestListener);
  return server;
};
var serve = (options, listeningListener) => {
  const server = createAdaptorServer(options);
  server.listen(options?.port ?? 3e3, 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 pr54206Applied = () => {
  const [major, minor] = process$1.versions.node.split(".").map((component) => parseInt(component));
  return major >= 23 || major === 22 && minor >= 7 || major === 20 && minor >= 18;
};
var useReadableToWeb = pr54206Applied();
var createStreamBody = (stream2) => {
  if (useReadableToWeb) {
    return stream.Readable.toWeb(stream2);
  }
  const body = new ReadableStream({
    start(controller) {
      stream2.on("data", (chunk) => {
        controller.enqueue(chunk);
      });
      stream2.on("error", (err) => {
        controller.error(err);
      });
      stream2.on("end", () => {
        controller.close();
      });
    },
    cancel() {
      stream2.destroy();
    }
  });
  return body;
};
var getStats = (path) => {
  let stats;
  try {
    stats = fs.statSync(path);
  } catch {
  }
  return stats;
};
var tryDecode = (str, decoder) => {
  try {
    return decoder(str);
  } catch {
    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
      try {
        return decoder(match);
      } catch {
        return match;
      }
    });
  }
};
var tryDecodeURI = (str) => tryDecode(str, decodeURI);
var serveStatic = (options = { root: "" }) => {
  const root = options.root || "";
  const optionPath = options.path;
  if (root !== "" && !fs.existsSync(root)) {
    console.error(`serveStatic: root path '${root}' is not found, are you sure it's correct?`);
  }
  return async (c, next) => {
    if (c.finalized) {
      return next();
    }
    let filename;
    if (optionPath) {
      filename = optionPath;
    } else {
      try {
        filename = tryDecodeURI(c.req.path);
        if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}/.test(filename)) {
          throw new Error();
        }
      } catch {
        await options.onNotFound?.(c.req.path, c);
        return next();
      }
    }
    let path$1 = path.join(
      root,
      !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
    );
    let stats = getStats(path$1);
    if (stats && stats.isDirectory()) {
      const indexFile = options.index ?? "index.html";
      path$1 = path.join(path$1, indexFile);
      stats = getStats(path$1);
    }
    if (!stats) {
      await options.onNotFound?.(path$1, c);
      return next();
    }
    const mimeType = mime.getMimeType(path$1);
    c.header("Content-Type", mimeType || "application/octet-stream");
    if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
      const acceptEncodingSet = new Set(
        c.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$1 + ENCODINGS[encoding]);
        if (precompressedStats) {
          c.header("Content-Encoding", encoding);
          c.header("Vary", "Accept-Encoding", { append: true });
          stats = precompressedStats;
          path$1 = path$1 + ENCODINGS[encoding];
          break;
        }
      }
    }
    let result;
    const size = stats.size;
    const range = c.req.header("range") || "";
    if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
      c.header("Content-Length", size.toString());
      c.status(200);
      result = c.body(null);
    } else if (!range) {
      c.header("Content-Length", size.toString());
      result = c.body(createStreamBody(fs.createReadStream(path$1)), 200);
    } else {
      c.header("Accept-Ranges", "bytes");
      c.header("Date", stats.birthtime.toUTCString());
      const parts = range.replace(/bytes=/, "").split("-", 2);
      const start = parseInt(parts[0], 10) || 0;
      let end = parseInt(parts[1], 10) || size - 1;
      if (size < end - start + 1) {
        end = size - 1;
      }
      const chunksize = end - start + 1;
      const stream2 = fs.createReadStream(path$1, { start, end });
      c.header("Content-Length", chunksize.toString());
      c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
      result = c.body(createStreamBody(stream2), 206);
    }
    await options.onFound?.(path$1, c);
    return result;
  };
};
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) => {
  return Object.entries(options).map(([k, v]) => {
    const key = k;
    if (!RENDER_TYPE_MAP[key] || v === void 0) return "";
    switch (RENDER_TYPE_MAP[key]) {
      case RENDER_TYPE.STRING:
        return `${key}: '${v}'`;
      case RENDER_TYPE.STRING_ARRAY:
        if (!Array.isArray(v)) return "";
        return `${key}: [${v.map((ve) => `${ve}`).join(",")}]`;
      case RENDER_TYPE.JSON_STRING:
        return `${key}: ${JSON.stringify(v)}`;
      case RENDER_TYPE.RAW:
        return `${key}: ${v}`;
      default:
        return "";
    }
  }).filter((item) => item !== "").join(",");
};
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 (c) => {
  const title = options?.title ?? "SwaggerUI";
  return c.html(`
      <!doctype 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>
    `);
};
var classRegExp = /^([A-Z][a-z0-9]*)+$/;
var kTypes = [
  "string",
  "function",
  "number",
  "object",
  // Accept 'Function' and 'Object' as alternative to the lower cased version.
  "Function",
  "Object",
  "boolean",
  "bigint",
  "symbol"
];
function determineSpecificType(value) {
  if (value == null) {
    return "" + value;
  }
  if (typeof value === "function" && value.name) {
    return `function ${value.name}`;
  }
  if (typeof value === "object") {
    if (value.constructor?.name) {
      return `an instance of ${value.constructor.name}`;
    }
    return `${util__default.default.inspect(value, { depth: -1 })}`;
  }
  let inspected = util__default.default.inspect(value, { colors: false });
  if (inspected.length > 28) {
    inspected = `${inspected.slice(0, 25)}...`;
  }
  return `type ${typeof value} (${inspected})`;
}
var ERR_HTTP_BODY_NOT_ALLOWED = class extends Error {
  constructor() {
    super("Adding content for this request method or response status is not allowed.");
  }
};
var ERR_HTTP_CONTENT_LENGTH_MISMATCH = class extends Error {
  constructor(actual, expected) {
    super(`Response body's content-length of ${actual} byte(s) does not match the content-length of ${expected} byte(s) set in header`);
  }
};
var ERR_HTTP_HEADERS_SENT = class extends Error {
  constructor(arg) {
    super(`Cannot ${arg} headers after they are sent to the client`);
  }
};
var ERR_INVALID_ARG_VALUE = class extends TypeError {
  constructor(name, value, reason = "is invalid") {
    let inspected = util__default.default.inspect(value);
    if (inspected.length > 128) {
      inspected = `${inspected.slice(0, 128)}...`;
    }
    const type = name.includes(".") ? "property" : "argument";
    super(`The ${type} '${name}' ${reason}. Received ${inspected}`);
  }
};
var ERR_INVALID_CHAR = class extends TypeError {
  constructor(name, field) {
    let msg = `Invalid character in ${name}`;
    if (field !== void 0) {
      msg += ` ["${field}"]`;
    }
    super(msg);
  }
};
var ERR_HTTP_INVALID_HEADER_VALUE = class extends TypeError {
  constructor(value, name) {
    super(`Invalid value "${value}" for header "${name}"`);
  }
};
var ERR_HTTP_INVALID_STATUS_CODE = class extends RangeError {
  originalStatusCode;
  constructor(originalStatusCode) {
    super(`Invalid status code: ${originalStatusCode}`);
    this.originalStatusCode = originalStatusCode;
  }
};
var ERR_HTTP_TRAILER_INVALID = class extends Error {
  constructor() {
    super(`Trailers are invalid with this transfer encoding`);
  }
};
var ERR_INVALID_ARG_TYPE = class extends TypeError {
  constructor(name, expected, actual) {
    if (!Array.isArray(expected)) {
      expected = [expected];
    }
    let msg = "The ";
    if (name.endsWith(" argument")) {
      msg += `${name} `;
    } else {
      const type = name.includes(".") ? "property" : "argument";
      msg += `"${name}" ${type} `;
    }
    msg += "must be ";
    const types = [];
    const instances = [];
    const other = [];
    for (const value of expected) {
      if (kTypes.includes(value)) {
        types.push(value.toLowerCase());
      } else if (classRegExp.exec(value) !== null) {
        instances.push(value);
      } else {
        other.push(value);
      }
    }
    if (instances.length > 0) {
      const pos = types.indexOf("object");
      if (pos !== -1) {
        types.splice(pos, 1);
        instances.push("Object");
      }
    }
    if (types.length > 0) {
      if (types.length > 2) {
        const last = types.pop();
        msg += `one of type ${types.join(", ")}, or ${last}`;
      } else if (types.length === 2) {
        msg += `one of type ${types[0]} or ${types[1]}`;
      } else {
        msg += `of type ${types[0]}`;
      }
      if (instances.length > 0 || other.length > 0)
        msg += " or ";
    }
    if (instances.length > 0) {
      if (instances.length > 2) {
        const last = instances.pop();
        msg += `an instance of ${instances.join(", ")}, or ${last}`;
      } else {
        msg += `an instance of ${instances[0]}`;
        if (instances.length === 2) {
          msg += ` or ${instances[1]}`;
        }
      }
      if (other.length > 0)
        msg += " or ";
    }
    if (other.length > 0) {
      if (other.length > 2) {
        const last = other.pop();
        msg += `one of ${other.join(", ")}, or ${last}`;
      } else if (other.length === 2) {
        msg += `one of ${other[0]} or ${other[1]}`;
      } else {
        if (other[0].toLowerCase() !== other[0])
          msg += "an ";
        msg += `${other[0]}`;
      }
    }
    msg += `. Received ${determineSpecificType(actual)}`;
    super(msg);
  }
};
var ERR_INVALID_HTTP_TOKEN = class extends TypeError {
  constructor(name, field) {
    super(`${name} must be a valid HTTP token ["${field}"]`);
  }
};
var ERR_METHOD_NOT_IMPLEMENTED = class extends Error {
  constructor(methodName) {
    super(`The ${methodName} method is not implemented`);
  }
};
var ERR_STREAM_ALREADY_FINISHED = class extends Error {
  constructor(methodName) {
    super(`Cannot call ${methodName} after a stream was finished`);
  }
};
var ERR_STREAM_CANNOT_PIPE = class extends Error {
  constructor() {
    super(`Cannot pipe, not readable`);
  }
};
var ERR_STREAM_DESTROYED = class extends Error {
  constructor(methodName) {
    super(`Cannot call ${methodName} after a stream was destroyed`);
  }
};
var ERR_STREAM_NULL_VALUES = class extends TypeError {
  constructor() {
    super(`May not write null values to stream`);
  }
};
var ERR_STREAM_WRITE_AFTER_END = class extends Error {
  constructor() {
    super(`write after end`);
  }
};

// ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fetch-to-node/2.1.0/75a085586b95f3a18a440f8655a7cb5c851846ab2c5e6ad2c4ae036e3bbaa05c/node_modules/fetch-to-node/dist/fetch-to-node/http-incoming.js
var kHeaders = /* @__PURE__ */ Symbol("kHeaders");
var kHeadersDistinct = /* @__PURE__ */ Symbol("kHeadersDistinct");
var kHeadersCount = /* @__PURE__ */ Symbol("kHeadersCount");
var kTrailers = /* @__PURE__ */ Symbol("kTrailers");
var kTrailersDistinct = /* @__PURE__ */ Symbol("kTrailersDistinct");
var kTrailersCount = /* @__PURE__ */ Symbol("kTrailersCount");
var FetchIncomingMessage = class extends stream.Readable {
  get socket() {
    return null;
  }
  set socket(_val) {
    throw new ERR_METHOD_NOT_IMPLEMENTED("socket");
  }
  httpVersionMajor;
  httpVersionMinor;
  httpVersion;
  complete = false;
  [kHeaders] = null;
  [kHeadersDistinct] = null;
  [kHeadersCount] = 0;
  rawHeaders = [];
  [kTrailers] = null;
  [kTrailersDistinct] = null;
  [kTrailersCount] = 0;
  rawTrailers = [];
  joinDuplicateHeaders = false;
  aborted = false;
  upgrade = false;
  // request (server) only
  url = "";
  method;
  // TODO: Support ClientRequest
  // statusCode = null;
  // statusMessage = null;
  // client = socket;
  _consuming;
  _dumped;
  // The underlying ReadableStream
  _stream = null;
  constructor() {
    const streamOptions = {};
    super(streamOptions);
    this._readableState.readingMore = true;
    this._consuming = false;
    this._dumped = false;
  }
  get connection() {
    return null;
  }
  set connection(_socket) {
    console.error("No support for IncomingMessage.connection");
  }
  get headers() {
    if (!this[kHeaders]) {
      this[kHeaders] = {};
      const src = this.rawHeaders;
      const dst = this[kHeaders];
      for (let n = 0; n < this[kHeadersCount]; n += 2) {
        this._addHeaderLine(src[n], src[n + 1], dst);
      }
    }
    return this[kHeaders];
  }
  set headers(val) {
    this[kHeaders] = val;
  }
  get headersDistinct() {
    if (!this[kHeadersDistinct]) {
      this[kHeadersDistinct] = {};
      const src = this.rawHeaders;
      const dst = this[kHeadersDistinct];
      for (let n = 0; n < this[kHeadersCount]; n += 2) {
        this._addHeaderLineDistinct(src[n], src[n + 1], dst);
      }
    }
    return this[kHeadersDistinct];
  }
  set headersDistinct(val) {
    this[kHeadersDistinct] = val;
  }
  get trailers() {
    if (!this[kTrailers]) {
      this[kTrailers] = {};
      const src = this.rawTrailers;
      const dst = this[kTrailers];
      for (let n = 0; n < this[kTrailersCount]; n += 2) {
        this._addHeaderLine(src[n], src[n + 1], dst);
      }
    }
    return this[kTrailers];
  }
  set trailers(val) {
    this[kTrailers] = val;
  }
  get trailersDistinct() {
    if (!this[kTrailersDistinct]) {
      this[kTrailersDistinct] = {};
      const src = this.rawTrailers;
      const dst = this[kTrailersDistinct];
      for (let n = 0; n < this[kTrailersCount]; n += 2) {
        this._addHeaderLineDistinct(src[n], src[n + 1], dst);
      }
    }
    return this[kTrailersDistinct];
  }
  set trailersDistinct(val) {
    this[kTrailersDistinct] = val;
  }
  setTimeout(msecs, callback) {
    return this;
  }
  async _read(n) {
    if (!this._consuming) {
      this._readableState.readingMore = false;
      this._consuming = true;
    }
    if (this._stream == null) {
      this.complete = true;
      this.push(null);
      return;
    }
    const reader = this._stream.getReader();
    try {
      const data = await reader.read();
      if (data.done) {
        this.complete = true;
        this.push(null);
      } else {
        this.push(data.value);
      }
    } catch (e) {
      this.destroy(e);
    } finally {
      reader.releaseLock();
    }
  }
  _destroy(err, cb) {
    if (!this.readableEnded || !this.complete) {
      this.aborted = true;
      this.emit("aborted");
    }
    setTimeout(onError, 0, this, err, cb);
  }
  _addHeaderLines(headers, n) {
    if (headers?.length) {
      let dest;
      if (this.complete) {
        this.rawTrailers = headers;
        this[kTrailersCount] = n;
        dest = this[kTrailers];
      } else {
        this.rawHeaders = headers;
        this[kHeadersCount] = n;
        dest = this[kHeaders];
      }
      if (dest) {
        for (let i = 0; i < n; i += 2) {
          this._addHeaderLine(headers[i], headers[i + 1], dest);
        }
      }
    }
  }
  // Add the given (field, value) pair to the message
  //
  // Per RFC2616, section 4.2 it is acceptable to join multiple instances of the
  // same header with a ', ' if the header in question supports specification of
  // multiple values this way. The one exception to this is the Cookie header,
  // which has multiple values joined with a '; ' instead. If a header's values
  // cannot be joined in either of these ways, we declare the first instance the
  // winner and drop the second. Extended header fields (those beginning with
  // 'x-') are always joined.
  _addHeaderLine(field, value, dest) {
    field = matchKnownFields(field);
    const flag = field.charCodeAt(0);
    if (flag === 0 || flag === 2) {
      field = field.slice(1);
      if (typeof dest[field] === "string") {
        dest[field] += (flag === 0 ? ", " : "; ") + value;
      } else {
        dest[field] = value;
      }
    } else if (flag === 1) {
      if (dest["set-cookie"] !== void 0) {
        dest["set-cookie"].push(value);
      } else {
        dest["set-cookie"] = [value];
      }
    } else if (this.joinDuplicateHeaders) {
      if (dest[field] === void 0) {
        dest[field] = value;
      } else {
        dest[field] += ", " + value;
      }
    } else if (dest[field] === void 0) {
      dest[field] = value;
    }
  }
  _addHeaderLineDistinct(field, value, dest) {
    field = field.toLowerCase();
    if (!dest[field]) {
      dest[field] = [value];
    } else {
      dest[field].push(value);
    }
  }
  // Call this instead of resume() if we want to just
  // dump all the data to /dev/null
  _dump() {
    if (!this._dumped) {
      this._dumped = true;
      this.removeAllListeners("data");
      this.resume();
    }
  }
};
function matchKnownFields(field, lowercased = false) {
  switch (field.length) {
    case 3:
      if (field === "Age" || field === "age")
        return "age";
      break;
    case 4:
      if (field === "Host" || field === "host")
        return "host";
      if (field === "From" || field === "from")
        return "from";
      if (field === "ETag" || field === "etag")
        return "etag";
      if (field === "Date" || field === "date")
        return "\0date";
      if (field === "Vary" || field === "vary")
        return "\0vary";
      break;
    case 6:
      if (field === "Server" || field === "server")
        return "server";
      if (field === "Cookie" || field === "cookie")
        return "cookie";
      if (field === "Origin" || field === "origin")
        return "\0origin";
      if (field === "Expect" || field === "expect")
        return "\0expect";
      if (field === "Accept" || field === "accept")
        return "\0accept";
      break;
    case 7:
      if (field === "Referer" || field === "referer")
        return "referer";
      if (field === "Expires" || field === "expires")
        return "expires";
      if (field === "Upgrade" || field === "upgrade")
        return "\0upgrade";
      break;
    case 8:
      if (field === "Location" || field === "location")
        return "location";
      if (field === "If-Match" || field === "if-match")
        return "\0if-match";
      break;
    case 10:
      if (field === "User-Agent" || field === "user-agent")
        return "user-agent";
      if (field === "Set-Cookie" || field === "set-cookie")
        return "
";
      if (field === "Connection" || field === "connection")
        return "\0connection";
      break;
    case 11:
      if (field === "Retry-After" || field === "retry-after")
        return "retry-after";
      break;
    case 12:
      if (field === "Content-Type" || field === "content-type")
        return "content-type";
      if (field === "Max-Forwards" || field === "max-forwards")
        return "max-forwards";
      break;
    case 13:
      if (field === "Authorization" || field === "authorization")
        return "authorization";
      if (field === "Last-Modified" || field === "last-modified")
        return "last-modified";
      if (field === "Cache-Control" || field === "cache-control")
        return "\0cache-control";
      if (field === "If-None-Match" || field === "if-none-match")
        return "\0if-none-match";
      break;
    case 14:
      if (field === "Content-Length" || field === "content-length")
        return "content-length";
      break;
    case 15:
      if (field === "Accept-Encoding" || field === "accept-encoding")
        return "\0accept-encoding";
      if (field === "Accept-Language" || field === "accept-language")
        return "\0accept-language";
      if (field === "X-Forwarded-For" || field === "x-forwarded-for")
        return "\0x-forwarded-for";
      break;
    case 16:
      if (field === "Content-Encoding" || field === "content-encoding")
        return "\0content-encoding";
      if (field === "X-Forwarded-Host" || field === "x-forwarded-host")
        return "\0x-forwarded-host";
      break;
    case 17:
      if (field === "If-Modified-Since" || field === "if-modified-since")
        return "if-modified-since";
      if (field === "Transfer-Encoding" || field === "transfer-encoding")
        return "\0transfer-encoding";
      if (field === "X-Forwarded-Proto" || field === "x-forwarded-proto")
        return "\0x-forwarded-proto";
      break;
    case 19:
      if (field === "Proxy-Authorization" || field === "proxy-authorization")
        return "proxy-authorization";
      if (field === "If-Unmodified-Since" || field === "if-unmodified-since")
        return "if-unmodified-since";
      break;
  }
  if (lowercased) {
    return "\0" + field;
  }
  return matchKnownFields(field.toLowerCase(), true);
}
function onError(self, error, cb) {
  if (self.listenerCount("error") === 0) {
    cb();
  } else {
    cb(error);
  }
}

// ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fetch-to-node/2.1.0/75a085586b95f3a18a440f8655a7cb5c851846ab2c5e6ad2c4ae036e3bbaa05c/node_modules/fetch-to-node/dist/utils/types.js
function validateString(value, name) {
  if (typeof value !== "string")
    throw new ERR_INVALID_ARG_TYPE(name, "string", value);
}
var linkValueRegExp = /^(?:<[^>]*>)(?:\s*;\s*[^;"\s]+(?:=(")?[^;"\s]*\1)?)*$/;
function validateLinkHeaderFormat(value, name) {
  if (typeof value === "undefined" || !linkValueRegExp.exec(value)) {
    throw new ERR_INVALID_ARG_VALUE(name, value, 'must be an array or string of format "</styles.css>; rel=preload; as=style"');
  }
}
function validateLinkHeaderValue(hints) {
  if (typeof hints === "string") {
    validateLinkHeaderFormat(hints, "hints");
    return hints;
  } else if (Array.isArray(hints)) {
    const hintsLength = hints.length;
    let result = "";
    if (hintsLength === 0) {
      return result;
    }
    for (let i = 0; i < hintsLength; i++) {
      const link = hints[i];
      validateLinkHeaderFormat(link, "hints");
      result += link;
      if (i !== hintsLength - 1) {
        result += ", ";
      }
    }
    return result;
  }
  throw new ERR_INVALID_ARG_VALUE("hints", hints, 'must be an array or string of format "</styles.css>; rel=preload; as=style"');
}
function isUint8Array(value) {
  return value != null && value[Symbol.toStringTag] === "Uint8Array";
}

// ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fetch-to-node/2.1.0/75a085586b95f3a18a440f8655a7cb5c851846ab2c5e6ad2c4ae036e3bbaa05c/node_modules/fetch-to-node/dist/fetch-to-node/internal-http.js
var kNeedDrain = /* @__PURE__ */ Symbol("kNeedDrain");
var kOutHeaders = /* @__PURE__ */ Symbol("kOutHeaders");
function utcDate() {
  return (/* @__PURE__ */ new Date()).toUTCString();
}

// ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fetch-to-node/2.1.0/75a085586b95f3a18a440f8655a7cb5c851846ab2c5e6ad2c4ae036e3bbaa05c/node_modules/fetch-to-node/dist/fetch-to-node/internal-streams-state.js
function getDefaultHighWaterMark(objectMode) {
  return objectMode ? 16 : 64 * 1024;
}

// ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fetch-to-node/2.1.0/75a085586b95f3a18a440f8655a7cb5c851846ab2c5e6ad2c4ae036e3bbaa05c/node_modules/fetch-to-node/dist/fetch-to-node/http-common.js
var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
function checkIsHttpToken(val) {
  return tokenRegExp.test(val);
}
var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
function checkInvalidHeaderChar(val) {
  return headerCharRegex.test(val);
}
var chunkExpression = /(?:^|\W)chunked(?:$|\W)/i;
var kCorked = /* @__PURE__ */ Symbol("corked");
var kChunkedBuffer = /* @__PURE__ */ Symbol("kChunkedBuffer");
var kChunkedLength = /* @__PURE__ */ Symbol("kChunkedLength");
var kUniqueHeaders = /* @__PURE__ */ Symbol("kUniqueHeaders");
var kBytesWritten = /* @__PURE__ */ Symbol("kBytesWritten");
var kErrored = /* @__PURE__ */ Symbol("errored");
var kHighWaterMark = /* @__PURE__ */ Symbol("kHighWaterMark");
var kRejectNonStandardBodyWrites = /* @__PURE__ */ Symbol("kRejectNonStandardBodyWrites");
var nop = () => {
};
var RE_CONN_CLOSE = /(?:^|\W)close(?:$|\W)/i;
function isCookieField(s) {
  return s.length === 6 && s.toLowerCase() === "cookie";
}
function isContentDispositionField(s) {
  return s.length === 19 && s.toLowerCase() === "content-disposition";
}
var WrittenDataBuffer = class {
  [kCorked] = 0;
  [kHighWaterMark] = getDefaultHighWaterMark();
  entries = [];
  onWrite;
  constructor(params = {}) {
    this.onWrite = params.onWrite;
  }
  write(data, encoding, callback) {
    this.entries.push({
      data,
      length: data.length,
      encoding,
      callback,
      written: false
    });
    this._flush();
    return true;
  }
  cork() {
    this[kCorked]++;
  }
  uncork() {
    this[kCorked]--;
    this._flush();
  }
  _flush() {
    if (this[kCorked] <= 0) {
      for (const [index, entry] of this.entries.entries()) {
        if (!entry.written) {
          entry.written = true;
          if (this.onWrite != null) {
            this.onWrite(index, entry);
          }
          if (entry.callback != null) {
            entry.callback.call(void 0);
          }
        }
      }
    }
  }
  get writableLength() {
    return this.entries.reduce((acc, entry) => {
      return acc + (entry.written && entry.length ? entry.length : 0);
    }, 0);
  }
  get writableHighWaterMark() {
    return this[kHighWaterMark];
  }
  get writableCorked() {
    return this[kCorked];
  }
};
var FetchOutgoingMessage = class extends stream.Writable {
  req;
  outputData;
  outputSize;
  // Difference from Node.js -
  // `writtenHeaderBytes` is the number of bytes the header has taken.
  // Since Node.js writes both the headers and body into the same outgoing
  // stream, it helps to keep track of this so that we can skip that many bytes
  // from the beginning of the stream when providing the outgoing stream.
  writtenHeaderBytes = 0;
  _last;
  chunkedEncoding;
  shouldKeepAlive;
  maxRequestsOnConnectionReached;
  _defaultKeepAlive;
  useChunkedEncodingByDefault;
  sendDate;
  _removedConnection;
  _removedContLen;
  _removedTE;
  strictContentLength;
  [kBytesWritten];
  _contentLength;
  _hasBody;
  _trailer;
  [kNeedDrain];
  finished;
  _headerSent;
  [kCorked];
  [kChunkedBuffer];
  [kChunkedLength];
  _closed;
  // Difference from Node.js -
  // In Node.js, this is a socket object.
  // [kSocket]: null;
  _header;
  [kOutHeaders];
  _keepAliveTimeout;
  _maxRequestsPerSocket;
  _onPendingData;
  [kUniqueHeaders];
  [kErrored];
  [kHighWaterMark];
  [kRejectNonStandardBodyWrites];
  _writtenDataBuffer = new WrittenDataBuffer({
    onWrite: this._onDataWritten.bind(this)
  });
  constructor(req, options) {
    super();
    this.req = req;
    this.outputData = [];
    this.outputSize = 0;
    this.destroyed = false;
    this._last = false;
    this.chunkedEncoding = false;
    this.shouldKeepAlive = true;
    this.maxRequestsOnConnectionReached = false;
    this._defaultKeepAlive = true;
    this.useChunkedEncodingByDefault = true;
    this.sendDate = false;
    this._removedConnection = false;
    this._removedContLen = false;
    this._removedTE = false;
    this.strictContentLength = false;
    this[kBytesWritten] = 0;
    this._contentLength = null;
    this._hasBody = true;
    this._trailer = "";
    this[kNeedDrain] = false;
    this.finished = false;
    this._headerSent = false;
    this[kCorked] = 0;
    this[kChunkedBuffer] = [];
    this[kChunkedLength] = 0;
    this._closed = false;
    this._header = null;
    this[kOutHeaders] = null;
    this._keepAliveTimeout = 0;
    this._onPendingData = nop;
    this[kErrored] = null;
    this[kHighWaterMark] = options?.highWaterMark ?? getDefaultHighWaterMark();
    this[kRejectNonStandardBodyWrites] = options?.rejectNonStandardBodyWrites ?? false;
    this[kUniqueHeaders] = null;
  }
  _renderHeaders() {
    if (this._header) {
      throw new ERR_HTTP_HEADERS_SENT("render");
    }
    const headersMap = this[kOutHeaders];
    const headers = {};
    if (headersMap !== null) {
      const keys = Object.keys(headersMap);
      for (let i = 0, l = keys.length; i < l; i++) {
        const key = keys[i];
        headers[headersMap[key][0]] = headersMap[key][1];
      }
    }
    return headers;
  }
  cork() {
    this[kCorked]++;
    if (this._writtenDataBuffer != null) {
      this._writtenDataBuffer.cork();
    }
  }
  uncork() {
    this[kCorked]--;
    if (this._writtenDataBuffer != null) {
      this._writtenDataBuffer.uncork();
    }
    if (this[kCorked] || this[kChunkedBuffer].length === 0) {
      return;
    }
    const buf = this[kChunkedBuffer];
    for (const { data, encoding, callback } of buf) {
      this._send(data ?? "", encoding, callback);
    }
    this[kChunkedBuffer].length = 0;
    this[kChunkedLength] = 0;
  }
  setTimeout(msecs, callback) {
    return this;
  }
  destroy(error) {
    if (this.destroyed) {
      return this;
    }
    this.destroyed = true;
    this[kErrored] = error;
    return this;
  }
  _send(data, encoding, callback, byteLength) {
    if (!this._headerSent) {
      const header = this._header;
      if (typeof data === "string" && (encoding === "utf8" || encoding === "latin1" || !encoding)) {
        data = header + data;
      } else {
        this.outputData.unshift({
          data: header,
          encoding: "latin1",
          callback: void 0
        });
        this.outputSize += header.length;
        this._onPendingData(header.length);
      }
      this._headerSent = true;
      this.writtenHeaderBytes = header.length;
      const [statusLine, ...headerLines] = this._header.split("\r\n");
      const STATUS_LINE_REGEXP = /^HTTP\/1\.1 (?<statusCode>\d+) (?<statusMessage>.*)$/;
      const statusLineResult = STATUS_LINE_REGEXP.exec(statusLine);
      if (statusLineResult == null) {
        throw new Error("Unexpected! Status line was " + statusLine);
      }
      const { statusCode: statusCodeText, statusMessage } = statusLineResult.groups ?? {};
      const statusCode = parseInt(statusCodeText, 10);
      const headers = [];
      for (const headerLine of headerLines) {
        if (headerLine !== "") {
          const pos = headerLine.indexOf(": ");
          const k = headerLine.slice(0, pos);
          const v = headerLine.slice(pos + 2);
          headers.push([k, v]);
        }
      }
      const event = {
        statusCode,
        statusMessage,
        headers
      };
      this.emit("_headersSent", event);
    }
    return this._writeRaw(data, encoding, callback, byteLength);
  }
  _writeRaw(data, encoding, callback, size) {
    if (typeof encoding === "function") {
      callback = encoding;
      encoding = null;
    }
    if (this._writtenDataBuffer != null) {
      if (this.outputData.length) {
        this._flushOutput(this._writtenDataBuffer);
      }
      return this._writtenDataBuffer.write(data, encoding, callback);
    }
    this.outputData.push({ data, encoding, callback });
    this.outputSize += data.length;
    this._onPendingData(data.length);
    return this.outputSize < this[kHighWaterMark];
  }
  _onDataWritten(index, entry) {
    const event = { index, entry };
    this.emit("_dataWritten", event);
  }
  _storeHeader(firstLine, headers) {
    const state = {
      connection: false,
      contLen: false,
      te: false,
      date: false,
      expect: false,
      trailer: false,
      header: firstLine
    };
    if (headers) {
      if (headers === this[kOutHeaders]) {
        for (const key in headers) {
          const entry = headers[key];
          processHeader(this, state, entry[0], entry[1], false);
        }
      } else if (Array.isArray(headers)) {
        if (headers.length && Array.isArray(headers[0])) {
          for (let i = 0; i < headers.length; i++) {
            const entry = headers[i];
            processHeader(this, state, entry[0], entry[1], true);
          }
        } else {
          if (headers.length % 2 !== 0) {
            throw new ERR_INVALID_ARG_VALUE("headers", headers);
          }
          for (let n = 0; n < headers.length; n += 2) {
            processHeader(this, state, headers[n], headers[n + 1], true);
          }
        }
      } else {
        for (const key in headers) {
          if (headers.hasOwnProperty(key)) {
            const _headers = headers;
            processHeader(this, state, key, _headers[key], true);
          }
        }
      }
    }
    let { header } = state;
    if (this.sendDate && !state.date) {
      header += "Date: " + utcDate() + "\r\n";
    }
    if (this.chunkedEncoding && (this.statusCode === 204 || this.statusCode === 304)) {
      this.chunkedEncoding = false;
      this.shouldKeepAlive = false;
    }
    if (this._removedConnection) {
      this._last = !this.shouldKeepAlive;
    } else if (!state.connection) {
      const shouldSendKeepAlive = this.shouldKeepAlive && (state.contLen || this.useChunkedEncodingByDefault);
      if (shouldSendKeepAlive && this.maxRequestsOnConnectionReached) {
        header += "Connection: close\r\n";
      } else if (shouldSendKeepAlive) {
        header += "Connection: keep-alive\r\n";
        if (this._keepAliveTimeout && this._defaultKeepAlive) {
          const timeoutSeconds = Math.floor(this._keepAliveTimeout / 1e3);
          let max = "";
          if (this._maxRequestsPerSocket && ~~this._maxRequestsPerSocket > 0) {
            max = `, max=${this._maxRequestsPerSocket}`;
          }
          header += `Keep-Alive: timeout=${timeoutSeconds}${max}\r
`;
        }
      } else {
        this._last = true;
        header += "Connection: close\r\n";
      }
    }
    if (!state.contLen && !state.te) {
      if (!this._hasBody) {
        this.chunkedEncoding = false;
      } else if (!this.useChunkedEncodingByDefault) {
        this._last = true;
      } else if (!state.trailer && !this._removedContLen && typeof this._contentLength === "number") {
        header += "Content-Length: " + this._contentLength + "\r\n";
      } else if (!this._removedTE) {
        header += "Transfer-Encoding: chunked\r\n";
        this.chunkedEncoding = true;
      } else {
        this._last = true;
      }
    }
    if (this.chunkedEncoding !== true && state.trailer) {
      throw new ERR_HTTP_TRAILER_INVALID();
    }
    this._header = header + "\r\n";
    this._headerSent = false;
    if (state.expect) {
      this._send("");
    }
  }
  get _headers() {
    console.warn("DEP0066: OutgoingMessage.prototype._headers is deprecated");
    return this.getHeaders();
  }
  set _headers(val) {
    console.warn("DEP0066: OutgoingMessage.prototype._headers is deprecated");
    if (val == null) {
      this[kOutHeaders] = null;
    } else if (typeof val === "object") {
      const headers = this[kOutHeaders] = /* @__PURE__ */ Object.create(null);
      const keys = Object.keys(val);
      for (let i = 0; i < keys.length; ++i) {
        const name = keys[i];
        headers[name.toLowerCase()] = [name, val[name]];
      }
    }
  }
  get connection() {
    return null;
  }
  set connection(_socket) {
    console.error("No support for OutgoingMessage.connection");
  }
  get socket() {
    return null;
  }
  set socket(_socket) {
    console.error("No support for OutgoingMessage.socket");
  }
  get _headerNames() {
    console.warn("DEP0066: OutgoingMessage.prototype._headerNames is deprecated");
    const headers = this[kOutHeaders];
    if (headers !== null) {
      const out = /* @__PURE__ */ Object.create(null);
      const keys = Object.keys(headers);
      for (let i = 0; i < keys.length; ++i) {
        const key = keys[i];
        const val = headers[key][0];
        out[key] = val;
      }
      return out;
    }
    return null;
  }
  set _headerNames(val) {
    console.warn("DEP0066: OutgoingMessage.prototype._headerNames is deprecated");
    if (typeof val === "object" && val !== null) {
      const headers = this[kOutHeaders];
      if (!headers)
        return;
      const keys = Object.keys(val);
      for (let i = 0; i < keys.length; ++i) {
        const header = headers[keys[i]];
        if (header)
          header[0] = val[keys[i]];
      }
    }
  }
  setHeader(name, value) {
    if (this._header) {
      throw new ERR_HTTP_HEADERS_SENT("set");
    }
    validateHeaderName(name);
    validateHeaderValue(name, value);
    let headers = this[kOutHeaders];
    if (headers === null) {
      this[kOutHeaders] = headers = { __proto__: null };
    }
    headers[name.toLowerCase()] = [name, value];
    return this;
  }
  setHeaders(headers) {
    if (this._header) {
      throw new ERR_HTTP_HEADERS_SENT("set");
    }
    if (!headers || Array.isArray(headers) || typeof headers.keys !== "function" || typeof headers.get !== "function") {
      throw new ERR_INVALID_ARG_TYPE("headers", ["Headers", "Map"], headers);
    }
    const cookies = [];
    for (const { 0: key, 1: value } of headers) {
      if (key === "set-cookie") {
        if (Array.isArray(value)) {
          cookies.push(...value);
        } else {
          cookies.push(value);
        }
        continue;
      }
      this.setHeader(key, value);
    }
    if (cookies.length) {
      this.setHeader("set-cookie", cookies);
    }
    return this;
  }
  appendHeader(name, value) {
    if (this._header) {
      throw new ERR_HTTP_HEADERS_SENT("append");
    }
    validateHeaderName(name);
    validateHeaderValue(name, value);
    const field = name.toLowerCase();
    const headers = this[kOutHeaders];
    if (headers === null || !headers[field]) {
      return this.setHeader(name, value);
    }
    if (!Array.isArray(headers[field][1])) {
      headers[field][1] = [headers[field][1]];
    }
    const existingValues = headers[field][1];
    if (Array.isArray(value)) {
      for (let i = 0, length = value.length; i < length; i++) {
        existingValues.push(value[i]);
      }
    } else {
      existingValues.push(value);
    }
    return this;
  }
  getHeader(name) {
    validateString(name, "name");
    const headers = this[kOutHeaders];
    if (headers === null) {
      return;
    }
    const entry = headers[name.toLowerCase()];
    return entry?.[1];
  }
  getHeaderNames() {
    return this[kOutHeaders] !== null ? Object.keys(this[kOutHeaders]) : [];
  }
  getRawHeaderNames() {
    const headersMap = this[kOutHeaders];
    if (headersMap === null)
      return [];
    const values = Object.values(headersMap);
    const headers = Array(values.length);
    for (let i = 0, l = values.length; i < l; i++) {
      headers[i] = values[i][0];
    }
    return headers;
  }
  getHeaders() {
    const headers = this[kOutHeaders];
    const ret = { __proto__: null };
    if (headers) {
      const keys = Object.keys(headers);
      for (let i = 0; i < keys.length; ++i) {
        const key = keys[i];
        const val = headers[key][1];
        ret[key] = val;
      }
    }
    return ret;
  }
  hasHeader(name) {
    validateString(name, "name");
    return this[kOutHeaders] !== null && !!this[kOutHeaders][name.toLowerCase()];
  }
  removeHeader(name) {
    validateString(name, "name");
    if (this._header) {
      throw new ERR_HTTP_HEADERS_SENT("remove");
    }
    const key = name.toLowerCase();
    switch (key) {
      case "connection":
        this._removedConnection = true;
        break;
      case "content-length":
        this._removedContLen = true;
        break;
      case "transfer-encoding":
        this._removedTE = true;
        break;
      case "date":
        this.sendDate = false;
        break;
    }
    if (this[kOutHeaders] !== null) {
      delete this[kOutHeaders][key];
    }
  }
  _implicitHeader() {
    throw new ERR_METHOD_NOT_IMPLEMENTED("_implicitHeader()");
  }
  get headersSent() {
    return !!this._header;
  }
  write(chunk, encoding, callback) {
    if (typeof encoding === "function") {
      callback = encoding;
      encoding = null;
    }
    const ret = write_(this, chunk, encoding, callback, false);
    if (!ret) {
      this[kNeedDrain] = true;
    }
    return ret;
  }
  addTrailers(headers) {
    this._trailer = "";
    const isArray = Array.isArray(headers);
    const keys = isArray ? [...headers.keys()] : Object.keys(headers);
    for (let i = 0, l = keys.length; i < l; i++) {
      let field, value;
      if (isArray) {
        const _headers = headers;
        const key = keys[i];
        field = _headers[key][0];
        value = _headers[key][1];
      } else {
        const _headers = headers;
        const key = keys[i];
        field = key;
        value = _headers[key];
      }
      validateHeaderName(field, "Trailer name");
      if (Array.isArray(value) && value.length > 1 && (!this[kUniqueHeaders] || !this[kUniqueHeaders].has(field.toLowerCase()))) {
        for (let j = 0, l2 = value.length; j < l2; j++) {
          if (checkInvalidHeaderChar(value[j])) {
            throw new ERR_INVALID_CHAR("trailer content", field);
          }
          this._trailer += field + ": " + value[j] + "\r\n";
        }
      } else {
        if (Array.isArray(value)) {
          value = value.join("; ");
        }
        if (checkInvalidHeaderChar(String(value))) {
          throw new ERR_INVALID_CHAR("trailer content", field);
        }
        this._trailer += field + ": " + value + "\r\n";
      }
    }
  }
  end(chunk, encoding, callback) {
    if (typeof chunk === "function") {
      callback = chunk;
      chunk = null;
      encoding = null;
    } else if (typeof encoding === "function") {
      callback = encoding;
      encoding = null;
    }
    if (chunk) {
      if (this.finished) {
        onError2(this, new ERR_STREAM_WRITE_AFTER_END(), typeof callback !== "function" ? nop : callback);
        return this;
      }
      if (this._writtenDataBuffer != null) {
        this._writtenDataBuffer.cork();
      }
      write_(this, chunk, encoding, null, true);
    } else if (this.finished) {
      if (typeof callback === "function") {
        if (!this.writableFinished) {
          this.on("finish", callback);
        } else {
          callback(new ERR_STREAM_ALREADY_FINISHED("end"));
        }
      }
      return this;
    } else if (!this._header) {
      if (this._writtenDataBuffer != null) {
        this._writtenDataBuffer.cork();
      }
      this._contentLength = 0;
      this._implicitHeader();
    }
    if (typeof callback === "function")
      this.once("finish", callback);
    if (strictContentLength(this) && this[kBytesWritten] !== this._contentLength) {
      throw new ERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten], this._contentLength);
    }
    const finish = onFinish.bind(void 0, this);
    if (this._hasBody && this.chunkedEncoding) {
      this._send("", "latin1", finish);
    } else if (!this._headerSent || this.writableLength || chunk) {
      this._send("", "latin1", finish);
    } else {
      setTimeout(finish, 0);
    }
    if (this._writtenDataBuffer != null) {
      this._writtenDataBuffer.uncork();
    }
    this[kCorked] = 1;
    this.uncork();
    this.finished = true;
    if (this.outputData.length === 0 && this._writtenDataBuffer != null) {
      this._finish();
    }
    return this;
  }
  _finish() {
    this.emit("prefinish");
  }
  // No _flush() implementation?
  _flush() {
    if (this._writtenDataBuffer != null) {
      const ret = this._flushOutput(this._writtenDataBuffer);
      if (this.finished) {
        this._finish();
      } else if (ret && this[kNeedDrain]) {
        this[kNeedDrain] = false;
        this.emit("drain");
      }
    }
  }
  _flushOutput(dataBuffer) {
    while (this[kCorked]) {
      this[kCorked]--;
      dataBuffer.cork();
    }
    const outputLength = this.outputData.length;
    if (outputLength <= 0) {
      return void 0;
    }
    const outputData = this.outputData;
    dataBuffer.cork();
    let ret;
    for (let i = 0; i < outputLength; i++) {
      const { data, encoding, callback } = outputData[i];
      outputData[i].data = null;
      ret = dataBuffer.write(data ?? "", encoding, callback);
    }
    dataBuffer.uncork();
    this.outputData = [];
    this._onPendingData(-this.outputSize);
    this.outputSize = 0;
    return ret;
  }
  flushHeaders() {
    if (!this._header) {
      this._implicitHeader();
    }
    this._send("");
  }
  pipe(destination) {
    this.emit("error", new ERR_STREAM_CANNOT_PIPE());
    return destination;
  }
};
function processHeader(self, state, key, value, validate) {
  if (validate) {
    validateHeaderName(key);
  }
  if (isContentDispositionField(key) && self._contentLength) {
    if (Array.isArray(value)) {
      for (let i = 0; i < value.length; i++) {
        value[i] = String(buffer.Buffer.from(String(value[i]), "latin1"));
      }
    } else {
      value = String(buffer.Buffer.from(String(value), "latin1"));
    }
  }
  if (Array.isArray(value)) {
    if ((value.length < 2 || !isCookieField(key)) && (!self[kUniqueHeaders] || !self[kUniqueHeaders].has(key.toLowerCase()))) {
      for (let i = 0; i < value.length; i++) {
        storeHeader(self, state, key, value[i], validate);
      }
      return;
    }
    value = value.join("; ");
  }
  storeHeader(self, state, key, String(value), validate);
}
function storeHeader(self, state, key, value, validate) {
  if (validate) {
    validateHeaderValue(key, value);
  }
  state.header += key + ": " + value + "\r\n";
  matchHeader(self, state, key, value);
}
function validateHeaderName(name, label) {
  if (typeof name !== "string" || !name || !checkIsHttpToken(name)) {
    throw new ERR_INVALID_HTTP_TOKEN(label || "Header name", name);
  }
}
function validateHeaderValue(name, value) {
  if (value === void 0) {
    throw new ERR_HTTP_INVALID_HEADER_VALUE(String(value), name);
  }
  if (checkInvalidHeaderChar(String(value))) {
    throw new ERR_INVALID_CHAR("header content", name);
  }
}
function matchHeader(self, state, field, value) {
  if (field.length < 4 || field.length > 17)
    return;
  field = field.toLowerCase();
  switch (field) {
    case "connection":
      state.connection = true;
      self._removedConnection = false;
      if (RE_CONN_CLOSE.exec(value) !== null)
        self._last = true;
      else
        self.shouldKeepAlive = true;
      break;
    case "transfer-encoding":
      state.te = true;
      self._removedTE = false;
      if (chunkExpression.exec(value) !== null)
        self.chunkedEncoding = true;
      break;
    case "content-length":
      state.contLen = true;
      self._contentLength = +value;
      self._removedContLen = false;
      break;
    case "date":
    case "expect":
    case "trailer":
      state[field] = true;
      break;
    case "keep-alive":
      self._defaultKeepAlive = false;
      break;
  }
}
function onError2(msg, err, callback) {
  if (msg.destroyed) {
    return;
  }
  setTimeout(emitErrorNt, 0, msg, err, callback);
}
function emitErrorNt(msg, err, callback) {
  callback(err);
  if (typeof msg.emit === "function" && !msg.destroyed) {
    msg.emit("error", err);
  }
}
function strictContentLength(msg) {
  return msg.strictContentLength && msg._contentLength != null && msg._hasBody && !msg._removedContLen && !msg.chunkedEncoding && !msg.hasHeader("transfer-encoding");
}
function write_(msg, chunk, encoding, callback, fromEnd) {
  if (typeof callback !== "function") {
    callback = nop;
  }
  if (chunk === null) {
    throw new ERR_STREAM_NULL_VALUES();
  } else if (typeof chunk !== "string" && !isUint8Array(chunk)) {
    throw new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
  }
  let err = void 0;
  if (msg.finished) {
    err = new ERR_STREAM_WRITE_AFTER_END();
  } else if (msg.destroyed) {
    err = new ERR_STREAM_DESTROYED("write");
  }
  if (err) {
    if (!msg.destroyed) {
      onError2(msg, err, callback);
    } else {
      setTimeout(callback, 0, err);
    }
    return false;
  }
  let len = void 0;
  if (msg.strictContentLength) {
    len ??= typeof chunk === "string" ? buffer.Buffer.byteLength(chunk, encoding ?? void 0) : chunk.byteLength;
    if (strictContentLength(msg) && (fromEnd ? msg[kBytesWritten] + len !== msg._contentLength : msg[kBytesWritten] + len > (msg._contentLength ?? 0))) {
      throw new ERR_HTTP_CONTENT_LENGTH_MISMATCH(len + msg[kBytesWritten], msg._contentLength);
    }
    msg[kBytesWritten] += len;
  }
  if (!msg._header) {
    if (fromEnd) {
      len ??= typeof chunk === "string" ? buffer.Buffer.byteLength(chunk, encoding ?? void 0) : chunk.byteLength;
      msg._contentLength = len;
    }
    msg._implicitHeader();
  }
  if (!msg._hasBody) {
    if (msg[kRejectNonStandardBodyWrites]) {
      throw new ERR_HTTP_BODY_NOT_ALLOWED();
    } else {
      setTimeout(callback, 0);
      return true;
    }
  }
  if (!fromEnd && msg._writtenDataBuffer != null && !msg._writtenDataBuffer.writableCorked) {
    msg._writtenDataBuffer.cork();
    setTimeout(connectionCorkNT, 0, msg._writtenDataBuffer);
  }
  let ret;
  if (msg.chunkedEncoding && chunk.length !== 0) {
    len ??= typeof chunk === "string" ? buffer.Buffer.byteLength(chunk, encoding ?? void 0) : chunk.byteLength;
    if (msg[kCorked] && msg._headerSent) {
      msg[kChunkedBuffer].push({ data: chunk, encoding, callback });
      msg[kChunkedLength] += len;
      ret = msg[kChunkedLength] < msg[kHighWaterMark];
    } else {
      ret = msg._send(chunk, encoding, callback, len);
    }
  } else {
    ret = msg._send(chunk, encoding, callback, len);
  }
  return ret;
}
function connectionCorkNT(dataBuffer) {
  dataBuffer.uncork();
}
function onFinish(outmsg) {
  outmsg.emit("finish");
}
Object.defineProperties(FetchOutgoingMessage.prototype, {
  errored: {
    get() {
      return this[kErrored];
    }
  },
  closed: {
    get() {
      return this._closed;
    }
  },
  writableFinished: {
    get() {
      return this.finished && this.outputSize === 0 && (this._writtenDataBuffer == null || this._writtenDataBuffer.writableLength === 0);
    }
  },
  writableObjectMode: {
    get() {
      return false;
    }
  },
  writableLength: {
    get() {
      return this.outputSize + this[kChunkedLength] + (this._writtenDataBuffer != null ? this._writtenDataBuffer.writableLength : 0);
    }
  },
  writableHighWaterMark: {
    get() {
      return this._writtenDataBuffer != null ? this._writtenDataBuffer.writableHighWaterMark : this[kHighWaterMark];
    }
  },
  writableCorked: {
    get() {
      return this[kCorked];
    }
  },
  writableEnded: {
    get() {
      return this.finished;
    }
  },
  writableNeedDrain: {
    get() {
      return !this.destroyed && !this.finished && this[kNeedDrain];
    }
  }
});
var headerCharRegex2 = /[^\t\x20-\x7e\x80-\xff]/;
function checkInvalidHeaderChar2(val) {
  return headerCharRegex2.test(val);
}
var STATUS_CODES = {
  100: "Continue",
  // RFC 7231 6.2.1
  101: "Switching Protocols",
  // RFC 7231 6.2.2
  102: "Processing",
  // RFC 2518 10.1 (obsoleted by RFC 4918)
  103: "Early Hints",
  // RFC 8297 2
  200: "OK",
  // RFC 7231 6.3.1
  201: "Created",
  // RFC 7231 6.3.2
  202: "Accepted",
  // RFC 7231 6.3.3
  203: "Non-Authoritative Information",
  // RFC 7231 6.3.4
  204: "No Content",
  // RFC 7231 6.3.5
  205: "Reset Content",
  // RFC 7231 6.3.6
  206: "Partial Content",
  // RFC 7233 4.1
  207: "Multi-Status",
  // RFC 4918 11.1
  208: "Already Reported",
  // RFC 5842 7.1
  226: "IM Used",
  // RFC 3229 10.4.1
  300: "Multiple Choices",
  // RFC 7231 6.4.1
  301: "Moved Permanently",
  // RFC 7231 6.4.2
  302: "Found",
  // RFC 7231 6.4.3
  303: "See Other",
  // RFC 7231 6.4.4
  304: "Not Modified",
  // RFC 7232 4.1
  305: "Use Proxy",
  // RFC 7231 6.4.5
  307: "Temporary Redirect",
  // RFC 7231 6.4.7
  308: "Permanent Redirect",
  // RFC 7238 3
  400: "Bad Request",
  // RFC 7231 6.5.1
  401: "Unauthorized",
  // RFC 7235 3.1
  402: "Payment Required",
  // RFC 7231 6.5.2
  403: "Forbidden",
  // RFC 7231 6.5.3
  404: "Not Found",
  // RFC 7231 6.5.4
  405: "Method Not Allowed",
  // RFC 7231 6.5.5
  406: "Not Acceptable",
  // RFC 7231 6.5.6
  407: "Proxy Authentication Required",
  // RFC 7235 3.2
  408: "Request Timeout",
  // RFC 7231 6.5.7
  409: "Conflict",
  // RFC 7231 6.5.8
  410: "Gone",
  // RFC 7231 6.5.9
  411: "Length Required",
  // RFC 7231 6.5.10
  412: "Precondition Failed",
  // RFC 7232 4.2
  413: "Payload Too Large",
  // RFC 7231 6.5.11
  414: "URI Too Long",
  // RFC 7231 6.5.12
  415: "Unsupported Media Type",
  // RFC 7231 6.5.13
  416: "Range Not Satisfiable",
  // RFC 7233 4.4
  417: "Expectation Failed",
  // RFC 7231 6.5.14
  418: "I'm a Teapot",
  // RFC 7168 2.3.3
  421: "Misdirected Request",
  // RFC 7540 9.1.2
  422: "Unprocessable Entity",
  // RFC 4918 11.2
  423: "Locked",
  // RFC 4918 11.3
  424: "Failed Dependency",
  // RFC 4918 11.4
  425: "Too Early",
  // RFC 8470 5.2
  426: "Upgrade Required",
  // RFC 2817 and RFC 7231 6.5.15
  428: "Precondition Required",
  // RFC 6585 3
  429: "Too Many Requests",
  // RFC 6585 4
  431: "Request Header Fields Too Large",
  // RFC 6585 5
  451: "Unavailable For Legal Reasons",
  // RFC 7725 3
  500: "Internal Server Error",
  // RFC 7231 6.6.1
  501: "Not Implemented",
  // RFC 7231 6.6.2
  502: "Bad Gateway",
  // RFC 7231 6.6.3
  503: "Service Unavailable",
  // RFC 7231 6.6.4
  504: "Gateway Timeout",
  // RFC 7231 6.6.5
  505: "HTTP Version Not Supported",
  // RFC 7231 6.6.6
  506: "Variant Also Negotiates",
  // RFC 2295 8.1
  507: "Insufficient Storage",
  // RFC 4918 11.5
  508: "Loop Detected",
  // RFC 5842 7.2
  509: "Bandwidth Limit Exceeded",
  510: "Not Extended",
  // RFC 2774 7
  511: "Network Authentication Required"
  // RFC 6585 6
};
var FetchServerResponse = class _FetchServerResponse extends FetchOutgoingMessage {
  static encoder = new TextEncoder();
  statusCode = 200;
  statusMessage;
  _sent100;
  _expect_continue;
  [kOutHeaders] = null;
  constructor(req, options) {
    super(req, options);
    if (req.method === "HEAD") {
      this._hasBody = false;
    }
    this.sendDate = true;
    this._sent100 = false;
    this._expect_continue = false;
    if (req.httpVersionMajor < 1 || req.httpVersionMinor < 1) {
      this.useChunkedEncodingByDefault = chunkExpression.exec(String(req.headers.te)) !== null;
      this.shouldKeepAlive = false;
    }
    this.fetchResponse = new Promise((resolve) => {
      let finished = false;
      this.on("finish", () => {
        finished = true;
      });
      const initialDataChunks = [];
      const initialDataWrittenHandler = (e) => {
        if (finished) {
          return;
        }
        initialDataChunks[e.index] = this.dataFromDataWrittenEvent(e);
      };
      this.on("_dataWritten", initialDataWrittenHandler);
      this.on("_headersSent", (e) => {
        this.off("_dataWritten", initialDataWrittenHandler);
        const { statusCode, statusMessage, headers } = e;
        resolve(this._toFetchResponse(statusCode, statusMessage, headers, initialDataChunks, finished));
      });
    });
  }
  dataFromDataWrittenEvent(e) {
    const { index, entry } = e;
    let { data, encoding } = entry;
    if (index === 0) {
      if (typeof data !== "string") {
        console.error("First chunk should be string, not sure what happened.");
        throw new ERR_INVALID_ARG_TYPE("packet.data", ["string", "Buffer", "Uint8Array"], data);
      }
      data = data.slice(this.writtenHeaderBytes);
    }
    if (typeof data === "string") {
      if (encoding === void 0 || encoding === "utf8" || encoding === "utf-8") {
        data = _FetchServerResponse.encoder.encode(data);
      } else {
        data = buffer.Buffer.from(data, encoding ?? void 0);
      }
    }
    return data ?? buffer.Buffer.from([]);
  }
  _finish() {
    super._finish();
  }
  assignSocket(socket) {
    throw new ERR_METHOD_NOT_IMPLEMENTED("assignSocket");
  }
  detachSocket(socket) {
    throw new ERR_METHOD_NOT_IMPLEMENTED("detachSocket");
  }
  writeContinue(callback) {
    this._writeRaw("HTTP/1.1 100 Continue\r\n\r\n", "ascii", callback);
    this._sent100 = true;
  }
  writeProcessing(callback) {
    this._writeRaw("HTTP/1.1 102 Processing\r\n\r\n", "ascii", callback);
  }
  writeEarlyHints(hints, callback) {
    let head = "HTTP/1.1 103 Early Hints\r\n";
    if (hints.link === null || hints.link === void 0) {
      return;
    }
    const link = validateLinkHeaderValue(hints.link);
    if (link.length === 0) {
      return;
    }
    head += "Link: " + link + "\r\n";
    for (const key of Object.keys(hints)) {
      if (key !== "link") {
        head += key + ": " + hints[key] + "\r\n";
      }
    }
    head += "\r\n";
    this._writeRaw(head, "ascii", callback);
  }
  _implicitHeader() {
    this.writeHead(this.statusCode);
  }
  writeHead(statusCode, reason, obj) {
    if (this._header) {
      throw new ERR_HTTP_HEADERS_SENT("write");
    }
    const originalStatusCode = statusCode;
    statusCode |= 0;
    if (statusCode < 100 || statusCode > 999) {
      throw new ERR_HTTP_INVALID_STATUS_CODE(originalStatusCode);
    }
    if (typeof reason === "string") {
      this.statusMessage = reason;
    } else {
      this.statusMessage ||= STATUS_CODES[statusCode] || "unknown";
      obj ??= reason;
    }
    this.statusCode = statusCode;
    let headers;
    if (this[kOutHeaders]) {
      let k;
      if (Array.isArray(obj)) {
        if (obj.length % 2 !== 0) {
          throw new ERR_INVALID_ARG_VALUE("headers", obj);
        }
        for (let n = 0; n < obj.length; n += 2) {
          k = obj[n + 0];
          this.removeHeader(String(k));
        }
        for (let n = 0; n < obj.length; n += 2) {
          k = obj[n];
          if (k) {
            this.appendHeader(String(k), obj[n + 1]);
          }
        }
      } else if (obj) {
        const keys = Object.keys(obj);
        for (let i = 0; i < keys.length; i++) {
          k = keys[i];
          if (k) {
            this.setHeader(k, obj[k]);
          }
        }
      }
      headers = this[kOutHeaders];
    } else {
      headers = obj;
    }
    if (checkInvalidHeaderChar2(this.statusMessage)) {
      throw new ERR_INVALID_CHAR("statusMessage");
    }
    const statusLine = `HTTP/1.1 ${statusCode} ${this.statusMessage}\r
`;
    if (statusCode === 204 || statusCode === 304 || statusCode >= 100 && statusCode <= 199) {
      this._hasBody = false;
    }
    if (this._expect_continue && !this._sent100) {
      this.shouldKeepAlive = false;
    }
    const convertedHeaders = headers && !Array.isArray(headers) ? headers : headers;
    this._storeHeader(statusLine, convertedHeaders ?? null);
    return this;
  }
  // Docs-only deprecated: DEP0063
  writeHeader = this.writeHead;
  fetchResponse;
  _toFetchResponse(status, statusText, sentHeaders, initialDataChunks, finished) {
    const headers = new Headers();
    for (const [header, value] of sentHeaders) {
      headers.append(header, value);
    }
    const _this = this;
    let body = this._hasBody ? new ReadableStream({
      start(controller) {
        for (const dataChunk of initialDataChunks) {
          controller.enqueue(dataChunk);
        }
        if (finished) {
          controller.close();
        } else {
          _this.on("finish", () => {
            finished = true;
            controller.close();
          });
          _this.on("_dataWritten", (e) => {
            if (finished) {
              return;
            }
            const data = _this.dataFromDataWrittenEvent(e);
            controller.enqueue(data);
          });
        }
      }
    }) : null;
    if (body != null && typeof FixedLengthStream !== "undefined") {
      const contentLength = parseInt(headers.get("content-length") ?? "", 10);
      if (contentLength >= 0) {
        body = body.pipeThrough(new FixedLengthStream(contentLength));
      }
    }
    return new Response(body, {
      status,
      statusText,
      headers
    });
  }
};
function toReqRes(req, options) {
  const { createIncomingMessage = () => new FetchIncomingMessage(), createServerResponse = (incoming2) => new FetchServerResponse(incoming2), ctx } = {};
  const incoming = createIncomingMessage(ctx);
  const serverResponse = createServerResponse(incoming, ctx);
  const reqUrl = new URL(req.url);
  const versionMajor = 1;
  const versionMinor = 1;
  incoming.httpVersionMajor = versionMajor;
  incoming.httpVersionMinor = versionMinor;
  incoming.httpVersion = `${versionMajor}.${versionMinor}`;
  incoming.url = reqUrl.pathname + reqUrl.search;
  incoming.upgrade = false;
  const headers = [];
  for (const [headerName, headerValue] of req.headers) {
    headers.push(headerName);
    headers.push(headerValue);
  }
  incoming._addHeaderLines(headers, headers.length);
  incoming.method = req.method;
  incoming._stream = req.body;
  return {
    req: incoming,
    res: serverResponse
  };
}
function toFetchResponse(res) {
  if (!(res instanceof FetchServerResponse)) {
    throw new Error("toFetchResponse must be called on a ServerResponse generated by toReqRes");
  }
  return res.fetchResponse;
}
async function setupBrowserStream(app, config) {
  let createNodeWebSocket;
  try {
    const mod = "@hono/node-ws";
    const honoNodeWs = await import(
      /* @vite-ignore */
      /* webpackIgnore: true */
      mod
    );
    createNodeWebSocket = honoNodeWs.createNodeWebSocket;
  } catch {
    return null;
  }
  const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
  const registry = new browserStream.ViewerRegistry();
  const rawPrefix = config.apiPrefix ?? "/api";
  const trimmed = rawPrefix.endsWith("/") ? rawPrefix.slice(0, -1) : rawPrefix;
  const apiPrefix = trimmed || "/api";
  app.get(
    "/browser/:agentId/stream",
    upgradeWebSocket((c) => {
      const agentId = c.req.param("agentId");
      const threadId = c.req.query("threadId");
      const viewerKey = threadId ? `${agentId}:${threadId}` : agentId;
      return {
        onOpen(_event, ws) {
          ws.send(JSON.stringify({ status: "connected" }));
          void registry.addViewer(viewerKey, ws, config.getToolset, agentId, threadId);
        },
        onMessage(event, _ws) {
          const data = typeof event.data === "string" ? event.data : null;
          if (data) {
            void browserStream.handleInputMessage(data, config.getToolset, agentId, threadId);
          }
        },
        onClose(_event, ws) {
          void registry.removeViewer(viewerKey, ws);
        },
        onError(event, ws) {
          console.error("[BrowserStream] WebSocket error:", event);
          void registry.removeViewer(viewerKey, ws);
        }
      };
    })
  );
  app.get(`${apiPrefix}/agents/:agentId/browser/session`, async (c) => {
    const agentId = c.req.param("agentId");
    if (!agentId) {
      return c.json({ error: "Agent ID is required" }, 400);
    }
    const threadId = c.req.query("threadId");
    const toolset = await config.getToolset(agentId);
    if (!toolset) {
      return c.json({ hasSession: false, screencastAvailable: true });
    }
    const hasSession = threadId ? toolset.hasThreadSession(threadId) : false;
    return c.json({ hasSession, screencastAvailable: true });
  });
  app.post(`${apiPrefix}/agents/:agentId/browser/close`, async (c) => {
    const agentId = c.req.param("agentId");
    if (!agentId) {
      return c.json({ error: "Agent ID is required" }, 400);
    }
    const toolset = await config.getToolset(agentId);
    if (!toolset) {
      return c.json({ error: "No browser session for this agent" }, 404);
    }
    try {
      let threadId;
      try {
        const body = await c.req.json();
        threadId = body?.threadId;
      } catch {
      }
      const scope = toolset.getScope();
      const viewerKey = threadId ? `${agentId}:${threadId}` : agentId;
      if (scope === "thread" && threadId) {
        await registry.closeBrowserSession(viewerKey);
        if ("closeThreadSession" in toolset && typeof toolset.closeThreadSession === "function") {
          await toolset.closeThreadSession(threadId);
        }
      } else {
        await registry.closeBrowserSession(viewerKey);
        await toolset.close();
      }
      return c.json({ success: true });
    } catch (error) {
      console.error(`[BrowserStream] Error closing browser for ${agentId}:`, error);
      return c.json({ error: "Failed to close browser" }, 500);
    }
  });
  return { injectWebSocket, registry };
}
var _hasPermissionPromise;
function loadHasPermission() {
  if (!_hasPermissionPromise) {
    _hasPermissionPromise = import('@mastra/core/auth/ee').then((m) => m.hasPermission).catch(() => {
      console.error(
        "[@mastra/hono] Auth features require @mastra/core >= 1.6.0. Please upgrade: npm install @mastra/core@latest"
      );
      return void 0;
    });
  }
  return _hasPermissionPromise;
}
var MastraServer = class extends serverAdapter.MastraServer {
  createContextMiddleware() {
    return async (c, next) => {
      const originalJson = c.req.json.bind(c.req);
      let jsonPromise;
      c.req.json = () => {
        if (!jsonPromise) {
          jsonPromise = originalJson().then((body) => {
            c.set("cachedBody", body);
            return body;
          });
        }
        return jsonPromise;
      };
      let bodyRequestContext;
      let paramsRequestContext;
      if (c.req.method === "POST" || c.req.method === "PUT") {
        const contentType = c.req.header("content-type");
        const contentLength = c.req.header("content-length");
        if (contentType?.includes("application/json") && contentLength !== "0") {
          try {
            const body = await c.req.raw.clone().json();
            if (body.requestContext) {
              bodyRequestContext = body.requestContext;
            }
          } catch {
          }
        }
      }
      if (c.req.method === "GET") {
        try {
          const encodedRequestContext = c.req.query("requestContext");
          if (encodedRequestContext) {
            try {
              paramsRequestContext = JSON.parse(encodedRequestContext);
            } catch {
              try {
                const json = Buffer.from(encodedRequestContext, "base64").toString("utf-8");
                paramsRequestContext = JSON.parse(json);
              } catch {
              }
            }
          }
        } catch {
        }
      }
      const requestContext = this.mergeRequestContext({ paramsRequestContext, bodyRequestContext });
      this.applyRequestMetadataToContext({
        requestContext,
        getHeader: (name) => c.req.header(name)
      });
      c.set("requestContext", requestContext);
      c.set("mastra", this.mastra);
      c.set("registeredTools", this.tools || {});
      c.set("taskStore", this.taskStore);
      c.set("abortSignal", c.req.raw.signal);
      c.set("customRouteAuthConfig", this.customRouteAuthConfig);
      return next();
    };
  }
  async stream(route, res, result) {
    const streamFormat = route.streamFormat || "stream";
    if (streamFormat === "sse") {
      res.header("Content-Type", "text/event-stream");
      res.header("Cache-Control", "no-cache");
      res.header("Connection", "keep-alive");
      res.header("X-Accel-Buffering", "no");
    } else {
      res.header("Content-Type", "text/plain");
    }
    res.header("Transfer-Encoding", "chunked");
    return streaming.stream(
      res,
      async (stream2) => {
        if (streamFormat === "sse" && route.sseFlushOnConnect) {
          await stream2.write(": connected\n\n");
        }
        const readableStream = result instanceof ReadableStream ? result : result.fullStream;
        const reader = readableStream.getReader();
        stream2.onAbort(() => {
          void reader.cancel("request aborted");
        });
        try {
          while (true) {
            const { done, value } = await reader.read();
            if (done) break;
            if (value) {
              if (streamFormat === "sse" && typeof value === "string" && value.startsWith(":")) {
                await stream2.write(value);
                continue;
              }
              const shouldRedact = this.streamOptions?.redact ?? true;
              const outputValue = shouldRedact ? serverAdapter.redactStreamChunk(value) : value;
              if (streamFormat === "sse") {
                await stream2.write(`data: ${JSON.stringify(outputValue)}

`);
              } else {
                await stream2.write(JSON.stringify(outputValue) + "");
              }
            }
          }
          if (streamFormat === "sse") {
            await stream2.write("data: [DONE]\n\n");
          }
        } catch (error) {
          this.mastra.getLogger()?.error("Error in stream processing", {
            error: error instanceof Error ? { message: error.message, stack: error.stack } : error
          });
        } finally {
          await stream2.close();
        }
      },
      async (err) => {
        this.mastra.getLogger()?.error("Stream error callback", {
          error: err instanceof Error ? { message: err.message, stack: err.stack } : err
        });
      }
    );
  }
  async getParams(route, request) {
    const urlParams = request.param();
    const queryParams = serverAdapter.normalizeQueryParams(request.queries());
    let body;
    let bodyParseError;
    if (route.method === "POST" || route.method === "PUT" || route.method === "PATCH" || route.method === "DELETE") {
      const contentType = request.header("content-type") || "";
      if (contentType.includes("multipart/form-data")) {
        try {
          const formData = await request.formData();
          body = await this.parseFormData(formData);
        } catch (error) {
          this.mastra.getLogger()?.error("Failed to parse multipart form data", {
            error: error instanceof Error ? { message: error.message, stack: error.stack } : error
          });
          if (error instanceof Error && error.message.toLowerCase().includes("size")) {
            throw error;
          }
          bodyParseError = {
            message: error instanceof Error ? error.message : "Failed to parse multipart form data"
          };
        }
      } else if (contentType.includes("application/json")) {
        const clonedReq = request.raw.clone();
        const bodyText = await clonedReq.text();
        if (bodyText && bodyText.trim().length > 0) {
          try {
            body = JSON.parse(bodyText);
          } catch (error) {
            this.mastra.getLogger()?.error("Failed to parse JSON body", {
              error: error instanceof Error ? { message: error.message, stack: error.stack } : error
            });
            bodyParseError = {
              message: error instanceof Error ? error.message : "Invalid JSON in request body"
            };
          }
        }
      }
    }
    return { urlParams, queryParams, body, bodyParseError };
  }
  /**
   * Parse FormData into a plain object, converting File objects to Buffers.
   */
  async parseFormData(formData) {
    const result = {};
    for (const [key, value] of formData.entries()) {
      if (value instanceof File) {
        const arrayBuffer = await value.arrayBuffer();
        result[key] = Buffer.from(arrayBuffer);
      } else if (typeof value === "string") {
        try {
          result[key] = JSON.parse(value);
        } catch {
          result[key] = value;
        }
      } else {
        result[key] = value;
      }
    }
    return result;
  }
  async sendResponse(route, response, result, prefix) {
    const resolvedPrefix = prefix ?? this.prefix ?? "";
    if (result && typeof result === "object" && "__refreshHeaders" in result) {
      const refreshHeaders = result.__refreshHeaders;
      for (const [key, value] of Object.entries(refreshHeaders)) {
        response.header(key, value);
      }
      delete result.__refreshHeaders;
    }
    if (route.responseType === "json") {
      return response.json(result, 200);
    } else if (route.responseType === "stream") {
      return this.stream(route, response, result);
    } else if (route.responseType === "datastream-response") {
      const fetchResponse = result;
      return fetchResponse;
    } else if (route.responseType === "mcp-http") {
      const { server, httpPath, mcpOptions: routeMcpOptions } = result;
      const { req, res } = toReqRes(response.req.raw);
      const options = { ...this.mcpOptions, ...routeMcpOptions };
      server.startHTTP({
        url: new URL(response.req.url),
        httpPath: `${resolvedPrefix}${httpPath}`,
        req,
        res,
        options: Object.keys(options).length > 0 ? options : void 0
      }).catch((e) => {
        this.mastra.getLogger()?.error("[MCP HTTP] Error in background startHTTP:", {
          error: e instanceof Error ? { message: e.message, stack: e.stack } : e
        });
        try {
          if (!res.headersSent) {
            res.writeHead(500, { "Content-Type": "application/json" });
            res.end(
              JSON.stringify({
                jsonrpc: "2.0",
                error: { code: -32603, message: "Internal server error" },
                id: null
              })
            );
          }
        } catch {
        }
      });
      return await toFetchResponse(res);
    } else if (route.responseType === "mcp-sse") {
      const { server, ssePath, messagePath } = result;
      try {
        return await server.startHonoSSE({
          url: new URL(response.req.url),
          ssePath: `${resolvedPrefix}${ssePath}`,
          messagePath: `${resolvedPrefix}${messagePath}`,
          context: response
        });
      } catch {
        return response.json({ error: "Error handling MCP SSE request" }, 500);
      }
    } else {
      return response.status(500);
    }
  }
  async registerRoute(app, route, { prefix: prefixParam } = {}) {
    const prefix = prefixParam ?? this.prefix ?? "";
    const shouldApplyBodyLimit = this.bodyLimitOptions && ["POST", "PUT", "PATCH"].includes(route.method.toUpperCase());
    const maxSize = route.maxBodySize ?? this.bodyLimitOptions?.maxSize;
    const middlewares = [];
    if (shouldApplyBodyLimit && maxSize && this.bodyLimitOptions) {
      middlewares.push(
        bodyLimit.bodyLimit({
          maxSize,
          onError: this.bodyLimitOptions.onError
        })
      );
    }
    app[route.method.toLowerCase()](
      `${prefix}${route.path}`,
      ...middlewares,
      async (c) => {
        const authResult = await this.checkRouteAuth(route, {
          path: c.req.path,
          method: c.req.method,
          getHeader: (name) => c.req.header(name),
          getQuery: (name) => c.req.query(name),
          requestContext: c.get("requestContext"),
          request: c.req.raw,
          buildAuthorizeContext: () => c
        });
        if (authResult) {
          if (authResult.headers) {
            for (const [key, value] of Object.entries(authResult.headers)) {
              c.header(key, value);
            }
          }
          if (authResult.error) {
            return c.json({ error: authResult.error }, authResult.status);
          }
        }
        const params = await this.getParams(route, c.req);
        if (params.bodyParseError) {
          return c.json(
            {
              error: "Invalid request body",
              issues: [{ field: "body", message: params.bodyParseError.message }]
            },
            400
          );
        }
        if (params.queryParams) {
          try {
            params.queryParams = await this.parseQueryParams(route, params.queryParams);
          } catch (error) {
            this.mastra.getLogger()?.error("Error parsing query params", {
              error: error instanceof Error ? { message: error.message, stack: error.stack } : error
            });
            if (serverAdapter.isZodError(error)) {
              const { status, body } = this.resolveValidationError(route, error, "query");
              return c.json(body, status);
            }
            return c.json(
              {
                error: "Invalid query parameters",
                issues: [{ field: "unknown", message: error instanceof Error ? error.message : "Unknown error" }]
              },
              400
            );
          }
        }
        if (params.body) {
          try {
            params.body = await this.parseBody(route, params.body);
          } catch (error) {
            this.mastra.getLogger()?.error("Error parsing body", {
              error: error instanceof Error ? { message: error.message, stack: error.stack } : error
            });
            if (serverAdapter.isZodError(error)) {
              const { status, body } = this.resolveValidationError(route, error, "body");
              return c.json(body, status);
            }
            return c.json(
              {
                error: "Invalid request body",
                issues: [{ field: "unknown", message: error instanceof Error ? error.message : "Unknown error" }]
              },
              400
            );
          }
        }
        if (params.urlParams) {
          try {
            params.urlParams = await this.parsePathParams(route, params.urlParams);
          } catch (error) {
            this.mastra.getLogger()?.error("Error parsing path params", {
              error: error instanceof Error ? { message: error.message, stack: error.stack } : error
            });
            if (serverAdapter.isZodError(error)) {
              const { status, body } = this.resolveValidationError(route, error, "path");
              return c.json(body, status);
            }
            return c.json(
              {
                error: "Invalid path parameters",
                issues: [{ field: "unknown", message: error instanceof Error ? error.message : "Unknown error" }]
              },
              400
            );
          }
        }
        const handlerParams = {
          ...params.urlParams,
          ...params.queryParams,
          ...typeof params.body === "object" ? params.body : {},
          requestContext: c.get("requestContext"),
          mastra: this.mastra,
          registeredTools: c.get("registeredTools"),
          taskStore: c.get("taskStore"),
          abortSignal: c.get("abortSignal"),
          routePrefix: prefix,
          request: c.req.raw
          // Standard Request object with headers/cookies
        };
        const requestContext = c.get("requestContext");
        const hasAuth = this.mastra.getStudio()?.auth || this.mastra.getServer()?.auth;
        if (hasAuth) {
          const hasPermission = await loadHasPermission();
          if (hasPermission) {
            const userPermissions = requestContext.get("mastra__userPermissions");
            const permissionError = this.checkRoutePermission(route, userPermissions, hasPermission, requestContext);
            if (permissionError) {
              return c.json(
                {
                  error: permissionError.error,
                  message: permissionError.message
                },
                permissionError.status
              );
            }
          }
        }
        const fgaError = await serverAdapter.checkRouteFGA(this.mastra, route, c.get("requestContext"), {
          ...params.urlParams,
          ...params.queryParams,
          ...typeof params.body === "object" ? params.body : {}
        });
        if (fgaError) {
          return c.json({ error: fgaError.error, message: fgaError.message }, fgaError.status);
        }
        try {
          const result = await route.handler(handlerParams);
          return this.sendResponse(route, c, result, prefix);
        } catch (error) {
          this.mastra.getLogger()?.error("Error calling handler", {
            error: error instanceof Error ? { message: error.message, stack: error.stack } : error,
            path: route.path,
            method: route.method
          });
          if (error && typeof error === "object") {
            if ("status" in error) {
              const status = error.status;
              let safeCause;
              try {
                const raw = error instanceof Error ? error.cause : void 0;
                if (raw && typeof raw === "object" && !Array.isArray(raw) && "failingItems" in raw && Array.isArray(raw.failingItems)) {
                  safeCause = { failingItems: raw.failingItems };
                }
              } catch {
              }
              return c.json(
                {
                  error: error instanceof Error ? error.message : "Unknown error",
                  ...safeCause ? { cause: safeCause } : {}
                },
                status
              );
            }
            if ("details" in error && error.details && typeof error.details === "object" && "status" in error.details) {
              const status = error.details.status;
              return c.json({ error: error instanceof Error ? error.message : "Unknown error" }, status);
            }
          }
          return c.json({ error: error instanceof Error ? error.message : "Unknown error" }, 500);
        }
      }
    );
  }
  async registerCustomApiRoutes() {
    if (!await this.buildCustomRouteHandler()) return;
    const routes = this.customApiRoutes ?? this.mastra.getServer()?.apiRoutes ?? [];
    for (const route of routes) {
      const serverRoute = {
        method: route.method,
        path: route.path,
        responseType: "json",
        handler: async () => {
        },
        requiresAuth: route.requiresAuth,
        requiresPermission: route.requiresPermission,
        fga: route.fga
      };
      const routeHandler = async (c) => {
        const authError = await this.checkRouteAuth(serverRoute, {
          path: c.req.path,
          method: c.req.method,
          getHeader: (name) => c.req.header(name),
          getQuery: (name) => c.req.query(name),
          requestContext: c.get("requestContext"),
          request: c.req.raw,
          buildAuthorizeContext: () => c
        });
        if (authError) {
          if (authError.headers) {
            for (const [key, value] of Object.entries(authError.headers)) {
              c.header(key, value);
            }
          }
          if (authError.error) {
            return c.json({ error: authError.error }, authError.status);
          }
        }
        const requestContext = c.get("requestContext");
        const hasAuth = this.mastra.getStudio()?.auth || this.mastra.getServer()?.auth;
        if (hasAuth) {
          const hasPermission = await loadHasPermission();
          if (hasPermission) {
            const userPermissions = requestContext.get("mastra__userPermissions");
            const permissionError = this.checkRoutePermission(
              serverRoute,
              userPermissions,
              hasPermission,
              requestContext
            );
            if (permissionError) {
              return c.json(
                { error: permissionError.error, message: permissionError.message },
                permissionError.status
              );
            }
          }
        }
        let bodyParams = {};
        const contentType = c.req.header("content-type");
        if (contentType?.includes("application/json")) {
          try {
            const body = await c.req.raw.clone().json();
            if (body && typeof body === "object" && !Array.isArray(body)) {
              bodyParams = body;
            }
          } catch {
            bodyParams = {};
          }
        } else if (contentType?.includes("application/x-www-form-urlencoded") || contentType?.includes("multipart/form-data")) {
          try {
            bodyParams = Object.fromEntries(await c.req.raw.clone().formData());
          } catch {
            bodyParams = {};
          }
        }
        const fgaError = await serverAdapter.checkRouteFGA(this.mastra, serverRoute, c.get("requestContext"), {
          ...c.req.param(),
          ...Object.fromEntries(new URL(c.req.url).searchParams.entries()),
          ...bodyParams
        });
        if (fgaError) {
          return c.json({ error: fgaError.error, message: fgaError.message }, fgaError.status);
        }
        const reqHeaders = {};
        c.req.raw.headers.forEach((v, k) => {
          reqHeaders[k] = v;
        });
        const response = await this.handleCustomRouteRequest(
          c.req.url,
          c.req.method,
          reqHeaders,
          c.req.raw.body,
          c.get("requestContext"),
          c.req.raw.signal
        );
        if (!response) {
          return c.json({ error: "Not Found" }, 404);
        }
        return response;
      };
      const method = route.method.toLowerCase();
      this.app[method](route.path, routeHandler);
    }
  }
  registerContextMiddleware() {
    this.app.use("*", this.createContextMiddleware());
  }
  registerAuthMiddleware() {
  }
  registerHttpLoggingMiddleware() {
    if (!this.httpLoggingConfig?.enabled) {
      return;
    }
    this.app.use("*", async (c, next) => {
      if (!this.shouldLogRequest(c.req.path)) {
        return next();
      }
      const start = Date.now();
      const method = c.req.method;
      const path = c.req.path;
      await next();
      const duration = Date.now() - start;
      const status = c.res.status;
      const level = this.httpLoggingConfig?.level || "info";
      const logData = {
        method,
        path,
        status,
        duration: `${duration}ms`
      };
      if (this.httpLoggingConfig?.includeQueryParams) {
        logData.query = c.req.query();
      }
      if (this.httpLoggingConfig?.includeHeaders) {
        const headers = Object.fromEntries(c.req.raw.headers.entries());
        const redactHeaders = this.httpLoggingConfig.redactHeaders || [];
        redactHeaders.forEach((h) => {
          const key = h.toLowerCase();
          if (headers[key] !== void 0) {
            headers[key] = "[REDACTED]";
          }
        });
        logData.headers = headers;
      }
      this.logger[level](`${method} ${path} ${status} ${duration}ms`, logData);
    });
  }
};

// ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/hono-openapi/1.3.0/8a61fee136ec2c53792a18ac633ed1e210d9cd979e48c5121bb6b6f406f486d4/node_modules/hono-openapi/dist/index.js
var uniqueSymbol = /* @__PURE__ */ Symbol("openapi");
function describeRoute(spec) {
  const middleware2 = async (_c, next) => {
    await next();
  };
  return Object.assign(middleware2, {
    [uniqueSymbol]: {
      spec
    }
  });
}

// src/server/handlers/client.ts
var clients = /* @__PURE__ */ new Set();
var hotReloadDisabled = false;
function handleClientsRefresh(c) {
  const stream2 = new ReadableStream({
    start(controller) {
      clients.add(controller);
      controller.enqueue("data: connected\n\n");
      c.req.raw.signal.addEventListener("abort", () => {
        clients.delete(controller);
      });
    }
  });
  return new Response(stream2, {
    headers: {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache",
      Connection: "keep-alive",
      "Access-Control-Allow-Origin": "*"
    }
  });
}
function handleTriggerClientsRefresh(c) {
  clients.forEach((controller) => {
    try {
      controller.enqueue("data: refresh\n\n");
    } catch {
      clients.delete(controller);
    }
  });
  return c.json({ success: true, clients: clients.size });
}
function isHotReloadDisabled() {
  return hotReloadDisabled;
}
function handleError(error, defaultMessage) {
  const apiError = error;
  throw new httpException.HTTPException(apiError.status || 500, {
    message: apiError.message || defaultMessage,
    cause: apiError.cause
  });
}
function errorHandler(err, c, isDev) {
  if (err instanceof httpException.HTTPException) {
    if (isDev) {
      return c.json({ error: err.message, cause: err.cause, stack: err.stack }, err.status);
    }
    return c.json({ error: err.message }, err.status);
  }
  c.get("mastra").getLogger().error(err);
  return c.json({ error: "Internal Server Error" }, 500);
}

// src/server/handlers/health.ts
async function healthHandler(c) {
  return c.json({ success: true }, 200);
}

// src/server/handlers/restart-active-runs.ts
async function restartAllActiveWorkflowRunsHandler(c) {
  try {
    const mastra = c.get("mastra");
    void mastra.restartAllActiveWorkflowRuns();
    return c.json({ message: "Restarting all active workflow runs..." });
  } catch (error) {
    return handleError(error, "Error restarting active workflow runs");
  }
}

// src/server/handlers/root.ts
async function rootHandler(c) {
  const baseUrl = new URL(c.req.url).origin;
  return c.html(
    /* html */
    `
    <!doctype html>
    <html lang="en">
      <head>
        <meta charset="UTF-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <title>Mastra API</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;
          }

          .link {
            color: #ffffff;
          }

          .link:hover {
            text-decoration: none;
          }

          .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 the Mastra API</h1>
          <p class="subtitle">
            Discover all available endpoints through Swagger UI. You can also define your own <a href="https://mastra.ai/docs/server-db/custom-api-routes" target="_blank" class="link">API routes</a>.
          </p>
          <a href="${baseUrl}/swagger-ui" target="_blank" class="docs-link">
            Browse Swagger UI
            <svg
              class="arrow-icon"
              width="20"
              height="20"
              viewBox="0 0 24 24"
              fill="none"
              stroke="currentColor"
              strokeWidth="2"
            >
              <path d="M5 12h14M12 5l7 7-7 7" />
            </svg>
          </a>
        </main>
      </body>
    </html>
    `
  );
}

// src/server/welcome.ts
function welcomeHtml(apiPrefix = "/api") {
  const prefix = "/" + apiPrefix.replace(/^\/+|\/+$/g, "");
  const prefixNoSlash = prefix.slice(1);
  return `
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Mastra Server</title>
    <style>
      * { box-sizing: border-box; }

      body {
        margin: 0;
        padding: 0;
        background-color: #0a0a0a;
        color: #e4e4e7;
        font-family: -apple-system, BlinkMacSystemFont, system-ui, sans-serif;
        min-height: 100vh;
        line-height: 1.6;
      }

      .page {
        max-width: 720px;
        margin: 0 auto;
        padding: 3rem 1.5rem 4rem;
      }

      header {
        margin-bottom: 2.5rem;
      }

      header h1 {
        font-size: 1.75rem;
        font-weight: 600;
        margin: 0 0 0.25rem;
        color: #fff;
      }

      header p {
        color: #71717a;
        font-size: 0.9rem;
        margin: 0;
      }

      .status-bar {
        display: flex;
        align-items: center;
        gap: 0.5rem;
        margin-top: 1rem;
        font-size: 0.8rem;
        color: #a1a1aa;
      }

      .status-dot {
        width: 8px;
        height: 8px;
        border-radius: 50%;
        background: #22c55e;
        flex-shrink: 0;
      }

      section {
        margin-bottom: 2rem;
      }

      section h2 {
        font-size: 0.75rem;
        font-weight: 600;
        text-transform: uppercase;
        letter-spacing: 0.05em;
        color: #71717a;
        margin: 0 0 0.75rem;
      }

      .card {
        background: #18181b;
        border: 1px solid #27272a;
        border-radius: 8px;
        overflow: hidden;
      }

      .card + .card {
        margin-top: 0.75rem;
      }

      .card-row {
        display: flex;
        align-items: center;
        justify-content: space-between;
        padding: 0.75rem 1rem;
        gap: 0.75rem;
      }

      .card-row + .card-row {
        border-top: 1px solid #27272a;
      }

      .card-row-left {
        display: flex;
        align-items: center;
        gap: 0.75rem;
        min-width: 0;
      }

      .method {
        font-family: 'SF Mono', SFMono-Regular, ui-monospace, Menlo, monospace;
        font-size: 0.7rem;
        font-weight: 600;
        padding: 2px 6px;
        border-radius: 4px;
        flex-shrink: 0;
      }

      .method-get { background: #052e16; color: #4ade80; }
      .method-post { background: #172554; color: #60a5fa; }

      .endpoint-path {
        font-family: 'SF Mono', SFMono-Regular, ui-monospace, Menlo, monospace;
        font-size: 0.8rem;
        color: #d4d4d8;
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
      }

      .endpoint-desc {
        font-size: 0.75rem;
        color: #71717a;
        flex-shrink: 0;
      }

      .curl-block {
        position: relative;
        background: #111113;
        border: 1px solid #27272a;
        border-radius: 8px;
        overflow: hidden;
      }

      .curl-block + .curl-block {
        margin-top: 0.75rem;
      }

      .curl-label {
        display: flex;
        align-items: center;
        justify-content: space-between;
        padding: 0.5rem 1rem;
        border-bottom: 1px solid #27272a;
        font-size: 0.75rem;
        color: #a1a1aa;
      }

      .copy-btn {
        background: none;
        border: 1px solid #3f3f46;
        border-radius: 4px;
        color: #a1a1aa;
        font-size: 0.7rem;
        padding: 2px 8px;
        cursor: pointer;
        font-family: inherit;
        transition: all 0.15s;
      }

      .copy-btn:hover {
        background: #27272a;
        color: #e4e4e7;
      }

      .curl-code {
        padding: 0.75rem 1rem;
        font-family: 'SF Mono', SFMono-Regular, ui-monospace, Menlo, monospace;
        font-size: 0.8rem;
        line-height: 1.5;
        color: #d4d4d8;
        overflow-x: auto;
        white-space: pre;
        margin: 0;
      }

      .curl-code .c-cmd { color: #a78bfa; }
      .curl-code .c-flag { color: #60a5fa; }
      .curl-code .c-url { color: #fbbf24; }
      .curl-code .c-str { color: #4ade80; }

      .links-grid {
        display: grid;
        grid-template-columns: 1fr 1fr;
        gap: 0.75rem;
      }

      .link-card {
        display: flex;
        align-items: center;
        gap: 0.75rem;
        padding: 0.875rem 1rem;
        background: #18181b;
        border: 1px solid #27272a;
        border-radius: 8px;
        color: #d4d4d8;
        text-decoration: none;
        font-size: 0.85rem;
        transition: all 0.15s;
      }

      .link-card:hover {
        background: #1f1f23;
        border-color: #3f3f46;
        color: #fff;
      }

      .link-icon {
        flex-shrink: 0;
        width: 18px;
        height: 18px;
        color: #71717a;
      }

      .link-card:hover .link-icon { color: #a1a1aa; }

      footer {
        margin-top: 3rem;
        padding-top: 1.5rem;
        border-top: 1px solid #1c1c1f;
        font-size: 0.75rem;
        color: #52525b;
      }

      @media (max-width: 480px) {
        .page { padding: 2rem 1rem 3rem; }
        header h1 { font-size: 1.5rem; }
        .links-grid { grid-template-columns: 1fr; }
        .endpoint-desc { display: none; }
      }
    </style>
  </head>
  <body>
    <div class="page">
      <header>
        <h1>Mastra Server</h1>
        <p>Your server is running. Use the endpoints below to get started.</p>
        <div class="status-bar">
          <span class="status-dot"></span>
          <span id="base-url"></span>
        </div>
      </header>

      <section>
        <h2>Quick Start</h2>

        <div class="curl-block">
          <div class="curl-label">
            <span>Check server health</span>
            <button class="copy-btn" onclick="copyCode(this)">Copy</button>
          </div>
          <pre class="curl-code" data-tpl="curl <base>/health"><span class="c-cmd">curl</span> <span class="c-url" data-url="health"></span></pre>
        </div>

        <div class="curl-block">
          <div class="curl-label">
            <span>List your agents</span>
            <button class="copy-btn" onclick="copyCode(this)">Copy</button>
          </div>
          <pre class="curl-code" data-tpl="curl <base>${prefix}/agents"><span class="c-cmd">curl</span> <span class="c-url" data-url="${prefixNoSlash}/agents"></span></pre>
        </div>

        <div class="curl-block">
          <div class="curl-label">
            <span>Chat with an agent</span>
            <button class="copy-btn" onclick="copyCode(this)">Copy</button>
          </div>
          <pre class="curl-code" data-tpl="curl -X POST <base>${prefix}/agents/:agent-id/generate -H 'Content-Type: application/json' -d '{&quot;messages&quot;:[{&quot;role&quot;:&quot;user&quot;,&quot;content&quot;:&quot;Hello&quot;}]}'"><span class="c-cmd">curl</span> <span class="c-flag">-X POST</span> <span class="c-url" data-url="${prefixNoSlash}/agents/:agent-id/generate"></span> \\
  <span class="c-flag">-H</span> <span class="c-str">'Content-Type: application/json'</span> \\
  <span class="c-flag">-d</span> <span class="c-str">'{"messages":[{"role":"user","content":"Hello"}]}'</span></pre>
        </div>

        <div class="curl-block">
          <div class="curl-label">
            <span>Stream an agent response</span>
            <button class="copy-btn" onclick="copyCode(this)">Copy</button>
          </div>
          <pre class="curl-code" data-tpl="curl -N -X POST <base>${prefix}/agents/:agent-id/stream -H 'Content-Type: application/json' -d '{&quot;messages&quot;:[{&quot;role&quot;:&quot;user&quot;,&quot;content&quot;:&quot;Hello&quot;}]}'"><span class="c-cmd">curl</span> <span class="c-flag">-N -X POST</span> <span class="c-url" data-url="${prefixNoSlash}/agents/:agent-id/stream"></span> \\
  <span class="c-flag">-H</span> <span class="c-str">'Content-Type: application/json'</span> \\
  <span class="c-flag">-d</span> <span class="c-str">'{"messages":[{"role":"user","content":"Hello"}]}'</span></pre>
        </div>
      </section>

      <section>
        <h2>API Endpoints</h2>
        <div class="card">
          <div class="card-row">
            <div class="card-row-left">
              <span class="method method-get">GET</span>
              <span class="endpoint-path">${prefix}/agents</span>
            </div>
            <span class="endpoint-desc">List all agents</span>
          </div>
          <div class="card-row">
            <div class="card-row-left">
              <span class="method method-post">POST</span>
              <span class="endpoint-path">${prefix}/agents/:id/generate</span>
            </div>
            <span class="endpoint-desc">Generate a response</span>
          </div>
          <div class="card-row">
            <div class="card-row-left">
              <span class="method method-post">POST</span>
              <span class="endpoint-path">${prefix}/agents/:id/stream</span>
            </div>
            <span class="endpoint-desc">Stream a response</span>
          </div>
          <div class="card-row">
            <div class="card-row-left">
              <span class="method method-get">GET</span>
              <span class="endpoint-path">${prefix}/workflows</span>
            </div>
            <span class="endpoint-desc">List all workflows</span>
          </div>
          <div class="card-row">
            <div class="card-row-left">
              <span class="method method-post">POST</span>
              <span class="endpoint-path">${prefix}/workflows/:id/start</span>
            </div>
            <span class="endpoint-desc">Run a workflow</span>
          </div>
          <div class="card-row">
            <div class="card-row-left">
              <span class="method method-get">GET</span>
              <span class="endpoint-path">${prefix}/tools</span>
            </div>
            <span class="endpoint-desc">List all tools</span>
          </div>
          <div class="card-row">
            <div class="card-row-left">
              <span class="method method-post">POST</span>
              <span class="endpoint-path">${prefix}/tools/:id/execute</span>
            </div>
            <span class="endpoint-desc">Execute a tool</span>
          </div>
          <div class="card-row">
            <div class="card-row-left">
              <span class="method method-get">GET</span>
              <span class="endpoint-path">${prefix}/memory/threads</span>
            </div>
            <span class="endpoint-desc">List memory threads</span>
          </div>
        </div>
      </section>

      <section>
        <h2>Resources</h2>
        <div class="links-grid">
          <a href="https://mastra.ai/docs" target="_blank" rel="noopener noreferrer" class="link-card">
            <svg class="link-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20"/><path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z"/></svg>
            Documentation
          </a>
          <a href="https://mastra.ai/docs/server-db/custom-api-routes" target="_blank" rel="noopener noreferrer" class="link-card">
            <svg class="link-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M16 18l6-6-6-6"/><path d="M8 6l-6 6 6 6"/></svg>
            Custom API Routes
          </a>
          <a href="https://mastra.ai/docs/agents/overview" target="_blank" rel="noopener noreferrer" class="link-card">
            <svg class="link-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"/><path d="M12 1v4m0 14v4m-7.8-15.4 2.8 2.8m9.6 9.6 2.8 2.8M1 12h4m14 0h4M4.2 19.8l2.8-2.8m9.6-9.6 2.8-2.8"/></svg>
            Agents Guide
          </a>
          <a href="https://mastra.ai/docs/workflows/overview" target="_blank" rel="noopener noreferrer" class="link-card">
            <svg class="link-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="16 3 21 3 21 8"/><line x1="4" y1="20" x2="21" y2="3"/><polyline points="21 16 21 21 16 21"/><line x1="15" y1="15" x2="21" y2="21"/><line x1="4" y1="4" x2="9" y2="9"/></svg>
            Workflows Guide
          </a>
        </div>
      </section>

      <footer>
        Powered by <a href="https://mastra.ai" target="_blank" rel="noopener noreferrer" style="color:#71717a;">Mastra</a>
      </footer>
    </div>

    <script>
      (function() {
        var base = location.origin;
        document.getElementById('base-url').textContent = base;

        var els = document.querySelectorAll('[data-url]');
        for (var i = 0; i < els.length; i++) {
          els[i].textContent = base + '/' + els[i].getAttribute('data-url');
        }

        var tpls = document.querySelectorAll('[data-tpl]');
        for (var i = 0; i < tpls.length; i++) {
          tpls[i].setAttribute('data-tpl', tpls[i].getAttribute('data-tpl').replace(/<base>/g, base));
        }
      })();

      function copyCode(btn) {
        var pre = btn.closest('.curl-block').querySelector('.curl-code');
        var text = pre.getAttribute('data-tpl');
        if (!navigator.clipboard || !navigator.clipboard.writeText) {
          btn.textContent = 'Unavailable';
          setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
          return;
        }
        navigator.clipboard.writeText(text).then(function() {
          btn.textContent = 'Copied!';
          setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
        }).catch(function() {
          btn.textContent = 'Failed';
          setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
        });
      }
    </script>
  </body>
</html>
`;
}

// src/server/index.ts
var getStudioPath = () => {
  if (process.env.MASTRA_STUDIO_PATH) {
    return process.env.MASTRA_STUDIO_PATH;
  }
  let __dirname = ".";
  if ((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))) {
    const __filename = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
    __dirname = path.dirname(__filename);
  }
  const studioPath = process.env.MASTRA_STUDIO_PATH || path.join(__dirname, "studio");
  return studioPath;
};
var DEFAULT_CORS_ALLOW_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
var DEFAULT_CORS_ALLOW_HEADERS = ["Content-Type", "Authorization", "x-mastra-client-type", "x-mastra-dev-playground"];
var DEFAULT_CORS_EXPOSE_HEADERS = ["Content-Length", "X-Requested-With"];
function getCorsConfig(serverCors, credentialsDefault) {
  const userCors = serverCors && typeof serverCors === "object" ? serverCors : void 0;
  const origin = userCors && "origin" in userCors && userCors.origin ? userCors.origin : credentialsDefault ? (requestOrigin) => requestOrigin || void 0 : "*";
  const credentials = userCors && "credentials" in userCors ? userCors.credentials : credentialsDefault;
  return {
    origin,
    allowMethods: DEFAULT_CORS_ALLOW_METHODS,
    credentials,
    maxAge: 3600,
    ...userCors,
    allowHeaders: [...DEFAULT_CORS_ALLOW_HEADERS, ...userCors?.allowHeaders ?? []],
    exposeHeaders: [...DEFAULT_CORS_EXPOSE_HEADERS, ...userCors?.exposeHeaders ?? []]
  };
}
function getRouteCorsConfig(apiRoutes, pathname, method) {
  const route = auth.findMatchingCustomRoute(pathname, method, apiRoutes)?.route;
  return route?.cors;
}
function getToolExports(tools$1) {
  try {
    return tools$1.reduce((acc, toolModule) => {
      Object.entries(toolModule).forEach(([key, tool]) => {
        if (tool instanceof tools.Tool) {
          acc[key] = tool;
        }
      });
      return acc;
    }, {});
  } catch (err) {
    console.error(
      `Failed to import tools
reason: ${err.message}
${err.stack.split("\n").slice(1).join("\n")}
    `,
      err
    );
  }
}
async function createHonoServer(mastra, options = {
  tools: {}
}) {
  if (options.tools) {
    for (const [key, tool] of Object.entries(options.tools)) {
      try {
        mastra.addTool(tool, key);
      } catch {
      }
    }
  }
  const app = new hono.Hono();
  const server = mastra.getServer();
  const apiPrefix = server?.apiPrefix ?? "/api";
  const a2aTaskStore = new store.InMemoryTaskStore();
  const routes = server?.apiRoutes;
  const processedRoutes = routes?.map((route) => {
    if ("openapi" in route && route.openapi) {
      const existingMiddleware = route.middleware ? Array.isArray(route.middleware) ? route.middleware : [route.middleware] : [];
      return {
        ...route,
        middleware: [
          describeRoute(route.openapi),
          ...existingMiddleware
        ]
      };
    }
    return route;
  });
  const customRouteAuthConfig = /* @__PURE__ */ new Map();
  if (processedRoutes) {
    for (const route of processedRoutes) {
      const requiresAuth = route.requiresAuth !== false;
      const routeKey = `${route.method}:${route.path}`;
      customRouteAuthConfig.set(routeKey, requiresAuth);
    }
  }
  const customOnError = server?.onError;
  app.onError((err, c) => {
    if (customOnError) {
      return customOnError(err, c);
    }
    return errorHandler(err, c, options.isDev);
  });
  const bodyLimitOptions = {
    maxSize: server?.bodySizeLimit ?? 4.5 * 1024 * 1024,
    // 4.5 MB,
    onError: () => ({ error: "Request body too large" })
  };
  const honoServerAdapter = new MastraServer({
    app,
    mastra,
    tools: options.tools,
    taskStore: a2aTaskStore,
    bodyLimitOptions,
    openapiPath: options?.isDev || server?.build?.openAPIDocs ? "/openapi.json" : void 0,
    customRouteAuthConfig,
    customApiRoutes: processedRoutes,
    prefix: apiPrefix,
    mcpOptions: server?.mcpOptions
  });
  honoServerAdapter.registerContextMiddleware();
  const serverMiddleware = mastra.getServerMiddleware?.();
  if (serverMiddleware && serverMiddleware.length > 0) {
    for (const m of serverMiddleware) {
      app.use(m.path, m.handler);
    }
  }
  const browserStreamSetup = await setupBrowserStream(app, {
    getToolset: async (agentId) => {
      try {
        const runtimeAgent = mastra.getAgentById(agentId);
        if (runtimeAgent) {
          return runtimeAgent.browser;
        }
      } catch {
      }
      try {
        const storedAgent = await mastra.getEditor?.()?.agent.getById(agentId);
        return storedAgent?.browser;
      } catch {
        return void 0;
      }
    },
    apiPrefix
  });
  if (!browserStreamSetup) {
    app.get(
      `${apiPrefix}/agents/:agentId/browser/session`,
      (c) => c.json({ hasSession: false, screencastAvailable: false })
    );
  }
  if (server?.cors === false) {
    app.use("*", timeout.timeout(server?.timeout ?? 3 * 60 * 1e3));
  } else {
    const hasAuth = !!server?.auth;
    app.use("*", timeout.timeout(server?.timeout ?? 3 * 60 * 1e3), async (c, next) => {
      const pathname = new URL(c.req.url).pathname;
      const method = c.req.method === "OPTIONS" ? c.req.header("Access-Control-Request-Method") ?? c.req.method : c.req.method;
      const routeCors = getRouteCorsConfig(processedRoutes, pathname, method);
      const corsOptions = routeCors ? getCorsConfig(routeCors, false) : getCorsConfig(server?.cors, hasAuth);
      return cors.cors(corsOptions)(c, next);
    });
  }
  app.get(
    "/health",
    describeRoute({
      description: "Health check endpoint",
      tags: ["system"],
      responses: {
        200: {
          description: "Service is healthy"
        }
      }
    }),
    healthHandler
  );
  if (options?.isDev || server?.build?.swaggerUI) {
    app.get(
      apiPrefix,
      describeRoute({
        description: "API Welcome Page",
        tags: ["system"],
        responses: {
          200: {
            description: "Success"
          }
        }
      }),
      rootHandler
    );
  }
  await honoServerAdapter.validateEELicense();
  honoServerAdapter.registerAuthMiddleware();
  if (server?.middleware) {
    const normalizedMiddlewares = Array.isArray(server.middleware) ? server.middleware : [server.middleware];
    const middlewares = normalizedMiddlewares.map((middleware2) => {
      if (typeof middleware2 === "function") {
        return {
          path: "*",
          handler: middleware2
        };
      }
      return middleware2;
    });
    for (const middleware2 of middlewares) {
      app.use(middleware2.path, middleware2.handler);
    }
  }
  await honoServerAdapter.registerCustomApiRoutes();
  if (server?.build?.apiReqLogs) {
    app.use(logger.logger());
  }
  await honoServerAdapter.registerRoutes();
  if (options?.isDev || server?.build?.swaggerUI) {
    if (!options?.isDev && server?.build?.swaggerUI && !server?.build?.openAPIDocs) {
      const logger2 = mastra.getLogger();
      logger2.warn(
        "Swagger UI is enabled but OpenAPI documentation is disabled. The Swagger UI will not function properly without the OpenAPI endpoint. Please enable openAPIDocs in your server.build configuration:\n  server: { build: { swaggerUI: true, openAPIDocs: true } }"
      );
    }
    app.get(
      "/swagger-ui",
      describeRoute({
        hide: true
      }),
      middleware({ url: `${apiPrefix}/openapi.json` })
    );
  }
  if (options?.isDev) {
    app.post(
      "/__restart-active-workflow-runs",
      describeRoute({
        hide: true
      }),
      restartAllActiveWorkflowRunsHandler
    );
  }
  const serverOptions = mastra.getServer();
  const studioBasePath = chunk3T7FP546_cjs.normalizeStudioBase(serverOptions?.studioBase ?? "/");
  if (options?.studio) {
    app.get(
      `${studioBasePath}/refresh-events`,
      describeRoute({
        hide: true
      }),
      handleClientsRefresh
    );
    app.post(
      `${studioBasePath}/__refresh`,
      describeRoute({
        hide: true
      }),
      handleTriggerClientsRefresh
    );
    app.get(
      `${studioBasePath}/__hot-reload-status`,
      describeRoute({
        hide: true
      }),
      (c) => {
        return c.json({
          disabled: isHotReloadDisabled(),
          timestamp: (/* @__PURE__ */ new Date()).toISOString()
        });
      }
    );
    app.use(`${studioBasePath}/assets/*`, compress.compress());
    const studioPath = getStudioPath();
    app.use(
      `${studioBasePath}/assets/*`,
      serveStatic({
        root: path.join(studioPath, "assets"),
        rewriteRequestPath: (path) => {
          let rewritten = path;
          if (studioBasePath && rewritten.startsWith(studioBasePath)) {
            rewritten = rewritten.slice(studioBasePath.length);
          }
          if (rewritten.startsWith("/assets")) {
            rewritten = rewritten.slice("/assets".length);
          }
          return rewritten;
        }
      })
    );
  }
  app.get("*", async (c, next) => {
    const requestPath = c.req.path;
    if (requestPath === apiPrefix || requestPath.startsWith(`${apiPrefix}/`) || requestPath.startsWith("/swagger-ui") || requestPath.startsWith("/openapi.json")) {
      return await next();
    }
    if (requestPath.includes(".") && !requestPath.endsWith(".html")) {
      return await next();
    }
    const isStudioRoute = studioBasePath === "" || requestPath === studioBasePath || requestPath.startsWith(`${studioBasePath}/`);
    if (options?.studio && isStudioRoute) {
      const studioPath = getStudioPath();
      let indexHtml = await promises.readFile(path.join(studioPath, "index.html"), "utf-8");
      const port = serverOptions?.port ?? (Number(process.env.PORT) || 4111);
      const hideCloudCta = process.env.MASTRA_HIDE_CLOUD_CTA === "true";
      const bindHost = serverOptions?.host ?? process.env.MASTRA_HOST;
      const host = bindHost ?? "localhost";
      const key = serverOptions?.https?.key ?? (process.env.MASTRA_HTTPS_KEY ? Buffer.from(process.env.MASTRA_HTTPS_KEY, "base64") : void 0);
      const cert = serverOptions?.https?.cert ?? (process.env.MASTRA_HTTPS_CERT ? Buffer.from(process.env.MASTRA_HTTPS_CERT, "base64") : void 0);
      const protocol = key && cert ? "https" : "http";
      const studioHost = serverOptions?.studioHost ?? host;
      const studioProtocol = serverOptions?.studioProtocol ?? protocol;
      const studioPort = serverOptions?.studioPort ?? port;
      const cloudApiEndpoint = process.env.MASTRA_CLOUD_API_ENDPOINT || "";
      const experimentalFeatures = process.env.EXPERIMENTAL_FEATURES === "true" ? "true" : "false";
      const experimentalUI = process.env.MASTRA_EXPERIMENTAL_UI === "true" ? "true" : "false";
      const templatesEnabled = process.env.MASTRA_TEMPLATES === "true" ? "true" : "false";
      const agentSignals = process.env.MASTRA_AGENT_SIGNALS === "false" ? "false" : "true";
      const requestContextPresets = process.env.MASTRA_REQUEST_CONTEXT_PRESETS || "";
      const escapeForHtml = (json) => {
        return json.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
      };
      const autoDetectUrl = process.env.MASTRA_AUTO_DETECT_URL === "true";
      indexHtml = chunk3T7FP546_cjs.injectStudioHtmlConfig(indexHtml, {
        host: `'${studioHost}'`,
        port: `'${studioPort}'`,
        protocol: `'${studioProtocol}'`,
        apiPrefix: `'${serverOptions?.apiPrefix ?? "/api"}'`,
        basePath: studioBasePath,
        hideCloudCta: `'${hideCloudCta}'`,
        cloudApiEndpoint: `'${cloudApiEndpoint}'`,
        experimentalFeatures: `'${experimentalFeatures}'`,
        templates: `'${templatesEnabled}'`,
        telemetryDisabled: `'${process.env.MASTRA_TELEMETRY_DISABLED ?? ""}'`,
        requestContextPresets: `'${escapeForHtml(requestContextPresets)}'`,
        experimentalUI: `'${experimentalUI}'`,
        agentSignals: `'${agentSignals}'`,
        autoDetectUrl: `'${autoDetectUrl}'`
      });
      return c.newResponse(indexHtml, 200, { "Content-Type": "text/html" });
    }
    return c.newResponse(welcomeHtml(apiPrefix), 200, { "Content-Type": "text/html" });
  });
  if (options?.studio) {
    const studioRootPath = getStudioPath();
    const studioPath = studioBasePath ? `${studioBasePath}/*` : "*";
    app.use(
      studioPath,
      serveStatic({
        root: studioRootPath,
        rewriteRequestPath: (path) => {
          if (studioBasePath && path.startsWith(studioBasePath)) {
            return path.slice(studioBasePath.length);
          }
          return path;
        }
      })
    );
  }
  app.injectWebSocket = browserStreamSetup?.injectWebSocket;
  return app;
}
async function createNodeServer(mastra, options = { tools: {} }) {
  const app = await createHonoServer(mastra, options);
  const injectWebSocket = app.injectWebSocket;
  const serverOptions = mastra.getServer();
  const apiPrefix = serverOptions?.apiPrefix ?? "/api";
  const key = serverOptions?.https?.key ?? (process.env.MASTRA_HTTPS_KEY ? Buffer.from(process.env.MASTRA_HTTPS_KEY, "base64") : void 0);
  const cert = serverOptions?.https?.cert ?? (process.env.MASTRA_HTTPS_CERT ? Buffer.from(process.env.MASTRA_HTTPS_CERT, "base64") : void 0);
  const isHttpsEnabled = Boolean(key && cert);
  const bindHost = serverOptions?.host ?? process.env.MASTRA_HOST;
  const host = bindHost ?? "localhost";
  const port = serverOptions?.port ?? (Number(process.env.PORT) || 4111);
  const protocol = isHttpsEnabled ? "https" : "http";
  const studioHost = serverOptions?.studioHost ?? host;
  const studioProtocol = serverOptions?.studioProtocol ?? protocol;
  const studioPort = serverOptions?.studioPort ?? port;
  const server = serve(
    {
      fetch: app.fetch,
      port,
      hostname: bindHost,
      ...isHttpsEnabled ? {
        createServer: https__namespace.createServer,
        serverOptions: {
          key,
          cert
        }
      } : {}
    },
    () => {
      const logger2 = mastra.getLogger();
      logger2.info("Mastra API running", { url: `${protocol}://${host}:${port}${apiPrefix}` });
      if (options?.studio) {
        const studioBasePath = chunk3T7FP546_cjs.normalizeStudioBase(serverOptions?.studioBase ?? "/");
        const studioUrl = `${studioProtocol}://${studioHost}:${studioPort}${studioBasePath}`;
        logger2.info("Studio available", { url: studioUrl });
      }
      if (process.send) {
        process.send({
          type: "server-ready",
          port,
          host
        });
      }
    }
  );
  injectWebSocket?.(server);
  const workerLifecycle = mastra;
  if (typeof workerLifecycle.startWorkers === "function") {
    await workerLifecycle.startWorkers();
  } else {
    await workerLifecycle.startEventEngine();
  }
  void import('@mastra/core/telemetry').then(({ syncUsageTelemetry }) => syncUsageTelemetry(mastra)).catch(() => {
  });
  const SHUTDOWN_TIMEOUT_MS = 5e3;
  let shuttingDown = false;
  const shutdown = async (signal) => {
    if (shuttingDown) {
      return;
    }
    shuttingDown = true;
    const logger2 = mastra.getLogger();
    logger2.info("Shutting down Mastra server", { signal });
    server.close();
    const lifecycle = mastra;
    if (typeof lifecycle.shutdown === "function") {
      let timeout2;
      const timedOut = /* @__PURE__ */ Symbol("shutdown-timeout");
      const timeoutPromise = new Promise((resolve) => {
        timeout2 = setTimeout(() => resolve(timedOut), SHUTDOWN_TIMEOUT_MS);
      });
      try {
        const result = await Promise.race([lifecycle.shutdown(), timeoutPromise]);
        if (result === timedOut) {
          logger2.warn("Mastra shutdown timed out; forcing exit", { timeoutMs: SHUTDOWN_TIMEOUT_MS });
        }
      } catch (error) {
        logger2.error("Error during Mastra shutdown", { error });
      } finally {
        clearTimeout(timeout2);
      }
    }
    process.exit(0);
  };
  process.once("SIGINT", () => void shutdown("SIGINT"));
  process.once("SIGTERM", () => void shutdown("SIGTERM"));
  return server;
}

exports.createHonoServer = createHonoServer;
exports.createNodeServer = createNodeServer;
exports.getToolExports = getToolExports;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=index.cjs.map