@forklaunch/express 0.7.12 → 0.8.0

package/lib/index.mjs

@@ -6,15 +6,1886 @@ import {
   generateMcpServer,
   generateOpenApiSpecs,
   isForklaunchRequest,
+  isPortBound,
   meta,
   OPENAPI_DEFAULT_VERSION
 } from "@forklaunch/core/http";
 import { ZodSchemaValidator } from "@forklaunch/validator/zod";
 import { apiReference } from "@scalar/express-api-reference";
-import crypto from "crypto";
+import crypto2 from "crypto";
 import express2 from "express";
 import swaggerUi from "swagger-ui-express";
 
+// src/cluster/bun.cluster.ts
+import cluster from "cluster";
+import os from "os";
+
+// src/cluster/bun.serve.shim.ts
+import * as crypto from "crypto";
+import { EventEmitter } from "events";
+import * as path from "path";
+import { PassThrough, Readable, Transform } from "stream";
+import RangeParser from "range-parser";
+
+// src/cluster/bun.socket.shim.ts
+import { Duplex } from "stream";
+var BunSocketShim = class extends Duplex {
+  remoteAddress;
+  remotePort;
+  remoteFamily;
+  localAddress;
+  localPort;
+  localFamily;
+  bytesRead = 0;
+  bytesWritten = 0;
+  connecting = false;
+  pending = false;
+  timeout;
+  readyState = "closed";
+  bufferSize = 0;
+  autoSelectFamilyAttemptedAddresses = [];
+  _destroyed = false;
+  _socketTimeoutId;
+  _abortController;
+  _request;
+  _responseWriter;
+  constructor(options2 = {}) {
+    super({
+      allowHalfOpen: false,
+      objectMode: false
+    });
+    this.remoteAddress = options2.remoteAddress || "127.0.0.1";
+    this.remotePort = options2.remotePort || 0;
+    this.remoteFamily = "IPv4";
+    this.localAddress = options2.localAddress || "localhost";
+    this.localPort = options2.localPort || 0;
+    this.localFamily = "IPv4";
+    this._abortController = options2.abortController || new AbortController();
+    this._request = options2.request;
+    this._responseWriter = options2.responseWriter;
+    this.readyState = "open";
+    this._setupAbortHandling();
+    this._setupRequestReading();
+  }
+  _setupAbortHandling() {
+    if (this._abortController?.signal) {
+      this._abortController.signal.addEventListener("abort", () => {
+        if (!this._destroyed) {
+          this.destroy(new Error("Socket aborted"));
+        }
+      });
+    }
+  }
+  _setupRequestReading() {
+    if (this._request?.body) {
+      const reader = this._request.body.getReader();
+      const pump = async () => {
+        try {
+          while (!this._destroyed) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            this.bytesRead += value.length;
+            this.push(Buffer.from(value));
+          }
+          this.push(null);
+        } catch (error) {
+          if (!this._destroyed) {
+            this.destroy(
+              error instanceof Error ? error : new Error(String(error))
+            );
+          }
+        }
+      };
+      pump();
+    }
+  }
+  _read(_size) {
+  }
+  _write(chunk, encoding, callback) {
+    try {
+      if (this._destroyed || !this.writable) {
+        callback(new Error("Socket is not writable"));
+        return;
+      }
+      let buffer;
+      if (Buffer.isBuffer(chunk)) {
+        buffer = chunk;
+      } else if (chunk instanceof Uint8Array) {
+        buffer = Buffer.from(chunk);
+      } else {
+        buffer = Buffer.from(chunk, encoding);
+      }
+      this.bytesWritten += buffer.length;
+      if (this._responseWriter) {
+        this._responseWriter.write(new Uint8Array(buffer)).then(() => callback()).catch(callback);
+      } else {
+        queueMicrotask(() => callback());
+      }
+    } catch (error) {
+      callback(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  _final(callback) {
+    if (this._responseWriter) {
+      this._responseWriter.close().then(() => callback()).catch(callback);
+    } else {
+      callback();
+    }
+  }
+  _destroy(error, callback) {
+    this._destroyed = true;
+    this.readyState = "closed";
+    this.connecting = false;
+    this.pending = false;
+    if (this._socketTimeoutId) {
+      clearTimeout(this._socketTimeoutId);
+      this._socketTimeoutId = void 0;
+    }
+    if (this._responseWriter && !this._responseWriter.closed) {
+      this._responseWriter.abort().catch(() => {
+      });
+    }
+    if (this._abortController && !this._abortController.signal.aborted) {
+      this._abortController.abort();
+    }
+    callback(error);
+  }
+  destroyed = this._destroyed;
+  destroy(error) {
+    if (this._destroyed) return this;
+    super.destroy(error);
+    return this;
+  }
+  destroySoon() {
+    this.end();
+  }
+  connect(optionsPortOrPath, hostOrConnectionListener, connectionListener) {
+    let port;
+    let host;
+    let listener;
+    if (typeof optionsPortOrPath === "number") {
+      port = optionsPortOrPath;
+      if (typeof hostOrConnectionListener === "string") {
+        host = hostOrConnectionListener;
+        listener = connectionListener;
+      } else if (typeof hostOrConnectionListener === "function") {
+        host = "localhost";
+        listener = hostOrConnectionListener;
+      } else {
+        host = "localhost";
+      }
+      this.remoteAddress = host;
+      this.remotePort = port;
+      this.localAddress = "localhost";
+      this.localPort = 0;
+      this.remoteFamily = "IPv4";
+      this.localFamily = "IPv4";
+    } else if (typeof optionsPortOrPath === "string") {
+      this.remoteAddress = optionsPortOrPath;
+      this.remotePort = void 0;
+      this.localAddress = optionsPortOrPath;
+      this.localPort = void 0;
+      this.remoteFamily = "Unix";
+      this.localFamily = "Unix";
+      listener = typeof hostOrConnectionListener === "function" ? hostOrConnectionListener : connectionListener;
+    } else {
+      const options2 = optionsPortOrPath;
+      if ("path" in options2) {
+        this.remoteAddress = options2.path;
+        this.remotePort = void 0;
+        this.localAddress = options2.path;
+        this.localPort = void 0;
+        this.remoteFamily = "Unix";
+        this.localFamily = "Unix";
+      } else {
+        port = options2.port;
+        host = options2.host || "localhost";
+        this.remoteAddress = host;
+        this.remotePort = port;
+        this.localAddress = options2.localAddress || "localhost";
+        this.localPort = options2.localPort || 0;
+        this.remoteFamily = typeof options2.family === "number" ? "IPv4" : options2.family || "IPv4";
+        this.localFamily = typeof options2.family === "number" ? "IPv4" : options2.family || "IPv4";
+      }
+      listener = typeof hostOrConnectionListener === "function" ? hostOrConnectionListener : connectionListener;
+    }
+    this.connecting = true;
+    this.pending = true;
+    this.readyState = "opening";
+    if (listener) {
+      this.once("connect", listener);
+    }
+    queueMicrotask(() => {
+      if (this._destroyed) return;
+      this.connecting = false;
+      this.pending = false;
+      this.readyState = "open";
+      this.remotePort = port;
+      this.remoteAddress = host;
+      this.emit("connect");
+    });
+    return this;
+  }
+  setTimeout(timeout, callback) {
+    if (this._socketTimeoutId) {
+      clearTimeout(this._socketTimeoutId);
+    }
+    this.timeout = timeout;
+    if (timeout > 0) {
+      this._socketTimeoutId = setTimeout(() => {
+        if (this._destroyed) return;
+        this.emit("timeout");
+        if (callback) {
+          try {
+            callback();
+          } catch (error) {
+            this.emit("error", error);
+          }
+        }
+      }, timeout);
+    }
+    return this;
+  }
+  setNoDelay(_noDelay = true) {
+    return this;
+  }
+  setKeepAlive(enable = false, initialDelay = 0) {
+    return this;
+  }
+  address() {
+    if (!this.localAddress || !this.localPort) {
+      return {};
+    }
+    return {
+      address: this.localAddress,
+      family: this.localFamily || "IPv4",
+      port: this.localPort
+    };
+  }
+  unref() {
+    if (this._socketTimeoutId && typeof this._socketTimeoutId === "object" && "unref" in this._socketTimeoutId) {
+      this._socketTimeoutId.unref();
+    }
+    return this;
+  }
+  ref() {
+    if (this._socketTimeoutId && typeof this._socketTimeoutId === "object" && "ref" in this._socketTimeoutId) {
+      this._socketTimeoutId.ref();
+    }
+    return this;
+  }
+  setEncoding(encoding) {
+    super.setEncoding(encoding || "utf-8");
+    return this;
+  }
+  resetAndDestroy() {
+    this.destroy();
+    return this;
+  }
+  end(chunkOrCb, encodingOrCb, cb) {
+    let chunk;
+    let encoding;
+    let callback;
+    if (typeof chunkOrCb === "function") {
+      callback = chunkOrCb;
+    } else {
+      chunk = chunkOrCb;
+      if (typeof encodingOrCb === "function") {
+        callback = encodingOrCb;
+      } else {
+        encoding = encodingOrCb;
+        callback = cb;
+      }
+    }
+    if (callback) {
+      this.once("finish", callback);
+    }
+    super.end(chunk, encoding || "utf-8");
+    return this;
+  }
+  write(chunk, encodingOrCb, cb) {
+    let encoding;
+    let callback;
+    if (typeof encodingOrCb === "function") {
+      callback = encodingOrCb;
+    } else {
+      encoding = encodingOrCb;
+      callback = cb;
+    }
+    return super.write(chunk, encoding || "utf-8", callback);
+  }
+};
+function createBunSocket(options2 = {}) {
+  return new BunSocketShim(options2);
+}
+function createSocketFromBunRequest(request, serverInfo) {
+  const url = new URL(request.url);
+  const forwardedFor = request.headers.get("x-forwarded-for");
+  const realIP = request.headers.get("x-real-ip");
+  const cfConnectingIP = request.headers.get("cf-connecting-ip");
+  const remoteAddress = forwardedFor?.split(",")[0]?.trim() || realIP || cfConnectingIP || "127.0.0.1";
+  return createBunSocket({
+    remoteAddress,
+    remotePort: 0,
+    localAddress: serverInfo.hostname,
+    localPort: serverInfo.port,
+    request
+  });
+}
+
+// src/cluster/bun.serve.shim.ts
+function toNodeReadable(stream, signal) {
+  const out = new PassThrough();
+  (async () => {
+    try {
+      if (!stream) {
+        out.end();
+        return;
+      }
+      if (signal?.aborted) {
+        out.destroy(new Error("Request aborted"));
+        return;
+      }
+      const reader = stream.getReader();
+      if (signal) {
+        signal.addEventListener("abort", () => {
+          reader.cancel();
+          out.destroy(new Error("Request aborted"));
+        });
+      }
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) out.write(Buffer.from(value));
+      }
+      out.end();
+    } catch (e) {
+      out.destroy(e);
+    }
+  })();
+  return out;
+}
+function extMime(filePath) {
+  const i = filePath.lastIndexOf(".");
+  const ext = i >= 0 ? filePath.slice(i + 1).toLowerCase() : "";
+  const mimeTypes = {
+    html: "text/html; charset=utf-8",
+    htm: "text/html; charset=utf-8",
+    css: "text/css; charset=utf-8",
+    js: "text/javascript; charset=utf-8",
+    mjs: "text/javascript; charset=utf-8",
+    json: "application/json; charset=utf-8",
+    txt: "text/plain; charset=utf-8",
+    md: "text/markdown; charset=utf-8",
+    xml: "application/xml; charset=utf-8",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml; charset=utf-8",
+    ico: "image/x-icon",
+    webp: "image/webp",
+    pdf: "application/pdf",
+    zip: "application/zip",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    eot: "application/vnd.ms-fontobject"
+  };
+  return mimeTypes[ext];
+}
+function serializeCookie(name, value, opts = {}) {
+  const enc = (v) => encodeURIComponent(v);
+  let str = `${name}=${enc(value)}`;
+  if (opts.maxAge != null) str += `; Max-Age=${Math.floor(opts.maxAge)}`;
+  if (opts.domain) str += `; Domain=${opts.domain}`;
+  str += `; Path=${opts.path || "/"}`;
+  if (opts.expires) str += `; Expires=${opts.expires.toUTCString()}`;
+  if (opts.httpOnly) str += `; HttpOnly`;
+  if (opts.secure) str += `; Secure`;
+  if (opts.sameSite) {
+    if (typeof opts.sameSite === "boolean") {
+      str += `; SameSite=Strict`;
+    } else {
+      str += `; SameSite=${opts.sameSite}`;
+    }
+  }
+  return str;
+}
+function signCookie(value, secret) {
+  return value + "." + crypto.createHmac("sha256", secret).update(value).digest("base64url");
+}
+function unsignCookie(signedValue, secret) {
+  const lastDot = signedValue.lastIndexOf(".");
+  if (lastDot === -1) return false;
+  const value = signedValue.slice(0, lastDot);
+  const signature = signedValue.slice(lastDot + 1);
+  const expected = crypto.createHmac("sha256", secret).update(value).digest("base64url");
+  return signature === expected ? value : false;
+}
+function parseCookies(request) {
+  const cookieHeader = request.headers.get("cookie");
+  const cookies = {};
+  if (cookieHeader) {
+    cookieHeader.split(";").forEach((cookie) => {
+      const [name, value] = cookie.trim().split("=");
+      if (name && value) {
+        cookies[decodeURIComponent(name)] = decodeURIComponent(value);
+      }
+    });
+  }
+  return cookies;
+}
+function parseSignedCookies(request, secret) {
+  const cookies = parseCookies(request);
+  const signedCookies = {};
+  Object.entries(cookies).forEach(([name, value]) => {
+    if (name.startsWith("s:")) {
+      const cookieName = name.slice(2);
+      const unsigned = unsignCookie(value, secret);
+      if (unsigned !== false) {
+        signedCookies[cookieName] = unsigned;
+      }
+    }
+  });
+  return signedCookies;
+}
+function serveExpress(app, openTelemetryCollector, opts = {}) {
+  const {
+    port = Number(process.env.PORT || 3e3),
+    host = "0.0.0.0",
+    reusePort = false,
+    development = process.env.NODE_ENV !== "production",
+    idleTimeout,
+    tls: tls2,
+    cookieSecret = process.env.COOKIE_SECRET || "default-secret"
+  } = opts;
+  let serverClosed = false;
+  const server = Bun.serve({
+    port,
+    hostname: host,
+    reusePort,
+    development,
+    ...idleTimeout ? { idleTimeout } : {},
+    ...tls2 ? { tls: tls2 } : {},
+    async fetch(request) {
+      const url = new URL(request.url);
+      const headers = {};
+      Object.entries(request.headers).forEach(([k, v]) => {
+        headers[k.toLowerCase()] = v;
+      });
+      const forwardedFor = headers["x-forwarded-for"];
+      const ip = (forwardedFor ? Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor.split(",")[0].trim() : void 0) || headers["x-real-ip"] || headers["x-client-ip"] || "127.0.0.1";
+      const proto = headers["x-forwarded-proto"] || (url.protocol === "https:" ? "https" : "http");
+      const nodeReq = toNodeReadable(request.body);
+      let reqTimeoutId;
+      let resTimeoutId;
+      let socketTimeoutId;
+      const socket = createSocketFromBunRequest(request, {
+        hostname: host,
+        port
+      });
+      let ended = false;
+      const headerMap = new Headers();
+      let statusCode = 200;
+      let headersSent = false;
+      const resEE = new EventEmitter();
+      const pathname = url.pathname;
+      const searchParams = url.searchParams;
+      const query = Object.fromEntries(searchParams.entries());
+      const cookies = parseCookies(request);
+      const signedCookies = parseSignedCookies(request, cookieSecret);
+      const abort = new AbortController();
+      const ts = new TransformStream();
+      const writer = ts.writable.getWriter();
+      let responded = false;
+      let resolveResponse;
+      const responsePromise = new Promise(
+        (r) => resolveResponse = r
+      );
+      function ensureResponse() {
+        if (responded) return;
+        responded = true;
+        const finalHeaders = new Headers(headerMap);
+        if (!finalHeaders.has("X-Powered-By")) {
+          finalHeaders.set("X-Powered-By", "Express");
+        }
+        resolveResponse(
+          new Response(ts.readable, {
+            status: statusCode,
+            statusText: res.statusMessage || void 0,
+            headers: finalHeaders
+          })
+        );
+      }
+      function cleanup() {
+        Object.assign(req, {
+          complete: true,
+          destroyed: true,
+          closed: true
+        });
+        Object.assign(res, {
+          finished: true,
+          writableEnded: true
+        });
+        if (reqTimeoutId) {
+          clearTimeout(reqTimeoutId);
+          reqTimeoutId = void 0;
+        }
+        if (resTimeoutId) {
+          clearTimeout(resTimeoutId);
+          resTimeoutId = void 0;
+        }
+        if (socketTimeoutId) {
+          clearTimeout(socketTimeoutId);
+          socketTimeoutId = void 0;
+        }
+        if (writer && !ended) {
+          writer.close();
+        }
+        req.emit("end");
+        req.emit("close");
+        res.emit("close");
+      }
+      const res = Object.assign(resEE, {
+        statusCode,
+        statusMessage: "",
+        headersSent,
+        finished: false,
+        locals: {},
+        charset: "utf-8",
+        strictContentLength: false,
+        writeProcessing: () => {
+        },
+        chunkedEncoding: false,
+        shouldKeepAlive: true,
+        useChunkedEncodingByDefault: true,
+        sendDate: true,
+        connection: socket,
+        socket,
+        writableCorked: 0,
+        writableEnded: false,
+        writableFinished: false,
+        writableHighWaterMark: 16384,
+        writableLength: 0,
+        writableObjectMode: false,
+        destroyed: false,
+        closed: false,
+        errored: null,
+        writableNeedDrain: false,
+        _header: null,
+        _headerSent: false,
+        _headers: {},
+        _headerNames: {},
+        _hasBody: true,
+        _trailer: "",
+        _keepAliveTimeout: 5e3,
+        _last: false,
+        _onPendingData: () => {
+        },
+        _sent100: false,
+        _expect_continue: false,
+        _maxRequestsPerSocket: 0,
+        req: void 0,
+        writable: true,
+        writableAborted: false,
+        setDefaultEncoding: (encoding) => {
+          socket.setEncoding(encoding);
+          return res;
+        },
+        [Symbol.asyncDispose]: async () => {
+          cleanup();
+        },
+        compose: ((stream) => {
+          if (stream && typeof stream === "object" && "pipe" in stream) {
+            return stream;
+          }
+          if (typeof stream === "function") {
+            const transform = new Transform({
+              objectMode: true,
+              transform(chunk, encoding, callback) {
+                try {
+                  stream(chunk);
+                  callback(null, chunk);
+                } catch (error) {
+                  callback(error);
+                }
+              }
+            });
+            return transform;
+          }
+          if (stream && typeof stream === "object" && Symbol.iterator in stream) {
+            const iterator = stream[Symbol.iterator]();
+            const first = iterator.next();
+            if (!first.done && first.value && typeof first.value === "object" && "pipe" in first.value) {
+              return first.value;
+            }
+          }
+          if (stream && typeof stream === "object" && Symbol.asyncIterator in stream) {
+            const readable = new Readable({
+              objectMode: true,
+              read() {
+                this.push(null);
+              }
+            });
+            return readable;
+          }
+          const emptyStream = new Readable({
+            read() {
+              this.push(null);
+            }
+          });
+          return emptyStream;
+        }),
+        setTimeout: (msecs, callback) => {
+          setTimeout(callback || (() => {
+          }), msecs);
+          return res;
+        },
+        setHeaders: (headers2) => {
+          for (const [name, value] of Object.entries(headers2)) {
+            res.setHeader(name, value);
+          }
+          return res;
+        },
+        appendHeader: (name, value) => {
+          return res.append(name, value);
+        },
+        addTrailers: (headers2) => {
+          return res;
+        },
+        flushHeaders: () => {
+          headersSent = true;
+          res.headersSent = true;
+          ensureResponse();
+        },
+        setHeader(name, value) {
+          if (Array.isArray(value)) {
+            headerMap.delete(name);
+            value.forEach((v) => headerMap.append(name, String(v)));
+          } else {
+            headerMap.set(name, String(value));
+          }
+          return res;
+        },
+        getHeader(name) {
+          return headerMap.get(name) ?? void 0;
+        },
+        getHeaders() {
+          const obj = {};
+          headerMap.forEach((v, k) => obj[k] = v);
+          return obj;
+        },
+        getHeaderNames() {
+          const names = [];
+          headerMap.forEach((_, name) => names.push(name));
+          return names;
+        },
+        hasHeader(name) {
+          return headerMap.has(name);
+        },
+        removeHeader(name) {
+          headerMap.delete(name);
+          return res;
+        },
+        writeHead(code, reason, headers2) {
+          if (typeof reason === "object") {
+            headers2 = reason;
+            reason = void 0;
+          }
+          statusCode = code;
+          res.statusCode = statusCode;
+          if (reason) res.statusMessage = reason;
+          if (headers2) {
+            for (const [k, v] of Object.entries(headers2))
+              if (v) res.setHeader(k, v);
+          }
+          headersSent = true;
+          res.headersSent = true;
+          ensureResponse();
+          return res;
+        },
+        write(chunk, encoding, callback) {
+          if (typeof encoding === "function") {
+            callback = encoding;
+            encoding = void 0;
+          }
+          if (ended) {
+            if (callback) callback(new Error("Cannot write after end"));
+            return false;
+          }
+          headersSent = true;
+          res.headersSent = true;
+          ensureResponse();
+          if (chunk == null) {
+            if (callback) callback();
+            return true;
+          }
+          try {
+            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), encoding || "utf8");
+            writer.write(buf);
+            if (callback) callback();
+            return true;
+          } catch (error) {
+            if (callback) callback(error);
+            return false;
+          }
+        },
+        end(chunk, encoding, callback) {
+          if (typeof chunk === "function") {
+            callback = chunk;
+            chunk = void 0;
+          }
+          if (typeof encoding === "function") {
+            callback = encoding;
+            encoding = void 0;
+          }
+          if (ended) {
+            if (callback) callback();
+            return res;
+          }
+          if (chunk) res.write(chunk, encoding || "utf8");
+          ended = true;
+          Object.assign(res, {
+            writableEnded: true
+          });
+          ensureResponse();
+          writer.close().then(() => {
+            resEE.emit("finish");
+            if (callback) callback();
+          });
+          return res;
+        },
+        cork: () => {
+        },
+        uncork: () => {
+        },
+        destroy: (error) => {
+          res.destroyed = true;
+          cleanup();
+          return res;
+        },
+        _destroy: (error, callback) => {
+          callback(error);
+        },
+        _final: (callback) => {
+          callback();
+        },
+        _write: (chunk, encoding, callback) => {
+          callback();
+        },
+        _writev: (chunks, callback) => {
+          callback();
+        },
+        pipe: (destination, options2) => {
+          return destination;
+        },
+        unpipe: (destination) => {
+          return res;
+        },
+        addListener: resEE.addListener.bind(resEE),
+        removeListener: resEE.removeListener.bind(resEE),
+        prependListener: resEE.prependListener.bind(resEE),
+        prependOnceListener: resEE.prependOnceListener.bind(resEE),
+        removeAllListeners: resEE.removeAllListeners.bind(resEE),
+        setMaxListeners: resEE.setMaxListeners.bind(resEE),
+        getMaxListeners: resEE.getMaxListeners.bind(resEE),
+        listeners: resEE.listeners.bind(resEE),
+        rawListeners: resEE.rawListeners.bind(resEE),
+        listenerCount: resEE.listenerCount.bind(resEE),
+        eventNames: resEE.eventNames.bind(resEE),
+        status(code) {
+          statusCode = code;
+          res.statusCode = code;
+          return res;
+        },
+        sendStatus(code) {
+          const statusTexts = {
+            100: "Continue",
+            101: "Switching Protocols",
+            200: "OK",
+            201: "Created",
+            202: "Accepted",
+            203: "Non-Authoritative Information",
+            204: "No Content",
+            205: "Reset Content",
+            206: "Partial Content",
+            300: "Multiple Choices",
+            301: "Moved Permanently",
+            302: "Found",
+            303: "See Other",
+            304: "Not Modified",
+            307: "Temporary Redirect",
+            308: "Permanent Redirect",
+            400: "Bad Request",
+            401: "Unauthorized",
+            402: "Payment Required",
+            403: "Forbidden",
+            404: "Not Found",
+            405: "Method Not Allowed",
+            406: "Not Acceptable",
+            407: "Proxy Authentication Required",
+            408: "Request Timeout",
+            409: "Conflict",
+            410: "Gone",
+            411: "Length Required",
+            412: "Precondition Failed",
+            413: "Payload Too Large",
+            414: "URI Too Long",
+            415: "Unsupported Media Type",
+            416: "Range Not Satisfiable",
+            417: "Expectation Failed",
+            418: "I'm a teapot",
+            422: "Unprocessable Entity",
+            425: "Too Early",
+            426: "Upgrade Required",
+            428: "Precondition Required",
+            429: "Too Many Requests",
+            431: "Request Header Fields Too Large",
+            451: "Unavailable For Legal Reasons",
+            500: "Internal Server Error",
+            501: "Not Implemented",
+            502: "Bad Gateway",
+            503: "Service Unavailable",
+            504: "Gateway Timeout",
+            505: "HTTP Version Not Supported",
+            507: "Insufficient Storage",
+            508: "Loop Detected",
+            510: "Not Extended",
+            511: "Network Authentication Required"
+          };
+          const statusText = statusTexts[code] || "Unknown Status";
+          res.status(code).send(statusText);
+          return res;
+        },
+        set(field, value) {
+          if (typeof field === "string" && value !== void 0) {
+            res.setHeader(field, value);
+          } else if (typeof field === "object") {
+            for (const [k, v] of Object.entries(field)) res.setHeader(k, v);
+          }
+          return res;
+        },
+        header(name, value) {
+          if (value !== void 0) {
+            res.setHeader(name, value);
+            return res;
+          }
+          return res;
+        },
+        get(name) {
+          return res.getHeader(name);
+        },
+        type(contentType) {
+          if (contentType.includes("/")) {
+            res.setHeader("Content-Type", contentType);
+          } else {
+            const mime = extMime(`file.${contentType}`);
+            if (mime) res.setHeader("Content-Type", mime);
+          }
+          return res;
+        },
+        contentType(type) {
+          return res.type(type);
+        },
+        location(url2) {
+          res.setHeader("Location", url2);
+          return res;
+        },
+        redirect(arg1, arg2) {
+          let code = 302;
+          let location = "";
+          if (typeof arg1 === "number") {
+            code = arg1;
+            location = String(arg2);
+          } else {
+            location = String(arg1);
+          }
+          res.status(code);
+          res.setHeader("Location", location);
+          if (req.accepts("html")) {
+            return res.type("html").end(
+              `<p>Redirecting to <a href="${location}">${location}</a></p>`
+            );
+          } else {
+            return res.type("txt").end(`Redirecting to ${location}`);
+          }
+        },
+        json(obj) {
+          if (!headerMap.has("content-type"))
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+          return res.end(JSON.stringify(obj));
+        },
+        jsonp(obj) {
+          const callback = req.query.callback || req.query.jsonp;
+          if (callback && typeof callback === "string") {
+            res.setHeader("Content-Type", "text/javascript; charset=utf-8");
+            const callbackName = callback.replace(/[^\w$]/g, "");
+            return res.end(
+              `/**/ typeof ${callbackName} === 'function' && ${callbackName}(${JSON.stringify(obj)});`
+            );
+          }
+          return res.json(obj);
+        },
+        send(body) {
+          if (body == null) return res.end();
+          if (Buffer.isBuffer(body)) return res.end(body);
+          if (typeof body === "object") {
+            if (!headerMap.has("content-type"))
+              res.type("application/json; charset=utf-8");
+            return res.end(JSON.stringify(body));
+          }
+          if (typeof body === "number") {
+            return res.sendStatus(body);
+          }
+          if (!headerMap.has("content-type"))
+            res.type("text/plain; charset=utf-8");
+          return res.end(String(body));
+        },
+        cookie(name, value, options2) {
+          const opts2 = options2 || {};
+          let cookieValue = value;
+          if (opts2.signed) {
+            cookieValue = signCookie(value, cookieSecret);
+            name = `s:${name}`;
+          }
+          headerMap.append(
+            "Set-Cookie",
+            serializeCookie(name, cookieValue, opts2)
+          );
+          return res;
+        },
+        clearCookie(name, options2) {
+          const opts2 = { ...options2 || {}, expires: /* @__PURE__ */ new Date(0), maxAge: 0 };
+          headerMap.append("Set-Cookie", serializeCookie(name, "", opts2));
+          return res;
+        },
+        sendFile: function(filePath, optionsOrFn, fn) {
+          let options2 = {};
+          let callback;
+          if (typeof optionsOrFn === "function") {
+            callback = optionsOrFn;
+          } else {
+            options2 = optionsOrFn || {};
+            callback = fn;
+          }
+          (async () => {
+            try {
+              const fullPath = options2.root ? path.join(options2.root, filePath) : filePath;
+              if (options2.dotfiles === "deny" && path.basename(fullPath).startsWith(".")) {
+                res.status(403);
+                res.end("Forbidden");
+                if (callback) callback(new Error("Forbidden"));
+                return;
+              }
+              const file = Bun.file(fullPath);
+              if (!await file.exists()) {
+                res.status(404);
+                res.end("Not Found");
+                if (callback) callback(new Error("Not Found"));
+                return;
+              }
+              const stats = await file.size;
+              const lastModified = new Date(file.lastModified);
+              if (options2.cacheControl !== false) {
+                const maxAge = options2.maxAge || 0;
+                res.setHeader("Cache-Control", `public, max-age=${maxAge}`);
+              }
+              if (options2.lastModified !== false) {
+                res.setHeader("Last-Modified", lastModified.toUTCString());
+              }
+              if (options2.etag !== false) {
+                const etag = `"${stats}-${lastModified.getTime()}"`;
+                res.setHeader("ETag", etag);
+              }
+              const ifModifiedSince = req.get("if-modified-since");
+              const ifNoneMatch = req.get("if-none-match");
+              if (ifModifiedSince && new Date(ifModifiedSince) >= lastModified) {
+                res.status(304).end();
+                if (callback) callback(void 0);
+                return;
+              }
+              if (ifNoneMatch && ifNoneMatch === res.getHeader("ETag")) {
+                res.status(304).end();
+                if (callback) callback(void 0);
+                return;
+              }
+              const mime = extMime(fullPath);
+              if (mime) res.setHeader("Content-Type", mime);
+              res.setHeader("Content-Length", stats.toString());
+              if (options2.headers) {
+                for (const [k, v] of Object.entries(options2.headers))
+                  if (v) res.setHeader(k, v);
+              }
+              headersSent = true;
+              res.headersSent = true;
+              ensureResponse();
+              const reader = file.stream().getReader();
+              try {
+                while (true) {
+                  const { done, value } = await reader.read();
+                  if (done) break;
+                  if (value) await writer.write(value);
+                }
+              } finally {
+                await writer.close();
+                resEE.emit("finish");
+                if (callback) callback(void 0);
+              }
+            } catch (error) {
+              if (callback) callback(error);
+            }
+          })();
+        },
+        download(filePath, filename, options2, callback) {
+          const downloadFilename = filename || path.basename(filePath);
+          res.setHeader(
+            "Content-Disposition",
+            `attachment; filename="${downloadFilename}"`
+          );
+          if (typeof options2 === "function") {
+            callback = options2;
+            options2 = {};
+          }
+          res.sendFile(filePath, options2 || {});
+          return res;
+        },
+        render: (view, locals, callback) => {
+          const errback = typeof locals === "function" ? locals : callback;
+          try {
+            const templateLocals = {
+              ...res.locals,
+              ...typeof locals === "function" ? {} : locals
+            };
+            let html = `<!DOCTYPE html><html><head><title>${view}</title></head><body>`;
+            html += `<h1>View: ${view}</h1>`;
+            html += `<pre>${JSON.stringify(templateLocals, null, 2)}</pre>`;
+            html += `</body></html>`;
+            if (errback) {
+              errback(new Error("Template rendering error"), html);
+            } else {
+              res.setHeader("Content-Type", "text/html; charset=utf-8");
+              res.send(html);
+            }
+          } catch (error) {
+            if (errback) {
+              errback(error, "");
+            } else {
+              res.status(500).send("Template rendering error");
+            }
+          }
+          return res;
+        },
+        links(links) {
+          const existing = res.getHeader("Link");
+          const linkHeader = Object.entries(links).map(([rel, url2]) => `<${url2}>; rel="${rel}"`).join(", ");
+          if (existing) {
+            res.setHeader("Link", `${existing}, ${linkHeader}`);
+          } else {
+            res.setHeader("Link", linkHeader);
+          }
+          return res;
+        },
+        sendfile: function(path2, options2, callback) {
+          if (!callback && !options2) {
+            return res.sendFile(path2);
+          } else if (!callback && options2) {
+            return res.sendFile(path2, options2);
+          } else if (callback && options2) {
+            return res.sendFile(path2, options2, callback);
+          }
+        },
+        attachment(filename) {
+          if (filename) {
+            res.setHeader(
+              "Content-Disposition",
+              `attachment; filename="${filename}"`
+            );
+            const mime = extMime(filename);
+            if (mime) res.type(mime);
+          } else {
+            res.setHeader("Content-Disposition", "attachment");
+          }
+          return res;
+        },
+        format(obj) {
+          const accepted = req.accepts(Object.keys(obj));
+          if (accepted && obj[accepted]) {
+            return obj[accepted]();
+          }
+          const defaultHandler = obj.default;
+          if (defaultHandler) {
+            return defaultHandler();
+          }
+          return res.status(406).send("Not Acceptable");
+        },
+        vary(field) {
+          const fields = Array.isArray(field) ? field : [field];
+          const existing = res.getHeader("Vary");
+          const varyHeader = existing ? `${existing}, ${fields.join(", ")}` : fields.join(", ");
+          res.setHeader("Vary", varyHeader);
+          return res;
+        },
+        append(field, value) {
+          const existing = res.getHeader(field);
+          if (existing) {
+            const newValue = Array.isArray(value) ? value.join(", ") : value;
+            res.setHeader(field, `${existing}, ${newValue}`);
+          } else {
+            res.setHeader(field, value);
+          }
+          return res;
+        },
+        writeContinue: () => {
+          return res;
+        },
+        writeEarlyHints: (hints) => {
+          return res;
+        },
+        assignSocket: (socket2) => {
+          Object.defineProperty(res, "socket", {
+            value: socket2,
+            writable: true,
+            enumerable: false,
+            configurable: true
+          });
+          return res;
+        },
+        detachSocket: (socket2) => {
+          Object.defineProperty(res, "socket", {
+            value: void 0,
+            writable: true,
+            enumerable: false,
+            configurable: true
+          });
+          return res;
+        },
+        app
+      });
+      const reqEE = new EventEmitter();
+      Object.getOwnPropertyNames(nodeReq).forEach((key) => {
+        if (key !== "constructor") {
+          try {
+            const descriptor = Object.getOwnPropertyDescriptor(nodeReq, key);
+            if (descriptor && descriptor.configurable !== false && descriptor.writable !== false) {
+              Object.defineProperty(reqEE, key, descriptor);
+            } else {
+              openTelemetryCollector.info(
+                "Property not configurable or writable:",
+                key
+              );
+            }
+          } catch (e) {
+            openTelemetryCollector.error("Error defining property:", e);
+          }
+        }
+      });
+      const req = Object.assign(reqEE, {
+        method: request.method,
+        url: url.pathname + url.search,
+        originalUrl: url.pathname + url.search,
+        headers,
+        httpVersion: "1.1",
+        httpVersionMajor: 1,
+        httpVersionMinor: 1,
+        complete: false,
+        socket,
+        connection: socket,
+        protocol: proto,
+        secure: proto === "https",
+        ip,
+        ips: forwardedFor ? Array.isArray(forwardedFor) ? forwardedFor : forwardedFor.split(",").map((s) => s.trim()) : [],
+        hostname: Array.isArray(headers["x-forwarded-host"] || headers["host"]) ? (headers["x-forwarded-host"] || headers["host"])[0].split(":")[0] : (headers["x-forwarded-host"] || headers["host"] || "").split(
+          ":"
+        )[0],
+        host: Array.isArray(headers["x-forwarded-host"] || headers["host"]) ? (headers["x-forwarded-host"] || headers["host"])[0] : headers["x-forwarded-host"] || headers["host"] || "",
+        path: url.pathname,
+        query,
+        params: {},
+        // Will be populated by route matching
+        body: void 0,
+        // Will be populated by body parsing middleware
+        cookies,
+        signedCookies,
+        secret: cookieSecret,
+        accepted: [],
+        subdomains: (() => {
+          const hostname = Array.isArray(
+            headers["x-forwarded-host"] || headers["host"]
+          ) ? (headers["x-forwarded-host"] || headers["host"])[0].split(":")[0] : (headers["x-forwarded-host"] || headers["host"] || "").split(
+            ":"
+          )[0];
+          if (!hostname) return [];
+          const parts = hostname.split(".");
+          return parts.length > 2 ? parts.slice(0, -2).reverse() : [];
+        })(),
+        get fresh() {
+          const method = request.method;
+          const status = res.statusCode;
+          if (method !== "GET" && method !== "HEAD") return false;
+          if (status >= 200 && status < 300 || status === 304) {
+            const modifiedSince = headers["if-modified-since"];
+            const noneMatch = headers["if-none-match"];
+            const lastModified = res.get("last-modified");
+            const etag = res.get("etag");
+            if (noneMatch && etag) {
+              return noneMatch.includes(etag);
+            }
+            if (modifiedSince && lastModified) {
+              return new Date(modifiedSince) >= new Date(lastModified);
+            }
+          }
+          return false;
+        },
+        get stale() {
+          return !this.fresh;
+        },
+        xhr: (() => {
+          const requestedWith = headers["x-requested-with"];
+          return requestedWith === "XMLHttpRequest";
+        })(),
+        get: ((name) => {
+          const value = headers[name.toLowerCase()];
+          if (!value) return void 0;
+          return Array.isArray(value) ? value[0] : value;
+        }),
+        header: ((name) => {
+          const value = headers[name.toLowerCase()];
+          if (!value) return void 0;
+          return Array.isArray(value) ? value[0] : value;
+        }),
+        is(types) {
+          const contentType = headers["content-type"] || "";
+          if (!contentType) return false;
+          const typesToCheck = Array.isArray(types) ? types : [types];
+          for (const type of typesToCheck) {
+            if (type === "json" && contentType.includes("application/json"))
+              return "json";
+            if (type === "html" && contentType.includes("text/html"))
+              return "html";
+            if (type === "xml" && contentType.includes("application/xml"))
+              return "xml";
+            if (type === "text" && contentType.includes("text/")) return "text";
+            if (contentType.includes(type)) return type;
+          }
+          return false;
+        },
+        accepts: ((types) => {
+          const accept = headers.accept || "*/*";
+          if (!types) {
+            const acceptStr2 = Array.isArray(accept) ? accept.join(",") : accept;
+            return acceptStr2.split(",").map((t) => t.trim().split(";")[0]);
+          }
+          const typesToCheck = Array.isArray(types) ? types : [types];
+          const acceptStr = Array.isArray(accept) ? accept.join(",") : accept;
+          const result = [];
+          for (const type of typesToCheck) {
+            if (acceptStr.includes(type) || acceptStr.includes("*/*")) {
+              result.push(type);
+            }
+            if (type === "json" && acceptStr.includes("application/json"))
+              result.push("json");
+            if (type === "html" && acceptStr.includes("text/html"))
+              result.push("html");
+            if (type === "xml" && acceptStr.includes("application/xml"))
+              result.push("xml");
+          }
+          return result;
+        }),
+        acceptsCharsets: ((charsets) => {
+          const acceptCharset = headers["accept-charset"] || "*";
+          const acceptCharsetStr = Array.isArray(acceptCharset) ? acceptCharset.join(",") : acceptCharset;
+          if (!charsets)
+            return acceptCharsetStr.split(",").map((c) => c.trim());
+          const charsetsToCheck = Array.isArray(charsets) ? charsets : [charsets];
+          const result = [];
+          for (const charset of charsetsToCheck) {
+            if (acceptCharsetStr.includes(charset) || acceptCharsetStr.includes("*")) {
+              result.push(charset);
+            }
+          }
+          return result;
+        }),
+        acceptsEncodings: ((encodings) => {
+          const acceptEncoding = headers["accept-encoding"] || "identity";
+          const acceptEncodingStr = Array.isArray(acceptEncoding) ? acceptEncoding.join(",") : acceptEncoding;
+          if (!encodings)
+            return acceptEncodingStr.split(",").map((e) => e.trim());
+          const encodingsToCheck = Array.isArray(encodings) ? encodings : [encodings];
+          const result = [];
+          for (const encoding of encodingsToCheck) {
+            if (acceptEncodingStr.includes(encoding) || acceptEncodingStr.includes("*")) {
+              result.push(encoding);
+            }
+          }
+          return result;
+        }),
+        acceptsLanguages: ((languages) => {
+          const acceptLanguage = headers["accept-language"] || "*";
+          const acceptLanguageStr = Array.isArray(acceptLanguage) ? acceptLanguage.join(",") : acceptLanguage;
+          if (!languages)
+            return acceptLanguageStr.split(",").map((l) => l.trim());
+          const languagesToCheck = Array.isArray(languages) ? languages : [languages];
+          const result = [];
+          for (const language of languagesToCheck) {
+            if (acceptLanguageStr.includes(language) || acceptLanguageStr.includes("*")) {
+              result.push(language);
+            }
+          }
+          return result;
+        }),
+        range(size, options2) {
+          const rangeHeader = headers.range;
+          if (!rangeHeader) return void 0;
+          const rangeStr = Array.isArray(rangeHeader) ? rangeHeader[0] : rangeHeader;
+          return RangeParser(size, rangeStr, options2);
+        },
+        param(name, defaultValue) {
+          if (this.params && this.params[name] !== void 0) {
+            return this.params[name];
+          }
+          if (this.query && this.query[name] !== void 0) {
+            return this.query[name];
+          }
+          if (this.body && typeof this.body === "object" && this.body[name] !== void 0) {
+            return this.body[name];
+          }
+          return defaultValue;
+        },
+        app,
+        baseUrl: app.basePath || "",
+        route: {
+          path: pathname,
+          stack: [],
+          methods: { [request.method.toLowerCase()]: true }
+        },
+        res,
+        next: (() => {
+        }),
+        rawHeaders: Object.entries(headers).flat(),
+        trailers: {},
+        rawTrailers: [],
+        aborted: false,
+        upgrade: false,
+        readable: true,
+        readableHighWaterMark: 16384,
+        readableLength: 0,
+        destroyed: false,
+        closed: false,
+        clearCookie: (name, options2) => {
+          const opts2 = Object.assign({}, options2);
+          opts2.expires = /* @__PURE__ */ new Date(1);
+          opts2.path = opts2.path || "/";
+          return res.cookie(name, "", opts2);
+        },
+        setTimeout: (msecs, callback) => {
+          setTimeout(callback || (() => {
+          }), msecs);
+          return req;
+        },
+        headersDistinct: Object.fromEntries(
+          Object.entries(headers).map(([key, value]) => [
+            key,
+            Array.isArray(value) ? value : [value]
+          ])
+        ),
+        trailersDistinct: {}
+      });
+      Object.assign(req, {
+        res,
+        req
+      });
+      Object.assign(res, {
+        req,
+        res
+      });
+      const onAbort = () => {
+        cleanup();
+        Object.assign(req, {
+          aborted: true,
+          destroyed: true
+        });
+        resEE.emit("close");
+        req.emit("close");
+        req.emit("aborted");
+        writer.abort("client aborted");
+      };
+      abort.signal.addEventListener("abort", onAbort);
+      res.once("finish", cleanup);
+      res.once("close", cleanup);
+      res.once("finish", () => {
+        abort.signal.removeEventListener("abort", onAbort);
+      });
+      res.once("close", () => {
+        abort.signal.removeEventListener("abort", onAbort);
+      });
+      try {
+        req.on("error", (error) => {
+          openTelemetryCollector.error("Request error:", error);
+          req.emit("aborted");
+          if (!res.headersSent) {
+            res.status(400).send("Bad Request: aborted");
+          }
+        });
+        req.on("timeout", () => {
+          openTelemetryCollector.warn("Request timeout:", req.method, req.path);
+          if (!res.headersSent) {
+            res.status(408).send("Request Timeout");
+          }
+        });
+        res.on("error", (error) => {
+          openTelemetryCollector.error("Response error:", error);
+          res.emit("close");
+        });
+        const next = (error) => {
+          if (error) {
+            openTelemetryCollector.error("Express middleware error:", error);
+            if (!res.headersSent) {
+              const status = error?.status || error?.statusCode || 500;
+              res.status(status);
+              if (development) {
+                const message = error?.message || String(error);
+                res.send(`${status} ${message}`);
+              } else {
+                const message = status === 404 ? "Not Found" : status === 401 ? "Unauthorized" : status === 403 ? "Forbidden" : status === 400 ? "Bad Request" : "Internal Server Error";
+                res.send(message);
+              }
+            }
+            return;
+          }
+        };
+        if (development) {
+          openTelemetryCollector.info(
+            `${request.method} ${pathname} - Started`
+          );
+        }
+        try {
+          app(req, res, next);
+        } catch (syncError) {
+          openTelemetryCollector.error(
+            "Synchronous Express application error:",
+            syncError
+          );
+          next(syncError);
+        }
+      } catch (error) {
+        openTelemetryCollector.error("Request processing error:", error);
+        const message = development ? error.message || String(error) : "Internal Server Error";
+        return new Response(message, {
+          status: 500,
+          headers: { "content-type": "text/plain" }
+        });
+      }
+      queueMicrotask(() => {
+        if (!responded && (res.headersSent || res.statusCode !== 200)) {
+          ensureResponse();
+        }
+      });
+      if (development) {
+        setTimeout(() => {
+          if (!responded && !serverClosed) {
+            try {
+              openTelemetryCollector.warn(
+                `Request timeout: ${request.method} ${pathname} - No response after 30s`
+              );
+              openTelemetryCollector.warn(
+                `Headers sent: ${res.headersSent}, Status: ${res.statusCode}`
+              );
+              if (!res.headersSent) {
+                res.status(504).send("Gateway Timeout");
+              } else {
+                writer.close();
+                ensureResponse();
+              }
+            } catch (error) {
+              openTelemetryCollector.error(
+                "Error sending timeout response:",
+                error
+              );
+              if (!responded) {
+                ensureResponse();
+              }
+            }
+          }
+        }, 3e4);
+      }
+      return await responsePromise;
+    }
+  });
+  const serverObj = {
+    port: server.port,
+    hostname: server.hostname,
+    url: `${tls2 ? "https" : "http"}://${host === "0.0.0.0" ? "localhost" : host}:${server.port}`,
+    stop(force = false) {
+      serverClosed = true;
+      openTelemetryCollector.info(`Stopping server on port ${server.port}...`);
+      server.stop(force);
+    },
+    reload() {
+      if (development) {
+        openTelemetryCollector.info(
+          "Server reload requested - restart server to apply changes"
+        );
+      }
+    },
+    address() {
+      return {
+        port: server.port,
+        family: "IPv4",
+        address: host
+      };
+    },
+    listening: true,
+    connections: 0,
+    maxConnections: void 0,
+    on: (event, listener) => {
+      if (event === "listening") {
+        process.nextTick(listener);
+      }
+      return serverObj;
+    },
+    once: (event, listener) => {
+      if (event === "listening") {
+        process.nextTick(listener);
+      }
+      return serverObj;
+    },
+    emit: (event, ...args) => {
+      return true;
+    },
+    async close(callback) {
+      try {
+        serverClosed = true;
+        server.stop(true);
+        if (callback) callback();
+      } catch (error) {
+        if (callback) callback(error);
+      }
+    },
+    getConnections(callback) {
+      process.nextTick(() => callback(null, serverObj.connections));
+    }
+  };
+  if (development) {
+    openTelemetryCollector.info(
+      `\u{1F680} Express server running on ${serverObj.url}`
+    );
+    openTelemetryCollector.info(
+      `\u{1F4C1} Environment: ${development ? "development" : "production"}`
+    );
+  }
+  return serverObj;
+}
+
+// src/cluster/bun.cluster.ts
+function startBunCluster(config) {
+  const WORKERS = config.workerCount;
+  const PORT = config.port;
+  const HOST = config.host;
+  const openTelemetryCollector = config.openTelemetryCollector;
+  if (WORKERS > os.cpus().length) {
+    throw new Error("Worker count cannot be greater than the number of CPUs");
+  }
+  if (cluster.isPrimary) {
+    let startWorker2 = function(i) {
+      if (isShuttingDown) return;
+      const worker = cluster.fork({
+        WORKER_INDEX: String(i),
+        PORT: String(PORT)
+      });
+      workers.set(worker.id, worker);
+      worker.on("exit", () => {
+        if (isShuttingDown) {
+          return;
+        }
+        workers.delete(worker.id);
+        openTelemetryCollector.warn(
+          `worker ${worker.process.pid} died; restarting in 2s`
+        );
+        setTimeout(() => {
+          if (!isShuttingDown) {
+            startWorker2(i);
+          }
+        }, 2e3);
+      });
+      worker.on("message", (message) => {
+        if (message && message.type === "worker-ready") {
+          openTelemetryCollector.info(
+            `Worker ${i} (PID: ${worker.process.pid}) ready`
+          );
+        }
+      });
+    };
+    var startWorker = startWorker2;
+    const workers = /* @__PURE__ */ new Map();
+    let isShuttingDown = false;
+    openTelemetryCollector.info(
+      `[primary ${process.pid}] starting ${WORKERS} workers on :${PORT}. Ignoring routing strategy due to SO_REUSEPORT kernel level routing.`
+    );
+    for (let i = 0; i < WORKERS; i++) {
+      startWorker2(i);
+    }
+    process.on("SIGINT", () => {
+      isShuttingDown = true;
+      openTelemetryCollector.info(
+        "Received SIGINT, shutting down gracefully..."
+      );
+      workers.forEach((worker) => {
+        worker.send({ type: "shutdown" });
+        worker.kill("SIGTERM");
+      });
+      setTimeout(() => {
+        workers.forEach((worker) => worker.kill("SIGKILL"));
+        process.exit(0);
+      }, 5e3);
+    });
+  } else {
+    const PORT2 = Number(process.env.PORT || 6935);
+    const IDX = process.env.WORKER_INDEX ?? "0";
+    const server = serveExpress(
+      config.expressApp,
+      config.openTelemetryCollector,
+      {
+        port: PORT2,
+        host: HOST,
+        reusePort: true,
+        development: false,
+        tls: config.ssl
+      }
+    );
+    if (process.send) {
+      process.send({ type: "worker-ready", port: server.port, index: IDX });
+    }
+    setInterval(() => {
+      const memUsage = process.memoryUsage();
+      const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
+      if (heapUsedMB > 100) {
+        openTelemetryCollector.warn(
+          `High memory usage on worker ${process.pid}: ${heapUsedMB} MB`
+        );
+      }
+    }, 3e4);
+    process.on("SIGINT", () => {
+      openTelemetryCollector.info(
+        `[worker ${process.pid}] shutting down gracefully...`
+      );
+      server.stop();
+      process.exit(0);
+    });
+    process.on("message", (message) => {
+      if (message?.type === "shutdown") {
+        openTelemetryCollector.info(
+          `[worker ${process.pid}] received shutdown signal from primary`
+        );
+        server.stop();
+        process.exit(0);
+      }
+    });
+    process.on("uncaughtException", (err) => {
+      openTelemetryCollector.error(
+        `Uncaught exception on worker ${process.pid}:`,
+        err
+      );
+      process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+      openTelemetryCollector.error(
+        `Unhandled rejection on worker ${process.pid}:`,
+        reason
+      );
+      process.exit(1);
+    });
+  }
+}
+
+// src/cluster/node.cluster.ts
+import { hashString } from "@forklaunch/common";
+import cluster2 from "cluster";
+import fs from "fs";
+import http from "http";
+import https from "https";
+import net from "net";
+import os2 from "os";
+import tls from "tls";
+function startNodeCluster(config) {
+  const PORT = config.port;
+  const HOST = config.host;
+  const WORKERS = config.workerCount;
+  const ROUTING_STRATEGY = config.routingStrategy || "round-robin";
+  const app = config.expressApp;
+  const openTelemetryCollector = config.openTelemetryCollector;
+  const SSL_CONFIG = config.ssl;
+  if (WORKERS > os2.cpus().length) {
+    throw new Error("Worker count cannot be greater than the number of CPUs");
+  }
+  let sslOptions;
+  if (SSL_CONFIG) {
+    try {
+      sslOptions = {
+        key: fs.readFileSync(SSL_CONFIG.keyFile),
+        cert: fs.readFileSync(SSL_CONFIG.certFile),
+        ca: fs.readFileSync(SSL_CONFIG.caFile)
+      };
+      openTelemetryCollector.info(`SSL/TLS configuration loaded from files`);
+    } catch (error) {
+      openTelemetryCollector.error(
+        "Failed to load SSL/TLS certificates:",
+        error
+      );
+      throw new Error("SSL/TLS configuration failed");
+    }
+  }
+  if (cluster2.isPrimary) {
+    let getWorker2 = function(remoteAddress) {
+      switch (ROUTING_STRATEGY) {
+        case "sticky": {
+          const ip = remoteAddress ?? "";
+          const idx = hashString(ip) % workers.length;
+          return workers[idx];
+        }
+        case "random": {
+          return workers[Math.floor(Math.random() * workers.length)];
+        }
+        case "round-robin":
+        default: {
+          const worker = workers[currentWorkerIndex];
+          currentWorkerIndex = (currentWorkerIndex + 1) % workers.length;
+          return worker;
+        }
+      }
+    };
+    var getWorker = getWorker2;
+    cluster2.setupPrimary({ execArgv: process.execArgv });
+    const protocol = SSL_CONFIG ? "https" : "http";
+    openTelemetryCollector.info(
+      `[primary ${process.pid}] starting ${WORKERS} workers with ${ROUTING_STRATEGY} routing on ${protocol}://${HOST}:${PORT}`
+    );
+    const workers = Array.from({ length: WORKERS }, (_, i) => {
+      const worker = cluster2.fork();
+      worker.on(
+        "message",
+        (message) => {
+          if (message && message.type === "worker-ready") {
+            openTelemetryCollector.info(
+              `Worker ${message.index || i} (PID: ${worker.process.pid}) ready`
+            );
+          }
+        }
+      );
+      return worker;
+    });
+    let currentWorkerIndex = 0;
+    const server = SSL_CONFIG ? tls.createServer(sslOptions, (socket) => {
+      const w = getWorker2(socket.remoteAddress);
+      w.send({ type: "sticky-connection" }, socket);
+    }) : net.createServer({ pauseOnConnect: true }, (socket) => {
+      const w = getWorker2(socket.remoteAddress);
+      w.send({ type: "sticky-connection" }, socket);
+    });
+    server.on("error", (err) => {
+      openTelemetryCollector.error("primary net server error:", err);
+    });
+    server.listen(PORT, HOST, () => {
+      const protocol2 = SSL_CONFIG ? "https" : "http";
+      openTelemetryCollector.info(
+        `[primary ${process.pid}] listening on ${protocol2}://${HOST}:${PORT}`
+      );
+    });
+    cluster2.on("exit", (worker) => {
+      openTelemetryCollector.warn(
+        `worker ${worker.process.pid} died; restarting`
+      );
+      const i = workers.findIndex((w) => w.id === worker.id);
+      const replacement = cluster2.fork();
+      replacement.on(
+        "message",
+        (message) => {
+          if (message && message.type === "worker-ready") {
+            openTelemetryCollector.info(
+              `Worker ${message.index || i} (PID: ${replacement.process.pid}) ready`
+            );
+          }
+        }
+      );
+      if (i !== -1) workers[i] = replacement;
+    });
+    let isShuttingDown = false;
+    process.on("SIGINT", () => {
+      if (isShuttingDown) return;
+      isShuttingDown = true;
+      openTelemetryCollector.info(
+        "Received SIGINT, shutting down gracefully..."
+      );
+      workers.forEach((worker) => {
+        worker.send({ type: "shutdown" });
+        worker.kill("SIGTERM");
+      });
+      setTimeout(() => {
+        workers.forEach((worker) => worker.kill("SIGKILL"));
+        process.exit(0);
+      }, 5e3);
+    });
+  } else {
+    const server = SSL_CONFIG ? https.createServer(sslOptions, app) : http.createServer(app);
+    const IDX = process.env.WORKER_INDEX ?? cluster2.worker?.id ?? "0";
+    process.on("message", (msg, socket) => {
+      if (msg?.type === "sticky-connection" && socket) {
+        server.emit("connection", socket);
+        socket.resume();
+      } else if (msg?.type === "shutdown") {
+        openTelemetryCollector.info(
+          `[worker ${process.pid}] received shutdown signal from primary`
+        );
+        server.close(() => {
+          process.exit(0);
+        });
+      }
+    });
+    server.on("clientError", (err, socket) => {
+      try {
+        const response = SSL_CONFIG ? "HTTP/1.1 400 Bad Request\r\n\r\n" : "HTTP/1.1 400 Bad Request\r\n\r\n";
+        socket.end(response);
+      } catch {
+        openTelemetryCollector.error("clientError", err);
+      }
+    });
+    server.listen(0, () => {
+      if (process.send) {
+        process.send({ type: "worker-ready", port: PORT, index: IDX });
+      }
+    });
+    setInterval(() => {
+      const memUsage = process.memoryUsage();
+      const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
+      if (heapUsedMB > 100) {
+        openTelemetryCollector.warn(
+          `High memory usage on worker ${process.pid}: ${heapUsedMB} MB`
+        );
+      }
+    }, 3e4);
+    process.on("uncaughtException", (err) => {
+      openTelemetryCollector.error(
+        `Uncaught exception on worker ${process.pid}:`,
+        err
+      );
+      process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+      openTelemetryCollector.error(
+        `Unhandled rejection on worker ${process.pid}:`,
+        reason
+      );
+      process.exit(1);
+    });
+    const protocol = SSL_CONFIG ? "https" : "http";
+    openTelemetryCollector.info(
+      `[worker ${process.pid}] ready (awaiting sockets from primary) - ${protocol}`
+    );
+  }
+}
+
 // src/middleware/content.parse.middleware.ts
 import { isNever } from "@forklaunch/common";
 import { discriminateBody } from "@forklaunch/core/http";
