@c4a/server-cli 0.4.12-alpha.2 → 0.4.12-alpha.3

package/serve.js

@@ -98,7 +98,7 @@ var init_serverConfig = __esm(() => {
   DEFAULT_SERVER_CONFIG = {
     server: {
       port: 5100,
-      host: "0.0.0.0"
+      host: "::"
     },
     doc_db: {
       provider: "sqlite",
@@ -106,7 +106,7 @@ var init_serverConfig = __esm(() => {
         path: "./data/c4a.db"
       },
       mongodb: {
-        uri: "mongodb://localhost:27017/c4a",
+        uri: "mongodb://localhost:27017/c4a?directConnection=true",
         database: "c4a"
       }
     },
@@ -11668,6 +11668,32 @@ var init_utils = __esm(() => {
 // ../core/src/constants.ts
 var DEFAULT_USER_ID = "user_admin", DEFAULT_USER_NAME = "admin", DEFAULT_WORKSPACE_ID = "ws_default", DEFAULT_WORKSPACE_NAME = "默认大脑", DEFAULT_CLOUD_LIBRARY_ID = "lib_cloud_default", DEFAULT_CLOUD_LIBRARY_NAME = "个人云", DAEMON_OFFLINE_THRESHOLD = 60000;
 
+// ../core/src/fileTypes.ts
+function getFileExtension(name) {
+  const dot = name.lastIndexOf(".");
+  return dot >= 0 ? name.slice(dot).toLowerCase() : "";
+}
+var INDEXABLE_CODE_EXTENSIONS, INDEXABLE_DOC_EXTENSIONS, INDEXABLE_EXTENSIONS, UPLOAD_ALLOWED_EXTENSIONS, TEXT_EXTENSIONS, UPLOAD_MAX_FILE_SIZE, UPLOAD_MAX_FILES = 10;
+var init_fileTypes = __esm(() => {
+  INDEXABLE_CODE_EXTENSIONS = new Set([".ts", ".tsx"]);
+  INDEXABLE_DOC_EXTENSIONS = new Set([".md"]);
+  INDEXABLE_EXTENSIONS = new Set([
+    ...INDEXABLE_CODE_EXTENSIONS,
+    ...INDEXABLE_DOC_EXTENSIONS
+  ]);
+  UPLOAD_ALLOWED_EXTENSIONS = new Set([
+    ".md",
+    ".doc",
+    ".docx",
+    ".pdf",
+    ".ppt",
+    ".pptx",
+    ".txt"
+  ]);
+  TEXT_EXTENSIONS = new Set([".md", ".txt"]);
+  UPLOAD_MAX_FILE_SIZE = 5 * 1024 * 1024;
+});
+
 // ../core/src/wsEvents.ts
 var WS_DAEMON_CONNECTED = "ws:daemon:connected", WS_DAEMON_STATUS = "ws:daemon:status";
 
@@ -11677,6 +11703,7 @@ var init_src = __esm(() => {
   init_schemas();
   init_errors2();
   init_utils();
+  init_fileTypes();
 });
 
 // ../../node_modules/.bun/@mikro-orm+core@6.6.7/node_modules/@mikro-orm/core/enums.js
@@ -143247,532 +143274,2231 @@ var init_milvusVectorStore = __esm(() => {
   init_src();
 });
 
-// ../../node_modules/.bun/@hono+node-server@1.19.9+eb2864ea6bc646ec/node_modules/@hono/node-server/dist/index.mjs
-var exports_dist = {};
-__export(exports_dist, {
-  serve: () => serve,
-  getRequestListener: () => getRequestListener,
-  createAdaptorServer: () => createAdaptorServer,
-  RequestError: () => RequestError
-});
-import { createServer as createServerHTTP } from "http";
-import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
-import { Http2ServerRequest } from "http2";
-import { Readable } from "stream";
-import crypto2 from "crypto";
-async function readWithoutBlocking(readPromise) {
-  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(undefined))]);
-}
-function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
-  const cancel = (error40) => {
-    reader.cancel(error40).catch(() => {});
+// ../../node_modules/.bun/ms@2.1.3/node_modules/ms/index.js
+var require_ms2 = __commonJS((exports, module) => {
+  var s = 1000;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+  module.exports = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse5(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
   };
-  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(error40) {
-    if (error40) {
-      writable.destroy(error40);
+  function parse5(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match2 = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+    if (!match2) {
+      return;
+    }
+    var n = parseFloat(match2[1]);
+    var type = (match2[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return;
     }
   }
-  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 fmtShort(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return Math.round(ms / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms / h) + "h";
     }
+    if (msAbs >= m) {
+      return Math.round(ms / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms / s) + "s";
+    }
+    return ms + "ms";
   }
-}
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    return;
+  function fmtLong(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return plural(ms, msAbs, d, "day");
+    }
+    if (msAbs >= h) {
+      return plural(ms, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms, msAbs, s, "second");
+    }
+    return ms + " ms";
   }
-  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
-}
-var RequestError, toRequestError = (e) => {
-  if (e instanceof RequestError) {
-    return e;
+  function plural(ms, msAbs, n, name21) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms / n) + " " + name21 + (isPlural ? "s" : "");
   }
-  return new RequestError(e.message, { cause: e });
-}, GlobalRequest, Request2, 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]);
+});
+
+// ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/common.js
+var require_common7 = __commonJS((exports, module) => {
+  function setup(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce2;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = require_ms2();
+    createDebug.destroy = destroy;
+    Object.keys(env).forEach((key) => {
+      createDebug[key] = env[key];
+    });
+    createDebug.names = [];
+    createDebug.skips = [];
+    createDebug.formatters = {};
+    function selectColor(namespace) {
+      let hash2 = 0;
+      for (let i = 0;i < namespace.length; i++) {
+        hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i);
+        hash2 |= 0;
+      }
+      return createDebug.colors[Math.abs(hash2) % createDebug.colors.length];
     }
-  }
-  return new Headers(headerRecord);
-}, wrapBodyStream, newRequestFromIncoming = (method, url2, headers, incoming, abortController) => {
-  const init = {
-    method,
-    headers,
-    signal: abortController.signal
-  };
-  if (method === "TRACE") {
-    init.method = "GET";
-    const req = new Request2(url2, init);
-    Object.defineProperty(req, "method", {
-      get() {
-        return "TRACE";
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      let prevTime;
+      let enableOverride = null;
+      let namespacesCache;
+      let enabledCache;
+      function debug(...args) {
+        if (!debug.enabled) {
+          return;
+        }
+        const self2 = debug;
+        const curr = Number(new Date);
+        const ms = curr - (prevTime || curr);
+        self2.diff = ms;
+        self2.prev = prevTime;
+        self2.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug.coerce(args[0]);
+        if (typeof args[0] !== "string") {
+          args.unshift("%O");
+        }
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match2, format) => {
+          if (match2 === "%%") {
+            return "%";
+          }
+          index++;
+          const formatter = createDebug.formatters[format];
+          if (typeof formatter === "function") {
+            const val = args[index];
+            match2 = formatter.call(self2, val);
+            args.splice(index, 1);
+            index--;
+          }
+          return match2;
+        });
+        createDebug.formatArgs.call(self2, args);
+        const logFn = self2.log || createDebug.log;
+        logFn.apply(self2, args);
       }
-    });
-    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();
+      debug.namespace = namespace;
+      debug.useColors = createDebug.useColors();
+      debug.color = createDebug.selectColor(namespace);
+      debug.extend = extend2;
+      debug.destroy = createDebug.destroy;
+      Object.defineProperty(debug, "enabled", {
+        enumerable: true,
+        configurable: false,
+        get: () => {
+          if (enableOverride !== null) {
+            return enableOverride;
+          }
+          if (namespacesCache !== createDebug.namespaces) {
+            namespacesCache = createDebug.namespaces;
+            enabledCache = createDebug.enabled(namespace);
+          }
+          return enabledCache;
+        },
+        set: (v) => {
+          enableOverride = v;
         }
       });
-    } else if (incoming[wrapBodyStream]) {
-      let reader;
-      init.body = new ReadableStream({
-        async pull(controller) {
-          try {
-            reader ||= Readable.toWeb(incoming).getReader();
-            const { done, value } = await reader.read();
-            if (done) {
-              controller.close();
-            } else {
-              controller.enqueue(value);
-            }
-          } catch (error40) {
-            controller.error(error40);
+      if (typeof createDebug.init === "function") {
+        createDebug.init(debug);
+      }
+      return debug;
+    }
+    function extend2(namespace, delimiter) {
+      const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+      newDebug.log = this.log;
+      return newDebug;
+    }
+    function enable(namespaces) {
+      createDebug.save(namespaces);
+      createDebug.namespaces = namespaces;
+      createDebug.names = [];
+      createDebug.skips = [];
+      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+      for (const ns of split) {
+        if (ns[0] === "-") {
+          createDebug.skips.push(ns.slice(1));
+        } else {
+          createDebug.names.push(ns);
+        }
+      }
+    }
+    function matchesTemplate(search2, template) {
+      let searchIndex = 0;
+      let templateIndex = 0;
+      let starIndex = -1;
+      let matchIndex = 0;
+      while (searchIndex < search2.length) {
+        if (templateIndex < template.length && (template[templateIndex] === search2[searchIndex] || template[templateIndex] === "*")) {
+          if (template[templateIndex] === "*") {
+            starIndex = templateIndex;
+            matchIndex = searchIndex;
+            templateIndex++;
+          } else {
+            searchIndex++;
+            templateIndex++;
           }
+        } else if (starIndex !== -1) {
+          templateIndex = starIndex + 1;
+          matchIndex++;
+          searchIndex = matchIndex;
+        } else {
+          return false;
         }
-      });
-    } else {
-      init.body = Readable.toWeb(incoming);
+      }
+      while (templateIndex < template.length && template[templateIndex] === "*") {
+        templateIndex++;
+      }
+      return templateIndex === template.length;
     }
-  }
-  return new Request2(url2, init);
-}, getRequestCache, requestCache, incomingKey, urlKey, headersKey, abortControllerKey, getAbortController, requestPrototype, newRequest = (incoming, defaultHostname) => {
-  const req = Object.create(requestPrototype);
-  req[incomingKey] = incoming;
-  const incomingUrl = incoming.url || "";
-  if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
-    if (incoming instanceof Http2ServerRequest) {
-      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+    function disable() {
+      const namespaces = [
+        ...createDebug.names,
+        ...createDebug.skips.map((namespace) => "-" + namespace)
+      ].join(",");
+      createDebug.enable("");
+      return namespaces;
     }
-    try {
-      const url22 = new URL(incomingUrl);
-      req[urlKey] = url22.href;
-    } catch (e) {
-      throw new RequestError("Invalid absolute URL", { cause: e });
+    function enabled(name21) {
+      for (const skip of createDebug.skips) {
+        if (matchesTemplate(name21, skip)) {
+          return false;
+        }
+      }
+      for (const ns of createDebug.names) {
+        if (matchesTemplate(name21, ns)) {
+          return true;
+        }
+      }
+      return false;
     }
-    return req;
+    function coerce2(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
+    }
+    function destroy() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    createDebug.enable(createDebug.load());
+    return createDebug;
   }
-  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
-  if (!host) {
-    throw new RequestError("Missing host header");
+  module.exports = setup;
+});
+
+// ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/browser.js
+var require_browser2 = __commonJS((exports, module) => {
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.storage = localstorage();
+  exports.destroy = (() => {
+    let warned = false;
+    return () => {
+      if (!warned) {
+        warned = true;
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+    };
+  })();
+  exports.colors = [
+    "#0000CC",
+    "#0000FF",
+    "#0033CC",
+    "#0033FF",
+    "#0066CC",
+    "#0066FF",
+    "#0099CC",
+    "#0099FF",
+    "#00CC00",
+    "#00CC33",
+    "#00CC66",
+    "#00CC99",
+    "#00CCCC",
+    "#00CCFF",
+    "#3300CC",
+    "#3300FF",
+    "#3333CC",
+    "#3333FF",
+    "#3366CC",
+    "#3366FF",
+    "#3399CC",
+    "#3399FF",
+    "#33CC00",
+    "#33CC33",
+    "#33CC66",
+    "#33CC99",
+    "#33CCCC",
+    "#33CCFF",
+    "#6600CC",
+    "#6600FF",
+    "#6633CC",
+    "#6633FF",
+    "#66CC00",
+    "#66CC33",
+    "#9900CC",
+    "#9900FF",
+    "#9933CC",
+    "#9933FF",
+    "#99CC00",
+    "#99CC33",
+    "#CC0000",
+    "#CC0033",
+    "#CC0066",
+    "#CC0099",
+    "#CC00CC",
+    "#CC00FF",
+    "#CC3300",
+    "#CC3333",
+    "#CC3366",
+    "#CC3399",
+    "#CC33CC",
+    "#CC33FF",
+    "#CC6600",
+    "#CC6633",
+    "#CC9900",
+    "#CC9933",
+    "#CCCC00",
+    "#CCCC33",
+    "#FF0000",
+    "#FF0033",
+    "#FF0066",
+    "#FF0099",
+    "#FF00CC",
+    "#FF00FF",
+    "#FF3300",
+    "#FF3333",
+    "#FF3366",
+    "#FF3399",
+    "#FF33CC",
+    "#FF33FF",
+    "#FF6600",
+    "#FF6633",
+    "#FF9900",
+    "#FF9933",
+    "#FFCC00",
+    "#FFCC33"
+  ];
+  function useColors() {
+    if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+      return true;
+    }
+    if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+      return false;
+    }
+    let m;
+    return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
   }
-  let scheme;
-  if (incoming instanceof Http2ServerRequest) {
-    scheme = incoming.scheme;
-    if (!(scheme === "http" || scheme === "https")) {
-      throw new RequestError("Unsupported scheme");
+  function formatArgs(args) {
+    args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+    if (!this.useColors) {
+      return;
     }
-  } else {
-    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+    const c = "color: " + this.color;
+    args.splice(1, 0, c, "color: inherit");
+    let index = 0;
+    let lastC = 0;
+    args[0].replace(/%[a-zA-Z%]/g, (match2) => {
+      if (match2 === "%%") {
+        return;
+      }
+      index++;
+      if (match2 === "%c") {
+        lastC = index;
+      }
+    });
+    args.splice(lastC, 0, c);
   }
-  const url2 = new URL(`${scheme}://${host}${incomingUrl}`);
-  if (url2.hostname.length !== host.length && url2.hostname !== host.replace(/:\d+$/, "")) {
-    throw new RequestError("Invalid host header");
+  exports.log = console.debug || console.log || (() => {});
+  function save(namespaces) {
+    try {
+      if (namespaces) {
+        exports.storage.setItem("debug", namespaces);
+      } else {
+        exports.storage.removeItem("debug");
+      }
+    } catch (error40) {}
   }
-  req[urlKey] = url2.href;
-  return req;
-}, responseCache, getResponseCache, cacheKey, GlobalResponse, Response2, buildOutgoingHttpHeaders = (headers) => {
-  const res = {};
-  if (!(headers instanceof Headers)) {
-    headers = new Headers(headers ?? undefined);
+  function load() {
+    let r;
+    try {
+      r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+    } catch (error40) {}
+    if (!r && typeof process !== "undefined" && "env" in process) {
+      r = process.env.DEBUG;
+    }
+    return r;
   }
-  const cookies = [];
-  for (const [k, v] of headers) {
-    if (k === "set-cookie") {
-      cookies.push(v);
+  function localstorage() {
+    try {
+      return localStorage;
+    } catch (error40) {}
+  }
+  module.exports = require_common7()(exports);
+  var { formatters } = module.exports;
+  formatters.j = function(v) {
+    try {
+      return JSON.stringify(v);
+    } catch (error40) {
+      return "[UnexpectedJSONParseError]: " + error40.message;
+    }
+  };
+});
+
+// ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/node.js
+var require_node6 = __commonJS((exports, module) => {
+  var tty = __require("tty");
+  var util3 = __require("util");
+  exports.init = init;
+  exports.log = log;
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.destroy = util3.deprecate(() => {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+  exports.colors = [6, 2, 3, 4, 5, 1];
+  try {
+    const supportsColor = require_supports_color();
+    if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+      exports.colors = [
+        20,
+        21,
+        26,
+        27,
+        32,
+        33,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        56,
+        57,
+        62,
+        63,
+        68,
+        69,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        92,
+        93,
+        98,
+        99,
+        112,
+        113,
+        128,
+        129,
+        134,
+        135,
+        148,
+        149,
+        160,
+        161,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        171,
+        172,
+        173,
+        178,
+        179,
+        184,
+        185,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        203,
+        204,
+        205,
+        206,
+        207,
+        208,
+        209,
+        214,
+        215,
+        220,
+        221
+      ];
+    }
+  } catch (error40) {}
+  exports.inspectOpts = Object.keys(process.env).filter((key) => {
+    return /^debug_/i.test(key);
+  }).reduce((obj, key) => {
+    const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+      return k.toUpperCase();
+    });
+    let val = process.env[key];
+    if (/^(yes|on|true|enabled)$/i.test(val)) {
+      val = true;
+    } else if (/^(no|off|false|disabled)$/i.test(val)) {
+      val = false;
+    } else if (val === "null") {
+      val = null;
     } else {
-      res[k] = v;
+      val = Number(val);
     }
+    obj[prop] = val;
+    return obj;
+  }, {});
+  function useColors() {
+    return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
   }
-  if (cookies.length > 0) {
-    res["set-cookie"] = cookies;
+  function formatArgs(args) {
+    const { namespace: name21, useColors: useColors2 } = this;
+    if (useColors2) {
+      const c = this.color;
+      const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+      const prefix = `  ${colorCode};1m${name21} \x1B[0m`;
+      args[0] = prefix + args[0].split(`
+`).join(`
+` + prefix);
+      args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+    } else {
+      args[0] = getDate() + name21 + " " + args[0];
+    }
   }
-  res["content-type"] ??= "text/plain; charset=UTF-8";
-  return res;
-}, X_ALREADY_SENT = "x-hono-already-sent", outgoingEnded, handleRequestError = () => new Response(null, {
-  status: 400
-}), handleFetchError2 = (e) => new Response(null, {
-  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
-}), 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" });
+  function getDate() {
+    if (exports.inspectOpts.hideDate) {
+      return "";
     }
-    outgoing.end(`Error: ${err.message}`);
-    outgoing.destroy(err);
+    return new Date().toISOString() + " ";
   }
-}, flushHeaders = (outgoing) => {
-  if ("flushHeaders" in outgoing && outgoing.writable) {
-    outgoing.flushHeaders();
+  function log(...args) {
+    return process.stderr.write(util3.formatWithOptions(exports.inspectOpts, ...args) + `
+`);
   }
-}, responseViaCache = async (res, outgoing) => {
-  let [status, body, header] = res[cacheKey];
-  if (header instanceof Headers) {
-    header = buildOutgoingHttpHeaders(header);
+  function save(namespaces) {
+    if (namespaces) {
+      process.env.DEBUG = namespaces;
+    } else {
+      delete process.env.DEBUG;
+    }
   }
-  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;
+  function load() {
+    return process.env.DEBUG;
   }
-  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()));
+  function init(debug) {
+    debug.inspectOpts = {};
+    const keys = Object.keys(exports.inspectOpts);
+    for (let i = 0;i < keys.length; i++) {
+      debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+    }
+  }
+  module.exports = require_common7()(exports);
+  var { formatters } = module.exports;
+  formatters.o = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util3.inspect(v, this.inspectOpts).split(`
+`).map((str) => str.trim()).join(" ");
+  };
+  formatters.O = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util3.inspect(v, this.inspectOpts);
+  };
+});
+
+// ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/index.js
+var require_src3 = __commonJS((exports, module) => {
+  if (typeof process === "undefined" || process.type === "renderer" || false || process.__nwjs) {
+    module.exports = require_browser2();
   } else {
-    flushHeaders(outgoing);
-    await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
+    module.exports = require_node6();
   }
-  outgoing[outgoingEnded]?.();
-}, isPromise = (res) => typeof res.then === "function", responseViaResponseObject = async (res, outgoing, options = {}) => {
-  if (isPromise(res)) {
-    if (options.errorHandler) {
+});
+
+// ../../node_modules/.bun/follow-redirects@1.15.11/node_modules/follow-redirects/debug.js
+var require_debug = __commonJS((exports, module) => {
+  var debug;
+  module.exports = function() {
+    if (!debug) {
       try {
-        res = await res;
-      } catch (err) {
-        const errRes = await options.errorHandler(err);
-        if (!errRes) {
-          return;
-        }
-        res = errRes;
+        debug = require_src3()("follow-redirects");
+      } catch (error40) {}
+      if (typeof debug !== "function") {
+        debug = function() {};
       }
-    } else {
-      res = await res.catch(handleFetchError2);
     }
+    debug.apply(null, arguments);
+  };
+});
+
+// ../../node_modules/.bun/follow-redirects@1.15.11/node_modules/follow-redirects/index.js
+var require_follow_redirects = __commonJS((exports, module) => {
+  var url2 = __require("url");
+  var URL2 = url2.URL;
+  var http = __require("http");
+  var https = __require("https");
+  var Writable = __require("stream").Writable;
+  var assert2 = __require("assert");
+  var debug = require_debug();
+  (function detectUnsupportedEnvironment() {
+    var looksLikeNode = typeof process !== "undefined";
+    var looksLikeBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+    var looksLikeV8 = isFunction(Error.captureStackTrace);
+    if (!looksLikeNode && (looksLikeBrowser || !looksLikeV8)) {
+      console.warn("The follow-redirects package should be excluded from browser builds.");
+    }
+  })();
+  var useNativeURL = false;
+  try {
+    assert2(new URL2(""));
+  } catch (error40) {
+    useNativeURL = error40.code === "ERR_INVALID_URL";
+  }
+  var preservedUrlFields = [
+    "auth",
+    "host",
+    "hostname",
+    "href",
+    "path",
+    "pathname",
+    "port",
+    "protocol",
+    "query",
+    "search",
+    "hash"
+  ];
+  var events = ["abort", "aborted", "connect", "error", "socket", "timeout"];
+  var eventHandlers = Object.create(null);
+  events.forEach(function(event) {
+    eventHandlers[event] = function(arg1, arg2, arg3) {
+      this._redirectable.emit(event, arg1, arg2, arg3);
+    };
+  });
+  var InvalidUrlError = createErrorType("ERR_INVALID_URL", "Invalid URL", TypeError);
+  var RedirectionError = createErrorType("ERR_FR_REDIRECTION_FAILURE", "Redirected request failed");
+  var TooManyRedirectsError = createErrorType("ERR_FR_TOO_MANY_REDIRECTS", "Maximum number of redirects exceeded", RedirectionError);
+  var MaxBodyLengthExceededError = createErrorType("ERR_FR_MAX_BODY_LENGTH_EXCEEDED", "Request body larger than maxBodyLength limit");
+  var WriteAfterEndError = createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
+  var destroy = Writable.prototype.destroy || noop2;
+  function RedirectableRequest(options, responseCallback) {
+    Writable.call(this);
+    this._sanitizeOptions(options);
+    this._options = options;
+    this._ended = false;
+    this._ending = false;
+    this._redirectCount = 0;
+    this._redirects = [];
+    this._requestBodyLength = 0;
+    this._requestBodyBuffers = [];
+    if (responseCallback) {
+      this.on("response", responseCallback);
+    }
+    var self2 = this;
+    this._onNativeResponse = function(response) {
+      try {
+        self2._processResponse(response);
+      } catch (cause) {
+        self2.emit("error", cause instanceof RedirectionError ? cause : new RedirectionError({ cause }));
+      }
+    };
+    this._performRequest();
   }
-  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 = undefined;
-    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((resolve2) => setTimeout(resolve2));
-            maxReadCount = 3;
-            continue;
+  RedirectableRequest.prototype = Object.create(Writable.prototype);
+  RedirectableRequest.prototype.abort = function() {
+    destroyRequest(this._currentRequest);
+    this._currentRequest.abort();
+    this.emit("abort");
+  };
+  RedirectableRequest.prototype.destroy = function(error40) {
+    destroyRequest(this._currentRequest, error40);
+    destroy.call(this, error40);
+    return this;
+  };
+  RedirectableRequest.prototype.write = function(data, encoding, callback) {
+    if (this._ending) {
+      throw new WriteAfterEndError;
+    }
+    if (!isString(data) && !isBuffer(data)) {
+      throw new TypeError("data should be a string, Buffer or Uint8Array");
+    }
+    if (isFunction(encoding)) {
+      callback = encoding;
+      encoding = null;
+    }
+    if (data.length === 0) {
+      if (callback) {
+        callback();
+      }
+      return;
+    }
+    if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
+      this._requestBodyLength += data.length;
+      this._requestBodyBuffers.push({ data, encoding });
+      this._currentRequest.write(data, encoding, callback);
+    } else {
+      this.emit("error", new MaxBodyLengthExceededError);
+      this.abort();
+    }
+  };
+  RedirectableRequest.prototype.end = function(data, encoding, callback) {
+    if (isFunction(data)) {
+      callback = data;
+      data = encoding = null;
+    } else if (isFunction(encoding)) {
+      callback = encoding;
+      encoding = null;
+    }
+    if (!data) {
+      this._ended = this._ending = true;
+      this._currentRequest.end(null, null, callback);
+    } else {
+      var self2 = this;
+      var currentRequest = this._currentRequest;
+      this.write(data, encoding, function() {
+        self2._ended = true;
+        currentRequest.end(null, null, callback);
+      });
+      this._ending = true;
+    }
+  };
+  RedirectableRequest.prototype.setHeader = function(name21, value) {
+    this._options.headers[name21] = value;
+    this._currentRequest.setHeader(name21, value);
+  };
+  RedirectableRequest.prototype.removeHeader = function(name21) {
+    delete this._options.headers[name21];
+    this._currentRequest.removeHeader(name21);
+  };
+  RedirectableRequest.prototype.setTimeout = function(msecs, callback) {
+    var self2 = this;
+    function destroyOnTimeout(socket) {
+      socket.setTimeout(msecs);
+      socket.removeListener("timeout", socket.destroy);
+      socket.addListener("timeout", socket.destroy);
+    }
+    function startTimer(socket) {
+      if (self2._timeout) {
+        clearTimeout(self2._timeout);
+      }
+      self2._timeout = setTimeout(function() {
+        self2.emit("timeout");
+        clearTimer();
+      }, msecs);
+      destroyOnTimeout(socket);
+    }
+    function clearTimer() {
+      if (self2._timeout) {
+        clearTimeout(self2._timeout);
+        self2._timeout = null;
+      }
+      self2.removeListener("abort", clearTimer);
+      self2.removeListener("error", clearTimer);
+      self2.removeListener("response", clearTimer);
+      self2.removeListener("close", clearTimer);
+      if (callback) {
+        self2.removeListener("timeout", callback);
+      }
+      if (!self2.socket) {
+        self2._currentRequest.removeListener("socket", startTimer);
+      }
+    }
+    if (callback) {
+      this.on("timeout", callback);
+    }
+    if (this.socket) {
+      startTimer(this.socket);
+    } else {
+      this._currentRequest.once("socket", startTimer);
+    }
+    this.on("socket", destroyOnTimeout);
+    this.on("abort", clearTimer);
+    this.on("error", clearTimer);
+    this.on("response", clearTimer);
+    this.on("close", clearTimer);
+    return this;
+  };
+  [
+    "flushHeaders",
+    "getHeader",
+    "setNoDelay",
+    "setSocketKeepAlive"
+  ].forEach(function(method) {
+    RedirectableRequest.prototype[method] = function(a, b) {
+      return this._currentRequest[method](a, b);
+    };
+  });
+  ["aborted", "connection", "socket"].forEach(function(property) {
+    Object.defineProperty(RedirectableRequest.prototype, property, {
+      get: function() {
+        return this._currentRequest[property];
+      }
+    });
+  });
+  RedirectableRequest.prototype._sanitizeOptions = function(options) {
+    if (!options.headers) {
+      options.headers = {};
+    }
+    if (options.host) {
+      if (!options.hostname) {
+        options.hostname = options.host;
+      }
+      delete options.host;
+    }
+    if (!options.pathname && options.path) {
+      var searchPos = options.path.indexOf("?");
+      if (searchPos < 0) {
+        options.pathname = options.path;
+      } else {
+        options.pathname = options.path.substring(0, searchPos);
+        options.search = options.path.substring(searchPos);
+      }
+    }
+  };
+  RedirectableRequest.prototype._performRequest = function() {
+    var protocol = this._options.protocol;
+    var nativeProtocol = this._options.nativeProtocols[protocol];
+    if (!nativeProtocol) {
+      throw new TypeError("Unsupported protocol " + protocol);
+    }
+    if (this._options.agents) {
+      var scheme = protocol.slice(0, -1);
+      this._options.agent = this._options.agents[scheme];
+    }
+    var request = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
+    request._redirectable = this;
+    for (var event of events) {
+      request.on(event, eventHandlers[event]);
+    }
+    this._currentUrl = /^\//.test(this._options.path) ? url2.format(this._options) : this._options.path;
+    if (this._isRedirect) {
+      var i = 0;
+      var self2 = this;
+      var buffers = this._requestBodyBuffers;
+      (function writeNext(error40) {
+        if (request === self2._currentRequest) {
+          if (error40) {
+            self2.emit("error", error40);
+          } else if (i < buffers.length) {
+            var buffer = buffers[i++];
+            if (!request.finished) {
+              request.write(buffer.data, buffer.encoding, writeNext);
+            }
+          } else if (self2._ended) {
+            request.end();
           }
-          break;
         }
-        currentReadPromise = undefined;
-        if (chunk.value) {
-          values.push(chunk.value);
+      })();
+    }
+  };
+  RedirectableRequest.prototype._processResponse = function(response) {
+    var statusCode = response.statusCode;
+    if (this._options.trackRedirects) {
+      this._redirects.push({
+        url: this._currentUrl,
+        headers: response.headers,
+        statusCode
+      });
+    }
+    var location = response.headers.location;
+    if (!location || this._options.followRedirects === false || statusCode < 300 || statusCode >= 400) {
+      response.responseUrl = this._currentUrl;
+      response.redirects = this._redirects;
+      this.emit("response", response);
+      this._requestBodyBuffers = [];
+      return;
+    }
+    destroyRequest(this._currentRequest);
+    response.destroy();
+    if (++this._redirectCount > this._options.maxRedirects) {
+      throw new TooManyRedirectsError;
+    }
+    var requestHeaders;
+    var beforeRedirect = this._options.beforeRedirect;
+    if (beforeRedirect) {
+      requestHeaders = Object.assign({
+        Host: response.req.getHeader("host")
+      }, this._options.headers);
+    }
+    var method = this._options.method;
+    if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" || statusCode === 303 && !/^(?:GET|HEAD)$/.test(this._options.method)) {
+      this._options.method = "GET";
+      this._requestBodyBuffers = [];
+      removeMatchingHeaders(/^content-/i, this._options.headers);
+    }
+    var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
+    var currentUrlParts = parseUrl(this._currentUrl);
+    var currentHost = currentHostHeader || currentUrlParts.host;
+    var currentUrl = /^\w+:/.test(location) ? this._currentUrl : url2.format(Object.assign(currentUrlParts, { host: currentHost }));
+    var redirectUrl = resolveUrl(location, currentUrl);
+    debug("redirecting to", redirectUrl.href);
+    this._isRedirect = true;
+    spreadUrlObject(redirectUrl, this._options);
+    if (redirectUrl.protocol !== currentUrlParts.protocol && redirectUrl.protocol !== "https:" || redirectUrl.host !== currentHost && !isSubdomain(redirectUrl.host, currentHost)) {
+      removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
+    }
+    if (isFunction(beforeRedirect)) {
+      var responseDetails = {
+        headers: response.headers,
+        statusCode
+      };
+      var requestDetails = {
+        url: currentUrl,
+        method,
+        headers: requestHeaders
+      };
+      beforeRedirect(this._options, responseDetails, requestDetails);
+      this._sanitizeOptions(this._options);
+    }
+    this._performRequest();
+  };
+  function wrap4(protocols) {
+    var exports2 = {
+      maxRedirects: 21,
+      maxBodyLength: 10 * 1024 * 1024
+    };
+    var nativeProtocols = {};
+    Object.keys(protocols).forEach(function(scheme) {
+      var protocol = scheme + ":";
+      var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
+      var wrappedProtocol = exports2[scheme] = Object.create(nativeProtocol);
+      function request(input, options, callback) {
+        if (isURL(input)) {
+          input = spreadUrlObject(input);
+        } else if (isString(input)) {
+          input = spreadUrlObject(parseUrl(input));
+        } else {
+          callback = options;
+          options = validateUrl(input);
+          input = { protocol };
         }
-        if (chunk.done) {
-          done = true;
-          break;
+        if (isFunction(options)) {
+          callback = options;
+          options = null;
+        }
+        options = Object.assign({
+          maxRedirects: exports2.maxRedirects,
+          maxBodyLength: exports2.maxBodyLength
+        }, input, options);
+        options.nativeProtocols = nativeProtocols;
+        if (!isString(options.host) && !isString(options.hostname)) {
+          options.hostname = "::1";
         }
+        assert2.equal(options.protocol, protocol, "protocol mismatch");
+        debug("options", options);
+        return new RedirectableRequest(options, callback);
       }
-      if (done && !("content-length" in resHeaderRecord)) {
-        resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+      function get(input, options, callback) {
+        var wrappedRequest = wrappedProtocol.request(input, options, callback);
+        wrappedRequest.end();
+        return wrappedRequest;
       }
-    }
-    outgoing.writeHead(res.status, resHeaderRecord);
-    values.forEach((value) => {
-      outgoing.write(value);
+      Object.defineProperties(wrappedProtocol, {
+        request: { value: request, configurable: true, enumerable: true, writable: true },
+        get: { value: get, configurable: true, enumerable: true, writable: true }
+      });
     });
-    if (done) {
-      outgoing.end();
+    return exports2;
+  }
+  function noop2() {}
+  function parseUrl(input) {
+    var parsed;
+    if (useNativeURL) {
+      parsed = new URL2(input);
     } else {
-      if (values.length === 0) {
-        flushHeaders(outgoing);
+      parsed = validateUrl(url2.parse(input));
+      if (!isString(parsed.protocol)) {
+        throw new InvalidUrlError({ input });
       }
-      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
     }
-  } else if (resHeaderRecord[X_ALREADY_SENT]) {} else {
-    outgoing.writeHead(res.status, resHeaderRecord);
-    outgoing.end();
+    return parsed;
   }
-  outgoing[outgoingEnded]?.();
-}, getRequestListener = (fetchCallback, options = {}) => {
-  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
-  if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
-    Object.defineProperty(global, "Request", {
-      value: Request2
-    });
-    Object.defineProperty(global, "Response", {
-      value: Response2
+  function resolveUrl(relative, base2) {
+    return useNativeURL ? new URL2(relative, base2) : parseUrl(url2.resolve(base2, relative));
+  }
+  function validateUrl(input) {
+    if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
+      throw new InvalidUrlError({ input: input.href || input });
+    }
+    if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
+      throw new InvalidUrlError({ input: input.href || input });
+    }
+    return input;
+  }
+  function spreadUrlObject(urlObject, target) {
+    var spread = target || {};
+    for (var key of preservedUrlFields) {
+      spread[key] = urlObject[key];
+    }
+    if (spread.hostname.startsWith("[")) {
+      spread.hostname = spread.hostname.slice(1, -1);
+    }
+    if (spread.port !== "") {
+      spread.port = Number(spread.port);
+    }
+    spread.path = spread.search ? spread.pathname + spread.search : spread.pathname;
+    return spread;
+  }
+  function removeMatchingHeaders(regex, headers) {
+    var lastValue;
+    for (var header in headers) {
+      if (regex.test(header)) {
+        lastValue = headers[header];
+        delete headers[header];
+      }
+    }
+    return lastValue === null || typeof lastValue === "undefined" ? undefined : String(lastValue).trim();
+  }
+  function createErrorType(code, message, baseClass) {
+    function CustomError(properties) {
+      if (isFunction(Error.captureStackTrace)) {
+        Error.captureStackTrace(this, this.constructor);
+      }
+      Object.assign(this, properties || {});
+      this.code = code;
+      this.message = this.cause ? message + ": " + this.cause.message : message;
+    }
+    CustomError.prototype = new (baseClass || Error);
+    Object.defineProperties(CustomError.prototype, {
+      constructor: {
+        value: CustomError,
+        enumerable: false
+      },
+      name: {
+        value: "Error [" + code + "]",
+        enumerable: false
+      }
     });
+    return CustomError;
   }
-  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 Http2ServerRequest2) {
-          outgoing[outgoingEnded] = () => {
-            if (!incomingEnded) {
-              setTimeout(() => {
-                if (!incomingEnded) {
-                  setTimeout(() => {
-                    incoming.destroy();
-                    outgoing.destroy();
-                  });
-                }
-              });
-            }
-          };
-        }
+  function destroyRequest(request, error40) {
+    for (var event of events) {
+      request.removeListener(event, eventHandlers[event]);
+    }
+    request.on("error", noop2);
+    request.destroy(error40);
+  }
+  function isSubdomain(subdomain, domain2) {
+    assert2(isString(subdomain) && isString(domain2));
+    var dot = subdomain.length - domain2.length - 1;
+    return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain2);
+  }
+  function isString(value) {
+    return typeof value === "string" || value instanceof String;
+  }
+  function isFunction(value) {
+    return typeof value === "function";
+  }
+  function isBuffer(value) {
+    return typeof value === "object" && "length" in value;
+  }
+  function isURL(value) {
+    return URL2 && value instanceof URL2;
+  }
+  module.exports = wrap4({ http, https });
+  module.exports.wrap = wrap4;
+});
+
+// ../../node_modules/.bun/http-proxy-3@1.23.2/node_modules/http-proxy-3/dist/lib/http-proxy/common.js
+var require_common8 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isSSL = undefined;
+  exports.setupOutgoing = setupOutgoing;
+  exports.setupSocket = setupSocket;
+  exports.getPort = getPort;
+  exports.hasEncryptedConnection = hasEncryptedConnection;
+  exports.urlJoin = urlJoin;
+  exports.rewriteCookieProperty = rewriteCookieProperty;
+  exports.toURL = toURL;
+  var node_tls_1 = __require("node:tls");
+  var upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
+  exports.isSSL = /^https|wss/;
+  var HEADER_BLACKLIST = "trailer";
+  var HTTP2_HEADER_BLACKLIST = [
+    ":method",
+    ":path",
+    ":scheme",
+    ":authority",
+    "connection",
+    "keep-alive"
+  ];
+  function setupOutgoing(outgoing, options, req, forward) {
+    const target = options[forward || "target"];
+    outgoing.port = +(target.port ?? (target.protocol !== undefined && exports.isSSL.test(target.protocol) ? 443 : 80));
+    for (const e of [
+      "host",
+      "hostname",
+      "socketPath",
+      "pfx",
+      "key",
+      "passphrase",
+      "cert",
+      "ca",
+      "ciphers",
+      "secureProtocol"
+    ]) {
+      outgoing[e] = target[e];
+    }
+    outgoing.method = options.method || req.method;
+    outgoing.headers = { ...req.headers };
+    if (req.headers?.[":authority"]) {
+      outgoing.headers.host = req.headers[":authority"];
+    }
+    if (options.headers) {
+      outgoing.headers = { ...outgoing.headers, ...options.headers };
+    }
+    for (const header in outgoing.headers) {
+      if (HEADER_BLACKLIST == header.toLowerCase()) {
+        delete outgoing.headers[header];
+        break;
       }
-      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 (req.httpVersionMajor > 1) {
+      for (const header of HTTP2_HEADER_BLACKLIST) {
+        delete outgoing.headers[header];
+      }
+    }
+    if (options.auth) {
+      delete outgoing.headers.authorization;
+      outgoing.auth = options.auth;
+    }
+    if (options.ca) {
+      outgoing.ca = options.ca;
+    }
+    if (target.protocol !== undefined && exports.isSSL.test(target.protocol)) {
+      outgoing.rejectUnauthorized = typeof options.secure === "undefined" ? true : options.secure;
+    }
+    outgoing.agent = options.agent || false;
+    outgoing.localAddress = options.localAddress;
+    if (!outgoing.agent) {
+      outgoing.headers = outgoing.headers || {};
+      if (typeof outgoing.headers.connection !== "string" || !upgradeHeader.test(outgoing.headers.connection)) {
+        outgoing.headers.connection = "close";
+      }
+    }
+    const targetPath = target && options.prependPath !== false && "pathname" in target ? getPath2(`${target.pathname}${target.search ?? ""}`) : "/";
+    let outgoingPath = options.toProxy ? req.url : getPath2(req.url);
+    outgoingPath = !options.ignorePath ? outgoingPath : "";
+    outgoing.path = urlJoin(targetPath, outgoingPath ?? "");
+    if (options.changeOrigin) {
+      outgoing.headers.host = target.protocol !== undefined && required2(outgoing.port, target.protocol) && !hasPort(outgoing.host) ? outgoing.host + ":" + outgoing.port : outgoing.host;
+    }
+    outgoing.url = "href" in target && target.href || (target.protocol === "https" ? "https" : "http") + "://" + outgoing.host + (outgoing.port ? ":" + outgoing.port : "");
+    if (req.httpVersionMajor > 1) {
+      for (const header of HTTP2_HEADER_BLACKLIST) {
+        delete outgoing.headers[header];
+      }
+    }
+    return outgoing;
+  }
+  function setupSocket(socket) {
+    socket.setTimeout(0);
+    socket.setNoDelay(true);
+    socket.setKeepAlive(true, 0);
+    return socket;
+  }
+  function getPort(req) {
+    const hostHeader = req.headers[":authority"] || req.headers.host;
+    const res = hostHeader ? hostHeader.match(/:(\d+)/) : "";
+    return res ? res[1] : hasEncryptedConnection(req) ? "443" : "80";
+  }
+  function hasEncryptedConnection(req) {
+    const conn = req.connection;
+    return conn instanceof node_tls_1.TLSSocket && conn.encrypted || Boolean(conn.pair);
+  }
+  function urlJoin(...args) {
+    const queryParams = [];
+    let queryParamRaw = "";
+    args.forEach((url2, index) => {
+      const qpStart = url2.indexOf("?");
+      if (qpStart !== -1) {
+        queryParams.push(url2.substring(qpStart + 1));
+        args[index] = url2.substring(0, qpStart);
+      }
+    });
+    queryParamRaw = queryParams.filter(Boolean).join("&");
+    let retSegs = "";
+    for (const seg of args) {
+      if (!seg) {
+        continue;
+      }
+      if (retSegs.endsWith("/")) {
+        if (seg.startsWith("/")) {
+          retSegs += seg.slice(1);
+        } else {
+          retSegs += seg;
         }
-        if (!incomingEnded) {
-          setTimeout(() => {
-            if (!incomingEnded) {
-              setTimeout(() => {
-                incoming.destroy();
-              });
-            }
-          });
+      } else {
+        if (seg.startsWith("/")) {
+          retSegs += seg;
+        } else {
+          retSegs += "/" + seg;
         }
+      }
+    }
+    return queryParamRaw ? retSegs + "?" + queryParamRaw : retSegs;
+  }
+  function rewriteCookieProperty(header, config2, property) {
+    if (Array.isArray(header)) {
+      return header.map((headerElement) => {
+        return rewriteCookieProperty(headerElement, config2, property);
       });
-      res = fetchCallback(req, { incoming, outgoing });
-      if (cacheKey in res) {
-        return responseViaCache(res, outgoing);
+    }
+    return header.replace(new RegExp("(;\\s*" + property + "=)([^;]+)", "i"), (match2, prefix, previousValue) => {
+      let newValue;
+      if (previousValue in config2) {
+        newValue = config2[previousValue];
+      } else if ("*" in config2) {
+        newValue = config2["*"];
+      } else {
+        return match2;
       }
-    } 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 = handleFetchError2(e);
-        }
+      if (newValue) {
+        return prefix + newValue;
       } else {
-        return handleResponseError(e, outgoing);
+        return "";
       }
+    });
+  }
+  function hasPort(host) {
+    return !!~host.indexOf(":");
+  }
+  function getPath2(url2) {
+    if (url2 === "" || url2?.startsWith("?")) {
+      return url2;
     }
-    try {
-      return await responseViaResponseObject(res, outgoing, options);
-    } catch (e) {
-      return handleResponseError(e, outgoing);
+    const u = toURL(url2);
+    return `${u.pathname ?? ""}${u.search ?? ""}`;
+  }
+  function toURL(url2) {
+    if (url2 instanceof URL) {
+      return url2;
+    } else if (typeof url2 === "object" && "href" in url2 && typeof url2.href === "string") {
+      url2 = url2.href;
     }
-  };
-}, createAdaptorServer = (options) => {
-  const fetchCallback = options.fetch;
-  const requestListener = getRequestListener(fetchCallback, {
-    hostname: options.hostname,
-    overrideGlobalObjects: options.overrideGlobalObjects,
-    autoCleanupIncoming: options.autoCleanupIncoming
+    if (!url2) {
+      url2 = "";
+    }
+    if (typeof url2 != "string") {
+      url2 = `${url2}`;
+    }
+    if (url2.startsWith("//")) {
+      url2 = `http://base.invalid${url2}`;
+    }
+    return new URL(url2, "http://base.invalid");
+  }
+  function required2(port, protocol) {
+    protocol = protocol.split(":")[0];
+    port = +port;
+    if (!port)
+      return false;
+    switch (protocol) {
+      case "http":
+      case "ws":
+        return port !== 80;
+      case "https":
+      case "wss":
+        return port !== 443;
+    }
+    return port !== 0;
+  }
+});
+
+// ../../node_modules/.bun/http-proxy-3@1.23.2/node_modules/http-proxy-3/dist/lib/http-proxy/passes/web-outgoing.js
+var require_web_outgoing = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
   });
-  const createServer = options.createServer || createServerHTTP;
-  const server = createServer(options.serverOptions || {}, requestListener);
-  return server;
-}, serve = (options, listeningListener) => {
-  const server = createAdaptorServer(options);
-  server.listen(options?.port ?? 3000, options.hostname, () => {
-    const serverInfo = server.address();
-    listeningListener && listeningListener(serverInfo);
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
   });
-  return server;
-};
-var init_dist2 = __esm(() => {
-  RequestError = class extends Error {
-    constructor(message, options) {
-      super(message, options);
-      this.name = "RequestError";
+  var __importStar = exports && exports.__importStar || function() {
+    var ownKeys = function(o) {
+      ownKeys = Object.getOwnPropertyNames || function(o2) {
+        var ar = [];
+        for (var k in o2)
+          if (Object.prototype.hasOwnProperty.call(o2, k))
+            ar[ar.length] = k;
+        return ar;
+      };
+      return ownKeys(o);
+    };
+    return function(mod4) {
+      if (mod4 && mod4.__esModule)
+        return mod4;
+      var result = {};
+      if (mod4 != null) {
+        for (var k = ownKeys(mod4), i = 0;i < k.length; i++)
+          if (k[i] !== "default")
+            __createBinding(result, mod4, k[i]);
+      }
+      __setModuleDefault(result, mod4);
+      return result;
+    };
+  }();
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OUTGOING_PASSES = undefined;
+  exports.removeChunked = removeChunked;
+  exports.setConnection = setConnection;
+  exports.setRedirectHostRewrite = setRedirectHostRewrite;
+  exports.writeHeaders = writeHeaders;
+  exports.writeStatusCode = writeStatusCode;
+  var common = __importStar(require_common8());
+  var redirectRegex = /^201|30(1|2|7|8)$/;
+  function removeChunked(_req, _res, proxyRes) {
+    delete proxyRes.headers["transfer-encoding"];
+  }
+  function setConnection(req, _res, proxyRes) {
+    if (req.httpVersion === "1.0") {
+      proxyRes.headers["connection"] = req.headers["connection"] || "close";
+    } else if (req.httpVersion !== "2.0" && !proxyRes.headers["connection"]) {
+      proxyRes.headers["connection"] = req.headers["connection"] || "keep-alive";
+    }
+  }
+  function setRedirectHostRewrite(req, _res, proxyRes, options) {
+    if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers["location"] && redirectRegex.test(`${proxyRes.statusCode}`)) {
+      const target = common.toURL(options.target);
+      const location = proxyRes.headers["location"];
+      if (typeof location != "string") {
+        return;
+      }
+      const u = common.toURL(location);
+      if (target.host != u.host) {
+        return;
+      }
+      if (options.hostRewrite) {
+        u.host = options.hostRewrite;
+      } else if (options.autoRewrite) {
+        u.host = req.headers[":authority"] ?? req.headers["host"] ?? "";
+      }
+      if (options.protocolRewrite) {
+        u.protocol = options.protocolRewrite;
+      }
+      proxyRes.headers["location"] = u.toString();
     }
-  };
-  GlobalRequest = global.Request;
-  Request2 = class extends GlobalRequest {
-    constructor(input, options) {
-      if (typeof input === "object" && getRequestCache in input) {
-        input = input[getRequestCache]();
+  }
+  function writeHeaders(_req, res, proxyRes, options) {
+    const rewriteCookieDomainConfig = typeof options.cookieDomainRewrite === "string" ? { "*": options.cookieDomainRewrite } : options.cookieDomainRewrite;
+    const rewriteCookiePathConfig = typeof options.cookiePathRewrite === "string" ? { "*": options.cookiePathRewrite } : options.cookiePathRewrite;
+    const preserveHeaderKeyCase = options.preserveHeaderKeyCase;
+    const setHeader = (key, header) => {
+      if (header == undefined) {
+        return;
+      }
+      if (rewriteCookieDomainConfig && key.toLowerCase() === "set-cookie") {
+        header = common.rewriteCookieProperty(header, rewriteCookieDomainConfig, "domain");
       }
-      if (typeof options?.body?.getReader !== "undefined") {
-        options.duplex ??= "half";
+      if (rewriteCookiePathConfig && key.toLowerCase() === "set-cookie") {
+        header = common.rewriteCookieProperty(header, rewriteCookiePathConfig, "path");
+      }
+      res.setHeader(String(key).trim(), header);
+    };
+    let rawHeaderKeyMap;
+    if (preserveHeaderKeyCase && proxyRes.rawHeaders != null) {
+      rawHeaderKeyMap = {};
+      for (let i = 0;i < proxyRes.rawHeaders.length; i += 2) {
+        const key = proxyRes.rawHeaders[i];
+        rawHeaderKeyMap[key.toLowerCase()] = key;
       }
-      super(input, options);
     }
-  };
-  wrapBodyStream = Symbol("wrapBodyStream");
-  getRequestCache = Symbol("getRequestCache");
-  requestCache = Symbol("requestCache");
-  incomingKey = Symbol("incomingKey");
-  urlKey = Symbol("urlKey");
-  headersKey = Symbol("headersKey");
-  abortControllerKey = Symbol("abortControllerKey");
-  getAbortController = Symbol("getAbortController");
-  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]);
+    for (const key0 in proxyRes.headers) {
+      let key = key0;
+      if (_req.httpVersionMajor > 1 && (key === "connection" || key === "keep-alive")) {
+        continue;
+      }
+      const header = proxyRes.headers[key];
+      if (preserveHeaderKeyCase && rawHeaderKeyMap) {
+        key = rawHeaderKeyMap[key] ?? key;
+      }
+      setHeader(key, header);
     }
+  }
+  function writeStatusCode(_req, res, proxyRes) {
+    res.statusCode = proxyRes.statusCode;
+    if (proxyRes.statusMessage && _req.httpVersionMajor === 1) {
+      res.statusMessage = proxyRes.statusMessage;
+    }
+  }
+  exports.OUTGOING_PASSES = {
+    removeChunked,
+    setConnection,
+    setRedirectHostRewrite,
+    writeHeaders,
+    writeStatusCode
   };
-  [
-    "body",
-    "bodyUsed",
-    "cache",
-    "credentials",
-    "destination",
-    "integrity",
-    "mode",
-    "redirect",
-    "referrer",
-    "referrerPolicy",
-    "signal",
-    "keepalive"
-  ].forEach((k) => {
-    Object.defineProperty(requestPrototype, k, {
-      get() {
-        return this[getRequestCache]()[k];
-      }
-    });
+});
+
+// ../../node_modules/.bun/http-proxy-3@1.23.2/node_modules/http-proxy-3/dist/lib/http-proxy/passes/web-incoming.js
+var require_web_incoming = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
   });
-  ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-    Object.defineProperty(requestPrototype, k, {
-      value: function() {
-        return this[getRequestCache]()[k]();
-      }
-    });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
   });
-  Object.setPrototypeOf(requestPrototype, Request2.prototype);
-  responseCache = Symbol("responseCache");
-  getResponseCache = Symbol("getResponseCache");
-  cacheKey = Symbol("cache");
-  GlobalResponse = global.Response;
-  Response2 = class _Response {
-    #body;
-    #init;
-    [getResponseCache]() {
-      delete this[cacheKey];
-      return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  var __importStar = exports && exports.__importStar || function() {
+    var ownKeys = function(o) {
+      ownKeys = Object.getOwnPropertyNames || function(o2) {
+        var ar = [];
+        for (var k in o2)
+          if (Object.prototype.hasOwnProperty.call(o2, k))
+            ar[ar.length] = k;
+        return ar;
+      };
+      return ownKeys(o);
+    };
+    return function(mod4) {
+      if (mod4 && mod4.__esModule)
+        return mod4;
+      var result = {};
+      if (mod4 != null) {
+        for (var k = ownKeys(mod4), i = 0;i < k.length; i++)
+          if (k[i] !== "default")
+            __createBinding(result, mod4, k[i]);
+      }
+      __setModuleDefault(result, mod4);
+      return result;
+    };
+  }();
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.WEB_PASSES = undefined;
+  exports.deleteLength = deleteLength;
+  exports.timeout = timeout;
+  exports.XHeaders = XHeaders;
+  exports.stream = stream;
+  var http = __importStar(__require("node:http"));
+  var https = __importStar(__require("node:https"));
+  var followRedirects = __importStar(require_follow_redirects());
+  var common = __importStar(require_common8());
+  var web_outgoing_1 = require_web_outgoing();
+  var node_stream_1 = __require("node:stream");
+  var web_o = Object.values(web_outgoing_1.OUTGOING_PASSES);
+  var nativeAgents = { http, https };
+  function deleteLength(req) {
+    if ((req.method === "DELETE" || req.method === "OPTIONS") && !req.headers["content-length"]) {
+      req.headers["content-length"] = "0";
+      delete req.headers["transfer-encoding"];
+    }
+  }
+  function timeout(req, _res, options) {
+    if (options.timeout) {
+      req.socket.setTimeout(options.timeout);
+    }
+  }
+  function XHeaders(req, _res, options) {
+    if (!options.xfwd) {
+      return;
     }
-    constructor(body, init) {
-      let headers;
-      this.#body = body;
-      if (init instanceof _Response) {
-        const cachedGlobalResponse = init[responseCache];
-        if (cachedGlobalResponse) {
-          this.#init = cachedGlobalResponse;
-          this[getResponseCache]();
+    const encrypted = common.hasEncryptedConnection(req);
+    const values = {
+      for: req.connection.remoteAddress || req.socket.remoteAddress,
+      port: common.getPort(req),
+      proto: encrypted ? "https" : "http"
+    };
+    for (const header of ["for", "port", "proto"]) {
+      req.headers["x-forwarded-" + header] = (req.headers["x-forwarded-" + header] || "") + (req.headers["x-forwarded-" + header] ? "," : "") + values[header];
+    }
+    req.headers["x-forwarded-host"] = req.headers["x-forwarded-host"] || req.headers[":authority"] || req.headers["host"] || "";
+  }
+  function stream(req, res, options, _, server, cb) {
+    server.emit("start", req, res, options.target || options.forward);
+    if (options.fetch || options.fetchOptions || process.env.FORCE_FETCH_PATH === "true") {
+      return stream2(req, res, options, _, server, cb);
+    }
+    const agents = options.followRedirects ? followRedirects : nativeAgents;
+    const http2 = agents.http;
+    const https2 = agents.https;
+    if (options.forward) {
+      const proto2 = options.forward.protocol === "https:" ? https2 : http2;
+      const outgoingOptions2 = common.setupOutgoing(options.ssl || {}, options, req, "forward");
+      const forwardReq = proto2.request(outgoingOptions2);
+      const forwardError = createErrorHandler(forwardReq, options.forward);
+      req.on("error", forwardError);
+      forwardReq.on("error", forwardError);
+      (options.buffer || req).pipe(forwardReq);
+      if (!options.target) {
+        return res.end();
+      }
+    }
+    const proto = options.target.protocol === "https:" ? https2 : http2;
+    const outgoingOptions = common.setupOutgoing(options.ssl || {}, options, req);
+    const proxyReq = proto.request(outgoingOptions);
+    proxyReq.on("socket", (socket) => {
+      if (server && !proxyReq.getHeader("expect")) {
+        server.emit("proxyReq", proxyReq, req, res, options, socket);
+      }
+    });
+    if (options.proxyTimeout) {
+      proxyReq.setTimeout(options.proxyTimeout, () => {
+        proxyReq.destroy();
+      });
+    }
+    res.on("close", () => {
+      const aborted2 = !res.writableFinished;
+      if (aborted2) {
+        proxyReq.destroy();
+      }
+    });
+    const proxyError = createErrorHandler(proxyReq, options.target);
+    req.on("error", proxyError);
+    proxyReq.on("error", proxyError);
+    function createErrorHandler(proxyReq2, url2) {
+      return (err) => {
+        if (req.socket.destroyed && err.code === "ECONNRESET") {
+          server.emit("econnreset", err, req, res, url2);
+          proxyReq2.destroy();
           return;
+        }
+        if (cb) {
+          cb(err, req, res, url2);
         } else {
-          this.#init = init.#init;
-          headers = new Headers(init.#init.headers);
+          server.emit("error", err, req, res, url2);
+        }
+      };
+    }
+    (options.buffer || req).pipe(proxyReq);
+    proxyReq.on("response", (proxyRes) => {
+      server?.emit("proxyRes", proxyRes, req, res);
+      if (!res.headersSent && !options.selfHandleResponse) {
+        for (const pass of web_o) {
+          pass(req, res, proxyRes, options);
+        }
+      }
+      if (!res.finished) {
+        proxyRes.on("end", () => {
+          server?.emit("end", req, res, proxyRes);
+        });
+        if (!options.selfHandleResponse) {
+          proxyRes.pipe(res);
         }
       } else {
-        this.#init = init;
+        server?.emit("end", req, res, proxyRes);
       }
-      if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
-        headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
-        this[cacheKey] = [init?.status || 200, body, headers];
+    });
+  }
+  async function stream2(req, res, options, _, server, cb) {
+    const handleError2 = (err, target) => {
+      const e = err;
+      if (e.code === undefined && e.cause?.code) {
+        e.code = e.cause.code;
       }
-    }
-    get headers() {
-      const cache = this[cacheKey];
-      if (cache) {
-        if (!(cache[2] instanceof Headers)) {
-          cache[2] = new Headers(cache[2]);
+      if (cb) {
+        cb(err, req, res, target);
+      } else {
+        server.emit("error", err, req, res, target);
+      }
+    };
+    req.on("error", (err) => {
+      if (req.socket.destroyed && err.code === "ECONNRESET") {
+        const target = options.target || options.forward;
+        if (target) {
+          server.emit("econnreset", err, req, res, target);
         }
-        return cache[2];
+        return;
+      }
+      handleError2(err);
+    });
+    const customFetch = options.fetch || fetch;
+    const fetchOptions = options.fetchOptions ?? {};
+    const prepareRequest = (outgoing) => {
+      const requestOptions2 = {
+        method: outgoing.method,
+        ...fetchOptions.requestOptions
+      };
+      const headers = new Headers(fetchOptions.requestOptions?.headers);
+      if (!fetchOptions.requestOptions?.headers && outgoing.headers) {
+        for (const [key, value] of Object.entries(outgoing.headers)) {
+          if (typeof key === "string") {
+            if (Array.isArray(value)) {
+              for (const v of value) {
+                headers.append(key, v);
+              }
+            } else if (value != null) {
+              headers.append(key, value);
+            }
+          }
+        }
+      }
+      if (options.auth) {
+        headers.set("authorization", `Basic ${Buffer.from(options.auth).toString("base64")}`);
+      }
+      if (options.proxyTimeout) {
+        requestOptions2.signal = AbortSignal.timeout(options.proxyTimeout);
+      }
+      requestOptions2.headers = headers;
+      if (options.buffer) {
+        requestOptions2.body = options.buffer;
+      } else if (req.method !== "GET" && req.method !== "HEAD") {
+        requestOptions2.body = req;
+        requestOptions2.duplex = "half";
+      }
+      return requestOptions2;
+    };
+    if (options.forward) {
+      const outgoingOptions2 = common.setupOutgoing(options.ssl || {}, options, req, "forward");
+      const requestOptions2 = prepareRequest(outgoingOptions2);
+      let targetUrl2 = new URL(outgoingOptions2.url).origin + outgoingOptions2.path;
+      if (targetUrl2.startsWith("ws")) {
+        targetUrl2 = targetUrl2.replace("ws", "http");
+      }
+      if (fetchOptions.onBeforeRequest) {
+        try {
+          await fetchOptions.onBeforeRequest(requestOptions2, req, res, options);
+        } catch (err) {
+          handleError2(err, options.forward);
+          return;
+        }
+      }
+      try {
+        const result = await customFetch(targetUrl2, requestOptions2);
+        if (fetchOptions.onAfterResponse) {
+          try {
+            await fetchOptions.onAfterResponse(result, req, res, options);
+          } catch (err) {
+            handleError2(err, options.forward);
+            return;
+          }
+        }
+      } catch (err) {
+        handleError2(err, options.forward);
+      }
+      if (!options.target) {
+        return res.end();
       }
-      return this[getResponseCache]().headers;
     }
-    get status() {
-      return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+    const outgoingOptions = common.setupOutgoing(options.ssl || {}, options, req);
+    const requestOptions = prepareRequest(outgoingOptions);
+    let targetUrl = new URL(outgoingOptions.url).origin + outgoingOptions.path;
+    if (targetUrl.startsWith("ws")) {
+      targetUrl = targetUrl.replace("ws", "http");
     }
-    get ok() {
-      const status = this.status;
-      return status >= 200 && status < 300;
+    if (fetchOptions.onBeforeRequest) {
+      try {
+        await fetchOptions.onBeforeRequest(requestOptions, req, res, options);
+      } catch (err) {
+        handleError2(err, options.target);
+        return;
+      }
+    }
+    try {
+      const response = await customFetch(targetUrl, requestOptions);
+      if (fetchOptions.onAfterResponse) {
+        try {
+          await fetchOptions.onAfterResponse(response, req, res, options);
+        } catch (err) {
+          handleError2(err, options.target);
+          return;
+        }
+      }
+      const fakeProxyRes = {
+        statusCode: response.status,
+        statusMessage: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        rawHeaders: Object.entries(response.headers).flatMap(([key, value]) => {
+          if (Array.isArray(value)) {
+            return value.flatMap((v) => v != null ? [key, v] : []);
+          }
+          return value != null ? [key, value] : [];
+        })
+      };
+      server?.emit("proxyRes", fakeProxyRes, req, res);
+      if (!res.headersSent && !options.selfHandleResponse) {
+        for (const pass of web_o) {
+          pass(req, res, fakeProxyRes, options);
+        }
+      }
+      if (!res.writableEnded) {
+        const nodeStream = response.body ? node_stream_1.Readable.from(response.body) : null;
+        if (nodeStream) {
+          nodeStream.on("error", (err) => {
+            handleError2(err, options.target);
+          });
+          nodeStream.on("end", () => {
+            server?.emit("end", req, res, fakeProxyRes);
+          });
+          if (!options.selfHandleResponse) {
+            nodeStream.pipe(res, { end: true });
+          } else {
+            nodeStream.resume();
+          }
+        } else {
+          server?.emit("end", req, res, fakeProxyRes);
+        }
+      } else {
+        server?.emit("end", req, res, fakeProxyRes);
+      }
+    } catch (err) {
+      handleError2(err, options.target);
+    }
+  }
+  exports.WEB_PASSES = { deleteLength, timeout, XHeaders, stream };
+});
+
+// ../../node_modules/.bun/http-proxy-3@1.23.2/node_modules/http-proxy-3/dist/lib/http-proxy/passes/ws-incoming.js
+var require_ws_incoming = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
     }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function() {
+    var ownKeys = function(o) {
+      ownKeys = Object.getOwnPropertyNames || function(o2) {
+        var ar = [];
+        for (var k in o2)
+          if (Object.prototype.hasOwnProperty.call(o2, k))
+            ar[ar.length] = k;
+        return ar;
+      };
+      return ownKeys(o);
+    };
+    return function(mod4) {
+      if (mod4 && mod4.__esModule)
+        return mod4;
+      var result = {};
+      if (mod4 != null) {
+        for (var k = ownKeys(mod4), i = 0;i < k.length; i++)
+          if (k[i] !== "default")
+            __createBinding(result, mod4, k[i]);
+      }
+      __setModuleDefault(result, mod4);
+      return result;
+    };
+  }();
+  var __importDefault = exports && exports.__importDefault || function(mod4) {
+    return mod4 && mod4.__esModule ? mod4 : { default: mod4 };
   };
-  ["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
-    Object.defineProperty(Response2.prototype, k, {
-      get() {
-        return this[getResponseCache]()[k];
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.WS_PASSES = undefined;
+  exports.numOpenSockets = numOpenSockets;
+  exports.checkMethodAndHeader = checkMethodAndHeader;
+  exports.XHeaders = XHeaders;
+  exports.stream = stream;
+  var http = __importStar(__require("node:http"));
+  var https = __importStar(__require("node:https"));
+  var common = __importStar(require_common8());
+  var web_outgoing_1 = require_web_outgoing();
+  var debug_1 = __importDefault(require_src3());
+  var log = (0, debug_1.default)("http-proxy-3:ws-incoming");
+  var web_o = Object.values(web_outgoing_1.OUTGOING_PASSES);
+  function createSocketCounter(name21) {
+    let sockets = new Set;
+    return ({ add, rm: rm2 } = {}) => {
+      if (add) {
+        if (!add.id) {
+          add.id = Math.random();
+        }
+        if (!sockets.has(add.id)) {
+          sockets.add(add.id);
+        }
+      }
+      if (rm2) {
+        if (!rm2.id) {
+          rm2.id = Math.random();
+        }
+        if (sockets.has(rm2.id)) {
+          sockets.delete(rm2.id);
+        }
+      }
+      log("socket counter:", { [name21]: sockets.size }, add ? "add" : rm2 ? "rm" : "");
+      return sockets.size;
+    };
+  }
+  var socketCounter = createSocketCounter("socket");
+  var proxySocketCounter = createSocketCounter("proxySocket");
+
+  class MockResponse {
+    constructor() {
+      this.headers = {};
+      this.statusCode = 200;
+      this.statusMessage = "";
+    }
+    setHeader(key, value) {
+      this.headers[key] = value;
+      return this;
+    }
+  }
+  function numOpenSockets() {
+    return socketCounter() + proxySocketCounter();
+  }
+  function checkMethodAndHeader(req, socket) {
+    log("websocket: checkMethodAndHeader");
+    if (req.method !== "GET" || !req.headers.upgrade) {
+      socket.destroy();
+      return true;
+    }
+    if (req.headers.upgrade.toLowerCase() !== "websocket") {
+      socket.destroy();
+      return true;
+    }
+  }
+  function XHeaders(req, _socket, options) {
+    if (!options.xfwd)
+      return;
+    log("websocket: XHeaders");
+    const values = {
+      for: req.connection.remoteAddress || req.socket.remoteAddress,
+      port: common.getPort(req),
+      proto: common.hasEncryptedConnection(req) ? "wss" : "ws"
+    };
+    for (const header of ["for", "port", "proto"]) {
+      req.headers["x-forwarded-" + header] = (req.headers["x-forwarded-" + header] || "") + (req.headers["x-forwarded-" + header] ? "," : "") + values[header];
+    }
+  }
+  function stream(req, socket, options, head, server, cb) {
+    log("websocket: new stream");
+    const proxySockets = [];
+    socketCounter({ add: socket });
+    const cleanUpProxySockets = () => {
+      for (const p4 of proxySockets) {
+        p4.end();
       }
+    };
+    socket.on("close", () => {
+      socketCounter({ rm: socket });
+      cleanUpProxySockets();
     });
-  });
-  ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-    Object.defineProperty(Response2.prototype, k, {
-      value: function() {
-        return this[getResponseCache]()[k]();
+    socket.on("error", cleanUpProxySockets);
+    const createHttpHeader = (line, headers) => {
+      return Object.keys(headers).reduce((head2, key) => {
+        const value = headers[key];
+        if (!Array.isArray(value)) {
+          head2.push(key + ": " + value);
+          return head2;
+        }
+        for (let i = 0;i < value.length; i++) {
+          head2.push(key + ": " + value[i]);
+        }
+        return head2;
+      }, [line]).join(`\r
+`) + `\r
+\r
+`;
+    };
+    common.setupSocket(socket);
+    if (head && head.length) {
+      socket.unshift(head);
+    }
+    const proto = common.isSSL.test(options.target.protocol) ? https : http;
+    const outgoingOptions = common.setupOutgoing(options.ssl || {}, options, req);
+    const proxyReq = proto.request(outgoingOptions);
+    if (server) {
+      server.emit("proxyReqWs", proxyReq, req, socket, options, head);
+    }
+    proxyReq.on("error", onOutgoingError);
+    proxyReq.on("upgrade", (proxyRes, proxySocket, proxyHead) => {
+      log("upgrade");
+      proxySocketCounter({ add: proxySocket });
+      proxySockets.push(proxySocket);
+      proxySocket.on("close", () => {
+        proxySocketCounter({ rm: proxySocket });
+      });
+      proxySocket.on("error", onOutgoingError);
+      proxySocket.on("end", () => {
+        server.emit("close", proxyRes, proxySocket, proxyHead);
+      });
+      proxySocket.on("close", () => {
+        socket.end();
+      });
+      common.setupSocket(proxySocket);
+      if (proxyHead && proxyHead.length) {
+        proxySocket.unshift(proxyHead);
+      }
+      socket.write(createHttpHeader("HTTP/1.1 101 Switching Protocols", proxyRes.headers));
+      proxySocket.pipe(socket).pipe(proxySocket);
+      server.emit("open", proxySocket);
+    });
+    function onOutgoingError(err) {
+      if (cb) {
+        cb(err, req, socket);
+      } else {
+        server.emit("error", err, req, socket);
+      }
+      socket.destroySoon();
+    }
+    proxyReq.on("response", (proxyRes) => {
+      log("got non-ws HTTP response", {
+        statusCode: proxyRes.statusCode,
+        statusMessage: proxyRes.statusMessage
+      });
+      const res = new MockResponse;
+      for (const pass of web_o) {
+        pass(req, res, proxyRes, options);
+      }
+      let writeChunk = (chunk) => {
+        socket.write(chunk);
+      };
+      if (req.httpVersion === "1.1" && proxyRes.headers["content-length"] === undefined) {
+        res.headers["transfer-encoding"] = "chunked";
+        writeChunk = (chunk) => {
+          socket.write(chunk.length.toString(16));
+          socket.write(`\r
+`);
+          socket.write(chunk);
+          socket.write(`\r
+`);
+        };
+      }
+      const proxyHead = createHttpHeader(`HTTP/${req.httpVersion} ${proxyRes.statusCode} ${proxyRes.statusMessage}`, res.headers);
+      if (!socket.destroyed) {
+        socket.write(proxyHead);
+        proxyRes.on("data", (chunk) => {
+          writeChunk(chunk);
+        });
+        proxyRes.on("end", () => {
+          writeChunk("");
+          socket.destroySoon();
+        });
+      } else {
+        proxyRes.resume();
       }
     });
+    proxyReq.end();
+  }
+  exports.WS_PASSES = { checkMethodAndHeader, XHeaders, stream };
+});
+
+// ../../node_modules/.bun/http-proxy-3@1.23.2/node_modules/http-proxy-3/dist/lib/http-proxy/index.js
+var require_http_proxy = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
   });
-  Object.setPrototypeOf(Response2, GlobalResponse);
-  Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-  if (typeof global.crypto === "undefined") {
-    global.crypto = crypto2;
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function() {
+    var ownKeys = function(o) {
+      ownKeys = Object.getOwnPropertyNames || function(o2) {
+        var ar = [];
+        for (var k in o2)
+          if (Object.prototype.hasOwnProperty.call(o2, k))
+            ar[ar.length] = k;
+        return ar;
+      };
+      return ownKeys(o);
+    };
+    return function(mod4) {
+      if (mod4 && mod4.__esModule)
+        return mod4;
+      var result = {};
+      if (mod4 != null) {
+        for (var k = ownKeys(mod4), i = 0;i < k.length; i++)
+          if (k[i] !== "default")
+            __createBinding(result, mod4, k[i]);
+      }
+      __setModuleDefault(result, mod4);
+      return result;
+    };
+  }();
+  var __importDefault = exports && exports.__importDefault || function(mod4) {
+    return mod4 && mod4.__esModule ? mod4 : { default: mod4 };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ProxyServer = undefined;
+  var http = __importStar(__require("node:http"));
+  var http2 = __importStar(__require("node:http2"));
+  var web_incoming_1 = require_web_incoming();
+  var ws_incoming_1 = require_ws_incoming();
+  var node_events_1 = __require("node:events");
+  var debug_1 = __importDefault(require_src3());
+  var common_1 = require_common8();
+  var log = (0, debug_1.default)("http-proxy-3");
+
+  class ProxyServer extends node_events_1.EventEmitter {
+    constructor(options = {}) {
+      super();
+      this.createRightProxy = (type) => {
+        log("createRightProxy", { type });
+        return (options2) => {
+          return (...args) => {
+            const req = args[0];
+            log("proxy: ", { type, path: req.url });
+            const res = args[1];
+            const passes = type === "ws" ? this.wsPasses : this.webPasses;
+            if (type == "ws") {
+              res.on("error", (err) => {
+                this.emit("error", err, req, res);
+              });
+            }
+            let counter = args.length - 1;
+            let head;
+            let cb;
+            if (typeof args[counter] === "function") {
+              cb = args[counter];
+              counter--;
+            }
+            let requestOptions;
+            if (!(args[counter] instanceof Buffer) && args[counter] !== res) {
+              requestOptions = { ...options2, ...args[counter] };
+              counter--;
+            } else {
+              requestOptions = { ...options2 };
+            }
+            if (args[counter] instanceof Buffer) {
+              head = args[counter];
+            }
+            for (const e of ["target", "forward"]) {
+              if (typeof requestOptions[e] === "string") {
+                requestOptions[e] = (0, common_1.toURL)(requestOptions[e]);
+              }
+            }
+            if (!requestOptions.target && !requestOptions.forward) {
+              this.emit("error", new Error("Must set target or forward"), req, res);
+              return;
+            }
+            for (const pass of passes) {
+              if (pass(req, res, requestOptions, head, this, cb)) {
+                break;
+              }
+            }
+          };
+        };
+      };
+      this.onError = (err) => {
+        if (this.listeners("error").length === 1) {
+          throw err;
+        }
+      };
+      this.listen = (port, hostname2) => {
+        log("listen", { port, hostname: hostname2 });
+        const requestListener = (req, res) => {
+          this.web(req, res);
+        };
+        this._server = this.options.ssl ? http2.createSecureServer({ ...this.options.ssl, allowHTTP1: true }, requestListener) : http.createServer(requestListener);
+        if (this.options.ws) {
+          this._server.on("upgrade", (req, socket, head) => {
+            this.ws(req, socket, head);
+          });
+        }
+        this._server.listen(port, hostname2);
+        return this;
+      };
+      this.address = () => {
+        return this._server?.address();
+      };
+      this.close = (cb) => {
+        if (this._server == null) {
+          cb?.();
+          return;
+        }
+        this._server.close((err) => {
+          this._server = null;
+          cb?.(err);
+        });
+      };
+      this.before = (type, passName, cb) => {
+        if (type !== "ws" && type !== "web") {
+          throw new Error("type must be `web` or `ws`");
+        }
+        const passes = type === "ws" ? this.wsPasses : this.webPasses;
+        let i = false;
+        passes.forEach((v, idx) => {
+          if (v.name === passName) {
+            i = idx;
+          }
+        });
+        if (i === false) {
+          throw new Error("No such pass");
+        }
+        passes.splice(i, 0, cb);
+      };
+      this.after = (type, passName, cb) => {
+        if (type !== "ws" && type !== "web") {
+          throw new Error("type must be `web` or `ws`");
+        }
+        const passes = type === "ws" ? this.wsPasses : this.webPasses;
+        let i = false;
+        passes.forEach((v, idx) => {
+          if (v.name === passName) {
+            i = idx;
+          }
+        });
+        if (i === false) {
+          throw new Error("No such pass");
+        }
+        passes.splice(i++, 0, cb);
+      };
+      log("creating a ProxyServer", options);
+      options.prependPath = options.prependPath !== false;
+      this.options = options;
+      this.web = this.createRightProxy("web")(options);
+      this.ws = this.createRightProxy("ws")(options);
+      this.webPasses = Object.values(web_incoming_1.WEB_PASSES);
+      this.wsPasses = Object.values(ws_incoming_1.WS_PASSES);
+      this.on("error", this.onError);
+    }
+    static createProxyServer(options) {
+      return new ProxyServer(options);
+    }
+    static createServer(options) {
+      return new ProxyServer(options);
+    }
+    static createProxy(options) {
+      return new ProxyServer(options);
+    }
   }
-  outgoingEnded = Symbol("outgoingEnded");
+  exports.ProxyServer = ProxyServer;
+});
+
+// ../../node_modules/.bun/http-proxy-3@1.23.2/node_modules/http-proxy-3/dist/lib/index.js
+var require_lib9 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.numOpenSockets = exports.ProxyServer = undefined;
+  exports.createProxyServer = createProxyServer;
+  exports.createServer = createProxyServer;
+  exports.createProxy = createProxyServer;
+  var index_1 = require_http_proxy();
+  Object.defineProperty(exports, "ProxyServer", { enumerable: true, get: function() {
+    return index_1.ProxyServer;
+  } });
+  var ws_incoming_1 = require_ws_incoming();
+  Object.defineProperty(exports, "numOpenSockets", { enumerable: true, get: function() {
+    return ws_incoming_1.numOpenSockets;
+  } });
+  function createProxyServer(options = {}) {
+    return new index_1.ProxyServer(options);
+  }
+  exports.default = index_1.ProxyServer;
 });
 
 // ../api/src/index.ts
@@ -145508,16 +147234,29 @@ var Factory = class {
 var createMiddleware = (middleware) => middleware;
 
 // ../api/src/middleware/errorHandler.ts
+function getTimestamp() {
+  const d = new Date;
+  const pad2 = (n) => String(n).padStart(2, "0");
+  const pad3 = (n) => String(n).padStart(3, "0");
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}.${pad3(d.getMilliseconds())}`;
+}
 function handleError(error, c) {
+  const timestamp = getTimestamp();
   if (error instanceof C4AError) {
+    console.error(`[api] C4AError [${error.code}]: ${error.message}`, error.details || "");
     const status = mapErrorCodeToStatus(error.code);
-    return c.json(error.toResponse(), status);
+    const response2 = error.toResponse();
+    return c.json({ ...response2, timestamp }, status);
   }
+  const isDev = true;
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  const errorStack = isDev && error instanceof Error ? error.stack : undefined;
   console.error("[api] Unhandled error:", error);
   const response = {
     code: "UNKNOWN" /* UNKNOWN */,
-    message: "Internal Server Error",
-    details: null
+    message: isDev ? `Internal Server Error: ${errorMessage}` : "Internal Server Error",
+    details: errorStack ? { stack: errorStack } : null,
+    timestamp
   };
   return c.json(response, 500);
 }
@@ -146500,6 +148239,10 @@ __legacyDecorateClassTS([
   Property({ type: "string", nullable: true }),
   __legacyMetadataTS("design:type", String)
 ], SourceContentRecord.prototype, "content_hash", undefined);
+__legacyDecorateClassTS([
+  Property({ type: "string", nullable: true }),
+  __legacyMetadataTS("design:type", String)
+], SourceContentRecord.prototype, "content_encoding", undefined);
 __legacyDecorateClassTS([
   Property({ type: "date" }),
   __legacyMetadataTS("design:type", typeof Date === "undefined" ? Object : Date)
@@ -146780,6 +148523,16 @@ class DocStore {
     const orm = this.orm;
     await orm.getSchemaGenerator().updateSchema();
   }
+  async safeFlush() {
+    try {
+      await this.em.flush();
+    } catch (error) {
+      if (this.docProvider === "mongodb" && error instanceof Error && error.message.includes("Transaction numbers are only allowed")) {
+        throw new C4AError("STORAGE_FAILED" /* STORAGE_FAILED */, "MongoDB 事务失败：单机 MongoDB 不支持事务。请配置 MongoDB 副本集（Replica Set）以启用事务支持。" + "参考：https://www.mongodb.com/docs/manual/tutorial/deploy-replica-set/", { originalError: error.message });
+      }
+      throw error;
+    }
+  }
   async save(entity2) {
     DocStore.assertEntity(entity2);
     const existing = await this.em.findOne(EntityRecord, { id: entity2.id });
@@ -146788,7 +148541,7 @@ class DocStore {
     } else {
       this.em.create(EntityRecord, DocStore.toEntityRecord(entity2));
     }
-    await this.em.flush();
+    await this.safeFlush();
     return entity2;
   }
   async read(id2) {
@@ -146859,7 +148612,7 @@ class DocStore {
         this.em.create(RelationRecord, DocStore.toRelationRecord(relation2));
       }
     }
-    await this.em.flush();
+    await this.safeFlush();
   }
   async deleteRelationsForEntity(entityId) {
     await this.em.nativeDelete(RelationRecord, {
@@ -178900,9 +180653,6 @@ var withTransaction = async (em, fn) => {
   return fn(em);
 };
 var isSourceType = (value) => value === "code" || value === "doc" || value === "feishu" || value === "web";
-var UPLOAD_ALLOWED_EXTENSIONS = new Set([".md", ".doc", ".docx", ".pdf", ".ppt", ".pptx", ".txt"]);
-var UPLOAD_MAX_FILE_SIZE = 5 * 1024 * 1024;
-var UPLOAD_MAX_FILES = 10;
 var findNodeByPath = (tree, targetPath) => {
   for (const node of tree) {
     if (node.path === targetPath)
@@ -179287,14 +181037,21 @@ function createSourcesRouter(storageProvider) {
       if (typeof file2.content !== "string") {
         throw new C4AError("VALIDATION_FAILED" /* VALIDATION_FAILED */, "Missing content", { file_name: file2.file_name });
       }
-      const ext = file2.file_name.includes(".") ? `.${file2.file_name.split(".").pop().toLowerCase()}` : "";
+      const ext = getFileExtension(file2.file_name);
       if (!UPLOAD_ALLOWED_EXTENSIONS.has(ext)) {
         throw new C4AError("VALIDATION_FAILED" /* VALIDATION_FAILED */, "Unsupported file type", {
           file_name: file2.file_name,
           extension: ext
         });
       }
-      if (Buffer.byteLength(file2.content, "utf-8") > UPLOAD_MAX_FILE_SIZE) {
+      if (file2.encoding === "base64") {
+        const decodedSize = Math.ceil(file2.content.length * 3 / 4);
+        if (decodedSize > UPLOAD_MAX_FILE_SIZE) {
+          throw new C4AError("VALIDATION_FAILED" /* VALIDATION_FAILED */, "File exceeds 5MB limit", {
+            file_name: file2.file_name
+          });
+        }
+      } else if (Buffer.byteLength(file2.content, "utf-8") > UPLOAD_MAX_FILE_SIZE) {
         throw new C4AError("VALIDATION_FAILED" /* VALIDATION_FAILED */, "File exceeds 5MB limit", {
           file_name: file2.file_name
         });
@@ -179322,7 +181079,8 @@ function createSourcesRouter(storageProvider) {
         const now2 = new Date;
         for (const file2 of files) {
           const nodePath = parentPath ? `${parentPath}/${file2.file_name}` : file2.file_name;
-          const hash2 = contentHash(file2.content);
+          const hashInput = file2.encoding === "base64" ? Buffer.from(file2.content, "base64") : file2.content;
+          const hash2 = contentHash(hashInput);
           const newNode = {
             path: nodePath,
             kind: "source",
@@ -179349,6 +181107,7 @@ function createSourcesRouter(storageProvider) {
           cnt.source_path = nodePath;
           cnt.content = file2.content;
           cnt.content_hash = hash2;
+          cnt.content_encoding = file2.encoding === "base64" ? "base64" : null;
           cnt.created_at = now2;
           cnt.updated_at = now2;
           emTx.persist(cnt);
@@ -179375,7 +181134,8 @@ function createSourcesRouter(storageProvider) {
       const now2 = new Date;
       const records = [];
       for (const file2 of files) {
-        const hash2 = contentHash(file2.content);
+        const hashInput = file2.encoding === "base64" ? Buffer.from(file2.content, "base64") : file2.content;
+        const hash2 = contentHash(hashInput);
         const rec = new SourceRecord;
         rec.id = `src_${generateUUID()}`;
         rec.library_id = libraryId;
@@ -179396,6 +181156,7 @@ function createSourcesRouter(storageProvider) {
         cnt.source_path = "";
         cnt.content = file2.content;
         cnt.content_hash = hash2;
+        cnt.content_encoding = file2.encoding === "base64" ? "base64" : null;
         cnt.created_at = now2;
         cnt.updated_at = now2;
         emTx.persist(cnt);
@@ -179586,6 +181347,7 @@ function createSourcesRouter(storageProvider) {
       source_path: content.source_path,
       content: content.content,
       content_hash: content.content_hash,
+      content_encoding: content.content_encoding ?? null,
       created_at: content.created_at,
       updated_at: content.updated_at
     }, 200);
@@ -179774,9 +181536,537 @@ function createApiApp(options = {}) {
 
 // ../server/src/serve.ts
 init_src();
-init_dist2();
+
+// ../../node_modules/.bun/@hono+node-server@1.19.9+eb2864ea6bc646ec/node_modules/@hono/node-server/dist/index.mjs
+import { createServer as createServerHTTP } from "http";
+import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+import { Http2ServerRequest } from "http2";
+import { Readable } from "stream";
+import crypto2 from "crypto";
+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 Request2 = 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 = Symbol("wrapBodyStream");
+var newRequestFromIncoming = (method, url2, headers, incoming, abortController) => {
+  const init = {
+    method,
+    headers,
+    signal: abortController.signal
+  };
+  if (method === "TRACE") {
+    init.method = "GET";
+    const req = new Request2(url2, 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 ||= Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error40) {
+            controller.error(error40);
+          }
+        }
+      });
+    } else {
+      init.body = Readable.toWeb(incoming);
+    }
+  }
+  return new Request2(url2, init);
+};
+var getRequestCache = Symbol("getRequestCache");
+var requestCache = Symbol("requestCache");
+var incomingKey = Symbol("incomingKey");
+var urlKey = Symbol("urlKey");
+var headersKey = Symbol("headersKey");
+var abortControllerKey = Symbol("abortControllerKey");
+var getAbortController = 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.setPrototypeOf(requestPrototype, Request2.prototype);
+var newRequest = (incoming, defaultHostname) => {
+  const req = Object.create(requestPrototype);
+  req[incomingKey] = incoming;
+  const incomingUrl = incoming.url || "";
+  if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+    if (incoming instanceof Http2ServerRequest) {
+      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+    }
+    try {
+      const url22 = new URL(incomingUrl);
+      req[urlKey] = url22.href;
+    } catch (e) {
+      throw new RequestError("Invalid absolute URL", { cause: e });
+    }
+    return req;
+  }
+  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+  if (!host) {
+    throw new RequestError("Missing host header");
+  }
+  let scheme;
+  if (incoming instanceof Http2ServerRequest) {
+    scheme = incoming.scheme;
+    if (!(scheme === "http" || scheme === "https")) {
+      throw new RequestError("Unsupported scheme");
+    }
+  } else {
+    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+  }
+  const url2 = new URL(`${scheme}://${host}${incomingUrl}`);
+  if (url2.hostname.length !== host.length && url2.hostname !== host.replace(/:\d+$/, "")) {
+    throw new RequestError("Invalid host header");
+  }
+  req[urlKey] = url2.href;
+  return req;
+};
+var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
+var cacheKey = Symbol("cache");
+var GlobalResponse = global.Response;
+var Response2 = class _Response {
+  #body;
+  #init;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    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) {
+      headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
+      this[cacheKey] = [init?.status || 200, body, headers];
+    }
+  }
+  get headers() {
+    const cache = this[cacheKey];
+    if (cache) {
+      if (!(cache[2] instanceof Headers)) {
+        cache[2] = new Headers(cache[2]);
+      }
+      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.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(undefined))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const cancel = (error40) => {
+    reader.cancel(error40).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(error40) {
+    if (error40) {
+      writable.destroy(error40);
+    }
+  }
+  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(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
+var buildOutgoingHttpHeaders = (headers) => {
+  const res = {};
+  if (!(headers instanceof Headers)) {
+    headers = new Headers(headers ?? undefined);
+  }
+  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 = crypto2;
+}
+var outgoingEnded = Symbol("outgoingEnded");
+var handleRequestError = () => new Response(null, {
+  status: 400
+});
+var handleFetchError2 = (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];
+  if (header instanceof Headers) {
+    header = buildOutgoingHttpHeaders(header);
+  }
+  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(handleFetchError2);
+    }
+  }
+  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 = undefined;
+    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((resolve2) => setTimeout(resolve2));
+            maxReadCount = 3;
+            continue;
+          }
+          break;
+        }
+        currentReadPromise = undefined;
+        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 !== Request2) {
+    Object.defineProperty(global, "Request", {
+      value: Request2
+    });
+    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 Http2ServerRequest2) {
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
+      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(() => {
+                incoming.destroy();
+              });
+            }
+          });
+        }
+      });
+      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 = handleFetchError2(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 createServer = options.createServer || createServerHTTP;
+  const server = createServer(options.serverOptions || {}, requestListener);
+  return server;
+};
+
+// ../server/src/serve.ts
+var import_http_proxy_3 = __toESM(require_lib9(), 1);
 var import_yaml3 = __toESM(require_dist(), 1);
-import { createServer as createHttpServer } from "node:http";
+import { createServer as createHttpServer, ServerResponse } from "node:http";
 import { existsSync as existsSync5 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
 import path8 from "node:path";
@@ -180391,6 +182681,22 @@ class DaemonManager {
   }
 }
 
+// ../server/src/index.ts
+function createServer(options = {}) {
+  const app = new Hono2;
+  const storageProvider = options.storageProvider ?? createDefaultStorageProvider();
+  const { injectWebSocket, wss, upgradeWebSocket, broadcastToWebClients } = createWsEndpoint(app);
+  const daemonManager = new DaemonManager(storageProvider, broadcastToWebClients);
+  const apiApp = createApiApp({
+    ...options,
+    storageProvider,
+    contextVariables: { daemonManager }
+  });
+  app.route("/api/v1", apiApp);
+  app.get("/ws/daemon", upgradeWebSocket(() => daemonManager.createWsHandlers()));
+  return { app, injectWebSocket, wss, daemonManager };
+}
+
 // ../server/src/static.ts
 import { existsSync as existsSync4 } from "node:fs";
 import { readFile as readFile3 } from "node:fs/promises";
@@ -180623,25 +182929,6 @@ function mountStatic(app, staticDir) {
   });
 }
 
-// ../server/src/index.ts
-function createServer(options = {}) {
-  const app = new Hono2;
-  const storageProvider = options.storageProvider ?? createDefaultStorageProvider();
-  const { injectWebSocket, wss, upgradeWebSocket, broadcastToWebClients } = createWsEndpoint(app);
-  const daemonManager = new DaemonManager(storageProvider, broadcastToWebClients);
-  const apiApp = createApiApp({
-    ...options,
-    storageProvider,
-    contextVariables: { daemonManager }
-  });
-  app.route("/api/v1", apiApp);
-  app.get("/ws/daemon", upgradeWebSocket(() => daemonManager.createWsHandlers()));
-  if (options.staticDir) {
-    mountStatic(app, options.staticDir);
-  }
-  return { app, injectWebSocket, wss, daemonManager };
-}
-
 // ../server/src/bootstrap.ts
 init_src();
 async function bootstrapPhase0(em) {
@@ -180715,10 +183002,17 @@ function timestamp() {
   const pad3 = (n) => String(n).padStart(3, "0");
   return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}.${pad3(d.getMilliseconds())}`;
 }
+var originalLog = console.log.bind(console);
 var originalInfo = console.info.bind(console);
 var originalError = console.error.bind(console);
+console.log = (...args) => originalLog(`[${timestamp()}]`, ...args);
 console.info = (...args) => originalInfo(`[${timestamp()}]`, ...args);
 console.error = (...args) => originalError(`[${timestamp()}]`, ...args);
+function displayHost(host) {
+  if (host === "::" || host === "0.0.0.0")
+    return "127.0.0.1";
+  return host;
+}
 function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -180741,9 +183035,22 @@ async function loadServerListenConfig() {
   const host = typeof serverSection.host === "string" ? serverSection.host : defaults2.host;
   return { port, host };
 }
+function attachPortErrorHandler(server, label) {
+  server.on("error", (error40) => {
+    const err = error40;
+    if (err?.code === "EADDRINUSE") {
+      console.error(`${label} 端口已被占用`);
+      process.exit(1);
+    }
+    const message = error40 instanceof Error ? error40.message : String(error40);
+    console.error(`${label} error: ${message}`);
+  });
+}
 async function startServer() {
   const { host, port } = await loadServerListenConfig();
   const isDev = process.env.C4A_DEV === "1";
+  const webPort = port + 20;
+  const dHost = displayHost(host);
   const currentDir = path8.dirname(fileURLToPath(import.meta.url));
   const webPkgDir = path8.resolve(currentDir, "..", "..", "web");
   function resolveStaticDir() {
@@ -180757,77 +183064,71 @@ async function startServer() {
     }
     return;
   }
-  const staticDir = !isDev ? resolveStaticDir() : undefined;
-  const storageProvider = createDefaultStorageProvider();
-  const options = {
-    storageProvider
-  };
-  if (staticDir)
-    options.staticDir = staticDir;
-  const { app, injectWebSocket } = createServer(options);
-  tryBootstrapPhase0(storageProvider);
   if (isDev) {
-    const { getRequestListener: getRequestListener2 } = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const { createServer: createViteServer } = await import("vite");
-    const honoListener = getRequestListener2(app.fetch);
-    let vite;
-    const server = createHttpServer((req, res) => {
-      const url2 = req.url ?? "/";
-      if (url2.startsWith("/api/") || url2 === "/ws" || url2.startsWith("/ws/")) {
-        honoListener(req, res);
-      } else {
-        vite.middlewares(req, res, () => {
-          honoListener(req, res);
-        });
-      }
-    });
-    vite = await createViteServer({
+    const vite = await createViteServer({
       root: webPkgDir,
-      server: { middlewareMode: true, hmr: { server } },
+      server: { port: webPort, host, strictPort: true },
       appType: "spa"
     });
-    injectWebSocket(server);
-    const upgradeListeners = server.listeners("upgrade");
-    const honoUpgrade = upgradeListeners[upgradeListeners.length - 1];
-    server.removeListener("upgrade", honoUpgrade);
-    server.on("upgrade", (req, socket, head) => {
-      const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
-      if (pathname === "/ws" || pathname === "/ws/daemon") {
-        honoUpgrade(req, socket, head);
-      }
-    });
-    server.on("error", (error40) => {
-      const err = error40;
-      if (err?.code === "EADDRINUSE") {
-        console.error("端口已被占用");
-        process.exit(1);
-      }
-      const message = error40 instanceof Error ? error40.message : String(error40);
-      console.error(`Server error: ${message}`);
-    });
-    server.listen(port, host, () => {
-      console.info(`C4A Server (dev) 已启动: http://${host}:${port}`);
-      console.info(`Vite HMR 已启用，修改 web 源码后自动热更新`);
-    });
+    await vite.listen();
+    console.info(`Vite Dev Server: http://${dHost}:${webPort}`);
   } else {
-    const server = createAdaptorServer({ fetch: app.fetch });
-    server.on("error", (error40) => {
-      const err = error40;
-      if (err?.code === "EADDRINUSE") {
-        console.error("端口已被占用");
-        process.exit(1);
-      }
-      const message = error40 instanceof Error ? error40.message : String(error40);
-      console.error(`Server error: ${message}`);
-    });
-    injectWebSocket(server);
-    server.listen(port, host, () => {
-      console.info(`C4A Server 已启动: http://${host}:${port}`);
-      if (staticDir) {
-        console.info(`静态资源托管: ${staticDir}`);
-      }
-    });
+    const staticDir = resolveStaticDir();
+    if (staticDir) {
+      const webApp = new Hono2;
+      mountStatic(webApp, staticDir);
+      const webServer = createAdaptorServer({ fetch: webApp.fetch });
+      attachPortErrorHandler(webServer, "Web Server");
+      await new Promise((resolve2) => {
+        webServer.listen(webPort, host, () => {
+          console.info(`Web Server (static): http://${dHost}:${webPort}`);
+          console.info(`  静态资源: ${staticDir}`);
+          resolve2();
+        });
+      });
+    }
   }