@@ -143,6 +2014,9 @@ function enrichResponseTransmission(req, res, next) {
 // src/expressApplication.ts
 var Application = class extends ForklaunchExpressLikeApplication {
   docsConfiguration;
+  mcpConfiguration;
+  openapiConfiguration;
+  hostingConfiguration;
   /**
    * Creates an instance of Application.
    *
@@ -161,90 +2035,153 @@ var Application = class extends ForklaunchExpressLikeApplication {
       openTelemetryCollector,
       options2
     );
+    console.log("this.routerOptions offa", this.routerOptions);
+    this.hostingConfiguration = options2?.hosting;
     this.docsConfiguration = options2?.docs;
+    this.mcpConfiguration = options2?.mcp;
+    this.openapiConfiguration = options2?.openapi;
   }
   listen(...args) {
     const port = typeof args[0] === "number" ? args[0] : Number(process.env.PORT);
     const host = typeof args[1] === "string" ? args[1] : process.env.HOST ?? "localhost";
     const protocol = process.env.PROTOCOL ?? "http";
-    const openApiServerUrls = getEnvVar("DOCS_SERVER_URLS")?.split(",") ?? [
-      `${protocol}://${host}:${port}`
-    ];
-    const openApiServerDescriptions = getEnvVar(
-      "DOCS_SERVER_DESCRIPTIONS"
-    )?.split(",") ?? ["Main Server"];
-    const openApi = generateOpenApiSpecs(
-      this.schemaValidator,
-      openApiServerUrls,
-      openApiServerDescriptions,
-      this
-    );
-    if (this.schemaValidator instanceof ZodSchemaValidator) {
+    if (this.schemaValidator instanceof ZodSchemaValidator && this.mcpConfiguration !== false) {
+      const {
+        port: mcpPort,
+        options: options2,
+        path: mcpPath,
+        version,
+        additionalTools,
+        contentTypeMapping
+      } = this.mcpConfiguration ?? {};
       const zodSchemaValidator = this.schemaValidator;
+      const finalMcpPort = mcpPort ?? port + 2e3;
       const mcpServer = generateMcpServer(
         zodSchemaValidator,
         protocol,
         host,
-        port,
-        "1.0.0",
-        this
+        finalMcpPort,
+        version ?? "1.0.0",
+        this,
+        this.mcpConfiguration,
+        options2,
+        contentTypeMapping
       );
-      mcpServer.start({
-        httpStream: {
-          host,
-          endpoint: "/mcp",
-          port: port + 1
-        },
-        transportType: "httpStream"
-      });
+      if (additionalTools) {
+        additionalTools(mcpServer);
+      }
+      if (this.hostingConfiguration?.workerCount && this.hostingConfiguration.workerCount > 1) {
+        isPortBound(finalMcpPort, host).then((isBound) => {
+          if (!isBound) {
+            mcpServer.start({
+              httpStream: {
+                host,
+                endpoint: mcpPath ?? "/mcp",
+                port: finalMcpPort
+              },
+              transportType: "httpStream"
+            });
+          }
+        });
+      } else {
+        mcpServer.start({
+          httpStream: {
+            host,
+            endpoint: mcpPath ?? "/mcp",
+            port: finalMcpPort
+          },
+          transportType: "httpStream"
+        });
+      }
     }
-    if (this.docsConfiguration == null || this.docsConfiguration.type === "scalar") {
-      this.internal.use(
-        `/api${process.env.VERSION ? `/${process.env.VERSION}` : ""}${process.env.DOCS_PATH ?? "/docs"}`,
-        apiReference({
-          ...this.docsConfiguration,
-          sources: [
-            {
-              content: openApi[OPENAPI_DEFAULT_VERSION],
-              title: "API Reference"
-            },
-            ...Object.entries(openApi).map(([version, spec]) => ({
-              content: spec,
-              title: `API Reference - ${version}`
-            })),
-            ...this.docsConfiguration?.sources ?? []
-          ]
-        })
+    if (this.openapiConfiguration !== false) {
+      const openApiServerUrls = getEnvVar("DOCS_SERVER_URLS")?.split(",") ?? [
+        `${protocol}://${host}:${port}`
+      ];
+      const openApiServerDescriptions = getEnvVar(
+        "DOCS_SERVER_DESCRIPTIONS"
+      )?.split(",") ?? ["Main Server"];
+      const openApi = generateOpenApiSpecs(
+        this.schemaValidator,
+        openApiServerUrls,
+        openApiServerDescriptions,
+        this,
+        this.openapiConfiguration
       );
-    } else if (this.docsConfiguration.type === "swagger") {
-      this.internal.use(
-        `/api${process.env.VERSION ? `/${process.env.VERSION}` : ""}${process.env.DOCS_PATH ?? "/docs"}`,
-        swaggerUi.serveFiles(openApi),
-        swaggerUi.setup(openApi)
+      if (this.docsConfiguration == null || this.docsConfiguration.type === "scalar") {
+        this.internal.use(
+          `/api${process.env.VERSION ? `/${process.env.VERSION}` : ""}${process.env.DOCS_PATH ?? "/docs"}`,
+          apiReference({
+            ...this.docsConfiguration,
+            sources: [
+              {
+                content: openApi[OPENAPI_DEFAULT_VERSION],
+                title: "API Reference"
+              },
+              ...Object.entries(openApi).map(([version, spec]) => ({
+                content: typeof this.openapiConfiguration === "boolean" ? spec : this.openapiConfiguration?.discreteVersions === false ? {
+                  ...openApi[OPENAPI_DEFAULT_VERSION],
+                  ...spec
+                } : spec,
+                title: `API Reference - ${version}`
+              })),
+              ...this.docsConfiguration?.sources ?? []
+            ]
+          })
+        );
+      } else if (this.docsConfiguration.type === "swagger") {
+        this.internal.use(
+          `/api${process.env.VERSION ? `/${process.env.VERSION}` : ""}${process.env.DOCS_PATH ?? "/docs"}`,
+          swaggerUi.serveFiles(openApi),
+          swaggerUi.setup(openApi)
+        );
+      }
+      this.internal.get(
+        `/api${process.env.VERSION ? `/${process.env.VERSION}` : ""}/openapi`,
+        (_, res) => {
+          res.type("application/json");
+          res.json({
+            latest: openApi[OPENAPI_DEFAULT_VERSION],
+            ...Object.fromEntries(
+              Object.entries(openApi).map(([version, spec]) => [
+                `v${version}`,
+                typeof this.openapiConfiguration === "boolean" ? spec : this.openapiConfiguration?.discreteVersions === false ? {
+                  ...openApi[OPENAPI_DEFAULT_VERSION],
+                  ...spec
+                } : spec
+              ])
+            )
+          });
+        }
+      );
+      this.internal.get(
+        `/api${process.env.VERSION ? `/${process.env.VERSION}` : ""}/openapi/:id`,
+        async (req, res) => {
+          res.type("application/json");
+          if (req.params.id === "latest") {
+            res.json(openApi[OPENAPI_DEFAULT_VERSION]);
+          } else {
+            if (openApi[req.params.id] == null) {
+              res.status(404).send("Not Found");
+              return;
+            }
+            res.json(
+              typeof this.openapiConfiguration === "boolean" ? openApi[req.params.id] : this.openapiConfiguration?.discreteVersions === false ? {
+                ...openApi[OPENAPI_DEFAULT_VERSION],
+                ...openApi[req.params.id]
+              } : openApi[req.params.id]
+            );
+          }
+        }
+      );
+      this.internal.get(
+        `/api/${process.env.VERSION ?? "v1"}/openapi-hash`,
+        async (_, res) => {
+          const hash = await crypto2.createHash("sha256").update(safeStringify2(openApi)).digest("hex");
+          res.send(hash);
+        }
       );
     }
-    this.internal.get(
-      `/api${process.env.VERSION ? `/${process.env.VERSION}` : ""}/openapi`,
-      (_, res) => {
-        res.type("application/json");
-        res.json({
-          latest: openApi[OPENAPI_DEFAULT_VERSION],
-          ...Object.fromEntries(
-            Object.entries(openApi).map(([version, spec]) => [
-              `v${version}`,
-              spec
-            ])
-          )
-        });
-      }
-    );
-    this.internal.get(
-      `/api/${process.env.VERSION ?? "v1"}/openapi-hash`,
-      async (_, res) => {
-        const hash = await crypto.createHash("sha256").update(safeStringify2(openApi)).digest("hex");
-        res.send(hash);
-      }
-    );
     this.internal.get("/health", (_, res) => {
       res.send("OK");
     });
@@ -266,6 +2203,36 @@ Correlation id: ${isForklaunchRequest(req) ? req.context.correlationId : "No cor
       );
     };
     this.internal.use(errorHandler);
+    const { workerCount, ssl, routingStrategy } = this.hostingConfiguration ?? {};
+    if (workerCount != null && workerCount > 1) {
+      if (typeof Bun !== "undefined") {
+        this.openTelemetryCollector.warn(
+          `Note: bun clustering is experimental, shimmed, and only works on linux. You may have an inconsistent experience, consider creating multiple hosts.`
+        );
+        Object.assign(this.internal, {
+          basePath: this.basePath
+        });
+        startBunCluster({
+          expressApp: this.internal,
+          openTelemetryCollector: this.openTelemetryCollector,
+          port,
+          host,
+          workerCount,
+          routingStrategy,
+          ssl
+        });
+      } else {
+        startNodeCluster({
+          expressApp: this.internal,
+          openTelemetryCollector: this.openTelemetryCollector,
+          port,
+          host,
+          workerCount,
+          routingStrategy,
+          ssl
+        });
+      }
+    }
     return this.internal.listen(...args);
   }
 };
@@ -291,14 +2258,15 @@ var Router = class _Router extends ForklaunchExpressLikeRouter {
         contentParse(options2),
         enrichResponseTransmission
       ],
-      openTelemetryCollector
+      openTelemetryCollector,
+      options2
     );
     this.basePath = basePath;
     this.configOptions = options2;
   }
   configOptions;
-  route(path) {
-    this.internal.route(path);
+  route(path2) {
+    this.internal.route(path2);
     return this;
   }
   param(name, _types, handler) {
@@ -481,229 +2449,233 @@ var Router = class _Router extends ForklaunchExpressLikeRouter {
 import {
   middleware
 } from "@forklaunch/core/http";
-var checkout = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware(schemaValidator, path, contractDetails, ...handlers2);
+var checkout = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/copy.ts
 import {
   middleware as middleware2
 } from "@forklaunch/core/http";
-var copy = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware2(schemaValidator, path, contractDetails, ...handlers2);
+var copy = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware2(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/delete.ts
 import {
   delete_ as innerDelete
 } from "@forklaunch/core/http";
-var delete_ = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return innerDelete(schemaValidator, path, contractDetails, ...handlers2);
+var delete_ = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return innerDelete(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/get.ts
 import {
   get as innerGet
 } from "@forklaunch/core/http";
-var get = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return innerGet(schemaValidator, path, contractDetails, ...handlers2);
+var get = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return innerGet(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/head.ts
 import {
   head as innerHead
 } from "@forklaunch/core/http";
-var head = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return innerHead(schemaValidator, path, contractDetails, ...handlers2);
+var head = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return innerHead(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/link.ts
 import {
   middleware as middleware3
 } from "@forklaunch/core/http";
-var link = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware3(schemaValidator, path, contractDetails, ...handlers2);
+var link = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware3(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/lock.ts
 import {
   middleware as middleware4
 } from "@forklaunch/core/http";
-var lock = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware4(schemaValidator, path, contractDetails, ...handlers2);
+var lock = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware4(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/m-search.ts
 import {
   middleware as middleware5
 } from "@forklaunch/core/http";
-var mSearch = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware5(schemaValidator, path, contractDetails, ...handlers2);
+var mSearch = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware5(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/merge.ts
 import {
   middleware as middleware6
 } from "@forklaunch/core/http";
-var merge = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware6(schemaValidator, path, contractDetails, ...handlers2);
+var merge = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware6(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/middleware.ts
 import {
   middleware as innerMiddleware
 } from "@forklaunch/core/http";
-var middleware7 = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return innerMiddleware(schemaValidator, path, contractDetails, ...handlers2);
+var middleware7 = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return innerMiddleware(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/mkcactivity.ts
 import {
   middleware as middleware8
 } from "@forklaunch/core/http";
-var mkcActivity = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware8(schemaValidator, path, contractDetails, ...handlers2);
+var mkcActivity = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware8(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/mkcol.ts
 import {
   middleware as middleware9
 } from "@forklaunch/core/http";
-var mkcol = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware9(schemaValidator, path, contractDetails, ...handlers2);
+var mkcol = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware9(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/move.ts
 import {
   middleware as middleware10
 } from "@forklaunch/core/http";
-var move = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware10(schemaValidator, path, contractDetails, ...handlers2);
+var move = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware10(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/notify.ts
 import {
   middleware as middleware11
 } from "@forklaunch/core/http";
-var notify = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware11(schemaValidator, path, contractDetails, ...handlers2);
+var notify = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware11(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/options.ts
 import {
   options as innerOptions
 } from "@forklaunch/core/http";
-var options = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return innerOptions(schemaValidator, path, contractDetails, ...handlers2);
+var options = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return innerOptions(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/patch.ts
 import {
   patch as innerPatch
 } from "@forklaunch/core/http";
-var patch = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return innerPatch(schemaValidator, path, contractDetails, ...handlers2);
+var patch = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return innerPatch(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/post.ts
 import {
   post as innerPost
 } from "@forklaunch/core/http";
-var post = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return innerPost(schemaValidator, path, contractDetails, ...handlers2);
+var post = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return innerPost(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/propfind.ts
 import {
   middleware as middleware12
 } from "@forklaunch/core/http";
-var propfind = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware12(schemaValidator, path, contractDetails, ...handlers2);
+var propfind = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware12(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/proppatch.ts
 import {
   middleware as middleware13
 } from "@forklaunch/core/http";
-var proppatch = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware13(schemaValidator, path, contractDetails, ...handlers2);
+var proppatch = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware13(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/purge.ts
 import {
   middleware as middleware14
 } from "@forklaunch/core/http";
-var purge = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware14(schemaValidator, path, contractDetails, ...handlers2);
+var purge = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware14(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/put.ts
 import {
   put as innerPut
 } from "@forklaunch/core/http";
-var put = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return innerPut(schemaValidator, path, contractDetails, ...handlers2);
+var put = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return innerPut(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/report.ts
 import {
   middleware as middleware15
 } from "@forklaunch/core/http";
-var report = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware15(schemaValidator, path, contractDetails, ...handlers2);
+var report = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware15(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/search.ts
 import {
   middleware as middleware16
 } from "@forklaunch/core/http";
-var search = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware16(schemaValidator, path, contractDetails, ...handlers2);
+var search = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware16(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/subscribe.ts
 import {
   middleware as middleware17
 } from "@forklaunch/core/http";
-var subscribe = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware17(schemaValidator, path, contractDetails, ...handlers2);
+var subscribe = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware17(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/trace.ts
 import {
   trace as innerTrace
 } from "@forklaunch/core/http";
-var trace = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return innerTrace(schemaValidator, path, contractDetails, ...handlers2);
+var trace = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return innerTrace(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/unlink.ts
 import {
   middleware as middleware18
 } from "@forklaunch/core/http";
-var unlink = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware18(schemaValidator, path, contractDetails, ...handlers2);
+var unlink = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware18(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/unlock.ts
 import {
   middleware as middleware19
 } from "@forklaunch/core/http";
-var unlock = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware19(schemaValidator, path, contractDetails, ...handlers2);
+var unlock = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware19(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // src/handlers/unsubscribe.ts
 import {
   middleware as middleware20
 } from "@forklaunch/core/http";
-var unsubscribe = (schemaValidator, path, contractDetails, ...handlers2) => {
-  return middleware20(schemaValidator, path, contractDetails, ...handlers2);
+var unsubscribe = (schemaValidator, path2, contractDetails, ...handlers2) => {
+  return middleware20(schemaValidator, path2, contractDetails, ...handlers2);
 };
 
 // index.ts
 function forklaunchExpress(schemaValidator, openTelemetryCollector, options2) {
-  return new Application(schemaValidator, openTelemetryCollector, options2);
+  return new Application(
+    schemaValidator,
+    openTelemetryCollector,
+    options2
+  );
 }
 function forklaunchRouter(basePath, schemaValidator, openTelemetryCollector, options2) {
   const router = new Router(