+  const storageProvider = createDefaultStorageProvider();
+  const { app, injectWebSocket } = createServer({ storageProvider });
+  tryBootstrapPhase0(storageProvider);
+  const honoListener = getRequestListener(app.fetch);
+  const webProxy = import_http_proxy_3.createProxyServer({ target: `http://${dHost}:${webPort}` });
+  const gateway2 = createHttpServer((req, res) => {
+    const url2 = req.url ?? "/";
+    if (url2.startsWith("/api/") || url2 === "/ws" || url2.startsWith("/ws/")) {
+      honoListener(req, res);
+    } else {
+      webProxy.web(req, res);
+    }
+  });
+  injectWebSocket(gateway2);
+  const upgradeListeners = gateway2.listeners("upgrade");
+  const honoUpgrade = upgradeListeners[upgradeListeners.length - 1];
+  gateway2.removeAllListeners("upgrade");
+  gateway2.on("upgrade", (req, socket, head) => {
+    const url2 = req.url ?? "/";
+    if (url2 === "/ws" || url2.startsWith("/ws/")) {
+      honoUpgrade(req, socket, head);
+    } else {
+      socket.destroy();
+    }
+  });
+  attachPortErrorHandler(gateway2, "Gateway");
+  webProxy.on("error", (_err, _req, res) => {
+    if (res instanceof ServerResponse && !res.headersSent) {
+      res.writeHead(503, { "Content-Type": "text/plain" });
+      res.end("Web server not ready");
+    }
+  });
+  await new Promise((resolve2) => {
+    gateway2.listen(port, host, () => {
+      console.info(`C4A Gateway: http://${dHost}:${port}`);
+      console.info(`  → API+WS  (in-process)`);
+      console.info(`  → Web     http://${dHost}:${webPort}`);
+      resolve2();
+    });
+  });
 }
 async function tryBootstrapPhase0(storageProvider) {
   try {