@kanbodev/mcp 1.1.9 → 1.2.0

package/dist/index.js

@@ -5,25 +5,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -227,7 +245,7 @@ var init_constants = __esm(() => {
   };
   SERVER_INFO = {
     name: "kanbo-mcp",
-    version: "1.1.9",
+    version: "1.2.0",
     description: "MCP server for Kanbo project management"
   };
   PAT_CONFIG = {
@@ -4812,6 +4830,7 @@ var require_limitLength = __commonJS((exports) => {
 var require_pattern = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var code_1 = require_code2();
+  var util_1 = require_util();
   var codegen_1 = require_codegen();
   var error2 = {
     message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
@@ -4824,10 +4843,18 @@ var require_pattern = __commonJS((exports) => {
     $data: true,
     error: error2,
     code(cxt) {
-      const { data, $data, schema, schemaCode, it } = cxt;
+      const { gen, data, $data, schema, schemaCode, it } = cxt;
       const u = it.opts.unicodeRegExp ? "u" : "";
-      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
-      cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+      if ($data) {
+        const { regExp } = it.opts.code;
+        const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
+        const valid = gen.let("valid");
+        gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+        cxt.fail$data((0, codegen_1._)`!${valid}`);
+      } else {
+        const regExp = (0, code_1.usePattern)(cxt, schema);
+        cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+      }
     }
   };
   exports.default = def;
@@ -6520,7 +6547,7 @@ var require_formats = __commonJS((exports) => {
   }
   var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time(str) {
+    return function time3(str) {
       const matches = TIME.exec(str);
       if (!matches)
         return false;
@@ -7999,8 +8026,18 @@ var require_sonic_boom = __commonJS((exports, module) => {
       this.flush = flush;
       this.flushSync = flushSync;
       this._actualWrite = actualWrite;
-      fsWriteSync = () => fs2.writeSync(this.fd, this._writingBuf, "utf8");
-      fsWrite = () => fs2.write(this.fd, this._writingBuf, "utf8", this.release);
+      fsWriteSync = () => {
+        if (Buffer.isBuffer(this._writingBuf)) {
+          return fs2.writeSync(this.fd, this._writingBuf);
+        }
+        return fs2.writeSync(this.fd, this._writingBuf, "utf8");
+      };
+      fsWrite = () => {
+        if (Buffer.isBuffer(this._writingBuf)) {
+          return fs2.write(this.fd, this._writingBuf, this.release);
+        }
+        return fs2.write(this.fd, this._writingBuf, "utf8", this.release);
+      };
     } else {
       throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
     }
@@ -8095,11 +8132,11 @@ var require_sonic_boom = __commonJS((exports, module) => {
     }
   }
   function releaseWritingBuf(writingBuf, len, n) {
-    if (typeof writingBuf === "string" && Buffer.byteLength(writingBuf) !== n) {
-      n = Buffer.from(writingBuf).subarray(0, n).toString().length;
+    if (typeof writingBuf === "string") {
+      writingBuf = Buffer.from(writingBuf);
     }
     len = Math.max(len - n, 0);
-    writingBuf = writingBuf.slice(n);
+    writingBuf = writingBuf.subarray(n);
     return { writingBuf, len };
   }
   function emitDrain(sonic) {
@@ -8123,14 +8160,16 @@ var require_sonic_boom = __commonJS((exports, module) => {
     if (this.destroyed) {
       throw new Error("SonicBoom destroyed");
     }
-    const len = this._len + data.length;
+    data = "" + data;
+    const dataLen = Buffer.byteLength(data);
+    const len = this._len + dataLen;
     const bufs = this._bufs;
     if (this.maxLength && len > this.maxLength) {
       this.emit("drop", data);
       return this._len < this._hwm;
     }
-    if (bufs.length === 0 || bufs[bufs.length - 1].length + data.length > this.maxWrite) {
-      bufs.push("" + data);
+    if (bufs.length === 0 || Buffer.byteLength(bufs[bufs.length - 1]) + dataLen > this.maxWrite) {
+      bufs.push(data);
     } else {
       bufs[bufs.length - 1] += data;
     }
@@ -8315,12 +8354,12 @@ var require_sonic_boom = __commonJS((exports, module) => {
       this._writingBuf = "";
     }
     let buf = "";
-    while (this._bufs.length || buf) {
+    while (this._bufs.length || buf.length) {
       if (buf.length <= 0) {
         buf = this._bufs[0];
       }
       try {
-        const n = fs2.writeSync(this.fd, buf, "utf8");
+        const n = Buffer.isBuffer(buf) ? fs2.writeSync(this.fd, buf) : fs2.writeSync(this.fd, buf, "utf8");
         const releasedBufObj = releaseWritingBuf(buf, this._len, n);
         buf = releasedBufObj.writingBuf;
         this._len = releasedBufObj.len;
@@ -8381,16 +8420,16 @@ var require_sonic_boom = __commonJS((exports, module) => {
   function actualWrite() {
     const release = this.release;
     this._writing = true;
-    this._writingBuf = this._writingBuf || this._bufs.shift() || "";
+    this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "";
     if (this.sync) {
       try {
-        const written = fs2.writeSync(this.fd, this._writingBuf, "utf8");
+        const written = Buffer.isBuffer(this._writingBuf) ? fs2.writeSync(this.fd, this._writingBuf) : fs2.writeSync(this.fd, this._writingBuf, "utf8");
         release(null, written);
       } catch (err) {
         release(err);
       }
     } else {
-      fs2.write(this.fd, this._writingBuf, "utf8", release);
+      fs2.write(this.fd, this._writingBuf, release);
     }
   }
   function actualWriteBuffer() {
@@ -8658,7 +8697,7 @@ var require_indexes = __commonJS((exports, module) => {
 
 // node_modules/thread-stream/index.js
 var require_thread_stream = __commonJS((exports, module) => {
-  var __dirname = "/Users/sin/0dev/kanbo/kanbo-mcp/node_modules/thread-stream";
+  var __dirname = "C:\\Users\\cloudpg07\\0dev\\kanbo-mcp\\node_modules\\thread-stream";
   var { version: version2 } = require_package();
   var { EventEmitter } = __require("events");
   var { Worker } = __require("worker_threads");
@@ -9083,10 +9122,12 @@ var require_thread_stream = __commonJS((exports, module) => {
 
 // node_modules/pino/lib/transport.js
 var require_transport = __commonJS((exports, module) => {
-  var __dirname = "/Users/sin/0dev/kanbo/kanbo-mcp/node_modules/pino/lib";
+  var __dirname = "C:\\Users\\cloudpg07\\0dev\\kanbo-mcp\\node_modules\\pino\\lib";
   var { createRequire: createRequire2 } = __require("module");
+  var { existsSync: existsSync2 } = __require("node:fs");
   var getCallers = require_caller();
   var { join: join2, isAbsolute, sep } = __require("node:path");
+  var { fileURLToPath } = __require("node:url");
   var sleep = require_atomic_sleep();
   var onExit = require_on_exit_leak_free();
   var ThreadStream = require_thread_stream();
@@ -9110,6 +9151,63 @@ var require_transport = __commonJS((exports, module) => {
     }
     return false;
   }
+  function sanitizeNodeOptions(nodeOptions) {
+    const tokens = nodeOptions.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+    if (!tokens) {
+      return nodeOptions;
+    }
+    const sanitized = [];
+    let changed = false;
+    for (let i = 0;i < tokens.length; i++) {
+      const token = tokens[i];
+      if (token === "--require" || token === "-r" || token === "--import") {
+        const next = tokens[i + 1];
+        if (next && shouldDropPreload(next)) {
+          changed = true;
+          i++;
+          continue;
+        }
+        sanitized.push(token);
+        if (next) {
+          sanitized.push(next);
+          i++;
+        }
+        continue;
+      }
+      if (token.startsWith("--require=") || token.startsWith("-r=") || token.startsWith("--import=")) {
+        const value = token.slice(token.indexOf("=") + 1);
+        if (shouldDropPreload(value)) {
+          changed = true;
+          continue;
+        }
+      }
+      sanitized.push(token);
+    }
+    return changed ? sanitized.join(" ") : nodeOptions;
+  }
+  function shouldDropPreload(value) {
+    const unquoted = stripQuotes(value);
+    if (!unquoted) {
+      return false;
+    }
+    let path2 = unquoted;
+    if (path2.startsWith("file://")) {
+      try {
+        path2 = fileURLToPath(path2);
+      } catch {
+        return false;
+      }
+    }
+    return isAbsolute(path2) && !existsSync2(path2);
+  }
+  function stripQuotes(value) {
+    const first = value[0];
+    const last = value[value.length - 1];
+    if (first === '"' && last === '"' || first === "'" && last === "'") {
+      return value.slice(1, -1);
+    }
+    return value;
+  }
   function buildStream(filename, workerData, workerOpts, sync, name) {
     if (!workerOpts.execArgv && hasPreloadFlags() && __require.main === undefined) {
       workerOpts = {
@@ -9117,6 +9215,18 @@ var require_transport = __commonJS((exports, module) => {
         execArgv: []
       };
     }
+    if (!workerOpts.env && process.env.NODE_OPTIONS) {
+      const nodeOptions = sanitizeNodeOptions(process.env.NODE_OPTIONS);
+      if (nodeOptions !== process.env.NODE_OPTIONS) {
+        workerOpts = {
+          ...workerOpts,
+          env: {
+            ...process.env,
+            NODE_OPTIONS: nodeOptions
+          }
+        };
+      }
+    }
     workerOpts = { ...workerOpts, name };
     const stream = new ThreadStream({
       filename,
@@ -9750,7 +9860,7 @@ var require_levels = __commonJS((exports, module) => {
 
 // node_modules/pino/lib/meta.js
 var require_meta = __commonJS((exports, module) => {
-  module.exports = { version: "10.3.0" };
+  module.exports = { version: "10.3.1" };
 });
 
 // node_modules/pino/lib/proto.js
@@ -12041,52 +12151,135 @@ function textDecode(bytes, encoding = "utf-8") {
       throw new RangeError(`Encoding '${encoding}' not supported`);
   }
 }
+function flushChunk(parts, chunk) {
+  if (chunk.length === 0)
+    return;
+  parts.push(String.fromCharCode.apply(null, chunk));
+  chunk.length = 0;
+}
+function pushCodeUnit(parts, chunk, codeUnit) {
+  chunk.push(codeUnit);
+  if (chunk.length >= CHUNK)
+    flushChunk(parts, chunk);
+}
+function pushCodePoint(parts, chunk, cp) {
+  if (cp <= 65535) {
+    pushCodeUnit(parts, chunk, cp);
+    return;
+  }
+  cp -= 65536;
+  pushCodeUnit(parts, chunk, 55296 + (cp >> 10));
+  pushCodeUnit(parts, chunk, 56320 + (cp & 1023));
+}
 function decodeUTF8(bytes) {
   const parts = [];
-  let out = "";
+  const chunk = [];
   let i = 0;
+  if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
+    i = 3;
+  }
   while (i < bytes.length) {
-    const b1 = bytes[i++];
-    if (b1 < 128) {
-      out += String.fromCharCode(b1);
-    } else if (b1 < 224) {
-      const b2 = bytes[i++] & 63;
-      out += String.fromCharCode((b1 & 31) << 6 | b2);
-    } else if (b1 < 240) {
-      const b2 = bytes[i++] & 63;
-      const b3 = bytes[i++] & 63;
-      out += String.fromCharCode((b1 & 15) << 12 | b2 << 6 | b3);
-    } else {
-      const b2 = bytes[i++] & 63;
-      const b3 = bytes[i++] & 63;
-      const b4 = bytes[i++] & 63;
-      let cp = (b1 & 7) << 18 | b2 << 12 | b3 << 6 | b4;
-      cp -= 65536;
-      out += String.fromCharCode(55296 + (cp >> 10 & 1023), 56320 + (cp & 1023));
+    const b1 = bytes[i];
+    if (b1 <= 127) {
+      pushCodeUnit(parts, chunk, b1);
+      i++;
+      continue;
     }
-    if (out.length >= CHUNK) {
-      parts.push(out);
-      out = "";
+    if (b1 < 194 || b1 > 244) {
+      pushCodeUnit(parts, chunk, REPLACEMENT);
+      i++;
+      continue;
+    }
+    if (b1 <= 223) {
+      if (i + 1 >= bytes.length) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const b22 = bytes[i + 1];
+      if ((b22 & 192) !== 128) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const cp2 = (b1 & 31) << 6 | b22 & 63;
+      pushCodeUnit(parts, chunk, cp2);
+      i += 2;
+      continue;
+    }
+    if (b1 <= 239) {
+      if (i + 2 >= bytes.length) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const b22 = bytes[i + 1];
+      const b32 = bytes[i + 2];
+      const valid2 = (b22 & 192) === 128 && (b32 & 192) === 128 && !(b1 === 224 && b22 < 160) && !(b1 === 237 && b22 >= 160);
+      if (!valid2) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const cp2 = (b1 & 15) << 12 | (b22 & 63) << 6 | b32 & 63;
+      pushCodeUnit(parts, chunk, cp2);
+      i += 3;
+      continue;
+    }
+    if (i + 3 >= bytes.length) {
+      pushCodeUnit(parts, chunk, REPLACEMENT);
+      i++;
+      continue;
+    }
+    const b2 = bytes[i + 1];
+    const b3 = bytes[i + 2];
+    const b4 = bytes[i + 3];
+    const valid = (b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128 && !(b1 === 240 && b2 < 144) && !(b1 === 244 && b2 > 143);
+    if (!valid) {
+      pushCodeUnit(parts, chunk, REPLACEMENT);
+      i++;
+      continue;
     }
+    const cp = (b1 & 7) << 18 | (b2 & 63) << 12 | (b3 & 63) << 6 | b4 & 63;
+    pushCodePoint(parts, chunk, cp);
+    i += 4;
   }
-  if (out)
-    parts.push(out);
+  flushChunk(parts, chunk);
   return parts.join("");
 }
 function decodeUTF16LE(bytes) {
-  const len = bytes.length & ~1;
-  if (len === 0)
-    return "";
   const parts = [];
-  const maxUnits = CHUNK;
-  for (let i = 0;i < len; ) {
-    const unitsThis = Math.min(maxUnits, len - i >> 1);
-    const units = new Array(unitsThis);
-    for (let j = 0;j < unitsThis; j++, i += 2) {
-      units[j] = bytes[i] | bytes[i + 1] << 8;
+  const chunk = [];
+  const len = bytes.length;
+  let i = 0;
+  while (i + 1 < len) {
+    const u1 = bytes[i] | bytes[i + 1] << 8;
+    i += 2;
+    if (u1 >= 55296 && u1 <= 56319) {
+      if (i + 1 < len) {
+        const u2 = bytes[i] | bytes[i + 1] << 8;
+        if (u2 >= 56320 && u2 <= 57343) {
+          pushCodeUnit(parts, chunk, u1);
+          pushCodeUnit(parts, chunk, u2);
+          i += 2;
+        } else {
+          pushCodeUnit(parts, chunk, REPLACEMENT);
+        }
+      } else {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+      }
+      continue;
+    }
+    if (u1 >= 56320 && u1 <= 57343) {
+      pushCodeUnit(parts, chunk, REPLACEMENT);
+      continue;
     }
-    parts.push(String.fromCharCode.apply(null, units));
+    pushCodeUnit(parts, chunk, u1);
+  }
+  if (i < len) {
+    pushCodeUnit(parts, chunk, REPLACEMENT);
   }
+  flushChunk(parts, chunk);
   return parts.join("");
 }
 function decodeASCII(bytes) {
@@ -12129,7 +12322,7 @@ function decodeWindows1252(bytes) {
     parts.push(out);
   return parts.join("");
 }
-var WINDOWS_1252_EXTRA, WINDOWS_1252_REVERSE, _utf8Decoder, CHUNK;
+var WINDOWS_1252_EXTRA, WINDOWS_1252_REVERSE, _utf8Decoder, CHUNK, REPLACEMENT = 65533;
 var init_lib2 = __esm(() => {
   WINDOWS_1252_EXTRA = {
     128: "€",
@@ -13637,6 +13830,100 @@ var init_supported = __esm(() => {
 });
 
 // node_modules/file-type/core.js
+function getSafeBound(value, maximum, reason) {
+  if (!Number.isFinite(value) || value < 0 || value > maximum) {
+    throw new ParserHardLimitError(`${reason} has invalid size ${value} (maximum ${maximum} bytes)`);
+  }
+  return value;
+}
+async function safeIgnore(tokenizer, length, { maximumLength = maximumUntrustedSkipSizeInBytes, reason = "skip" } = {}) {
+  const safeLength = getSafeBound(length, maximumLength, reason);
+  await tokenizer.ignore(safeLength);
+}
+async function safeReadBuffer(tokenizer, buffer, options, { maximumLength = buffer.length, reason = "read" } = {}) {
+  const length = options?.length ?? buffer.length;
+  const safeLength = getSafeBound(length, maximumLength, reason);
+  return tokenizer.readBuffer(buffer, {
+    ...options,
+    length: safeLength
+  });
+}
+async function decompressDeflateRawWithLimit(data, { maximumLength = maximumZipEntrySizeInBytes } = {}) {
+  const input = new ReadableStream({
+    start(controller) {
+      controller.enqueue(data);
+      controller.close();
+    }
+  });
+  const output = input.pipeThrough(new DecompressionStream("deflate-raw"));
+  const reader = output.getReader();
+  const chunks = [];
+  let totalLength = 0;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      totalLength += value.length;
+      if (totalLength > maximumLength) {
+        await reader.cancel();
+        throw new Error(`ZIP entry decompressed data exceeds ${maximumLength} bytes`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const uncompressedData = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    uncompressedData.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return uncompressedData;
+}
+function createByteLimitedReadableStream(stream, maximumBytes) {
+  const reader = stream.getReader();
+  let emittedBytes = 0;
+  let sourceDone = false;
+  let sourceCanceled = false;
+  const cancelSource = async (reason) => {
+    if (sourceDone || sourceCanceled) {
+      return;
+    }
+    sourceCanceled = true;
+    await reader.cancel(reason);
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      if (emittedBytes >= maximumBytes) {
+        controller.close();
+        await cancelSource();
+        return;
+      }
+      const { done, value } = await reader.read();
+      if (done || !value) {
+        sourceDone = true;
+        controller.close();
+        return;
+      }
+      const remainingBytes = maximumBytes - emittedBytes;
+      if (value.length > remainingBytes) {
+        controller.enqueue(value.subarray(0, remainingBytes));
+        emittedBytes += remainingBytes;
+        controller.close();
+        await cancelSource();
+        return;
+      }
+      controller.enqueue(value);
+      emittedBytes += value.length;
+    },
+    async cancel(reason) {
+      await cancelSource(reason);
+    }
+  });
+}
 async function fileTypeFromBuffer(input, options) {
   return new FileTypeParser(options).fromBuffer(input);
 }
@@ -13790,29 +14077,166 @@ function _check2(buffer, headers, options) {
   }
   return true;
 }
+function normalizeSampleSize(sampleSize) {
+  if (!Number.isFinite(sampleSize)) {
+    return reasonableDetectionSizeInBytes;
+  }
+  return Math.max(1, Math.trunc(sampleSize));
+}
+function normalizeMpegOffsetTolerance(mpegOffsetTolerance) {
+  if (!Number.isFinite(mpegOffsetTolerance)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(maximumMpegOffsetTolerance, Math.trunc(mpegOffsetTolerance)));
+}
+function getKnownFileSizeOrMaximum(fileSize) {
+  if (!Number.isFinite(fileSize)) {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  return Math.max(0, fileSize);
+}
+function hasUnknownFileSize(tokenizer) {
+  const fileSize = tokenizer.fileInfo.size;
+  return !Number.isFinite(fileSize) || fileSize === Number.MAX_SAFE_INTEGER;
+}
+function hasExceededUnknownSizeScanBudget(tokenizer, startOffset, maximumBytes) {
+  return hasUnknownFileSize(tokenizer) && tokenizer.position - startOffset > maximumBytes;
+}
+function isRecoverableZipError(error2) {
+  if (error2 instanceof EndOfStreamError) {
+    return true;
+  }
+  if (error2 instanceof ParserHardLimitError) {
+    return true;
+  }
+  if (!(error2 instanceof Error)) {
+    return false;
+  }
+  if (recoverableZipErrorMessages.has(error2.message)) {
+    return true;
+  }
+  if (error2 instanceof TypeError && recoverableZipErrorCodes.has(error2.code)) {
+    return true;
+  }
+  for (const prefix of recoverableZipErrorMessagePrefixes) {
+    if (error2.message.startsWith(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
+function canReadZipEntryForDetection(zipHeader, maximumSize = maximumZipEntrySizeInBytes) {
+  const sizes = [zipHeader.compressedSize, zipHeader.uncompressedSize];
+  for (const size of sizes) {
+    if (!Number.isFinite(size) || size < 0 || size > maximumSize) {
+      return false;
+    }
+  }
+  return true;
+}
+function createOpenXmlZipDetectionState() {
+  return {
+    hasContentTypesEntry: false,
+    hasParsedContentTypesEntry: false,
+    isParsingContentTypes: false,
+    hasUnparseableContentTypes: false,
+    hasWordDirectory: false,
+    hasPresentationDirectory: false,
+    hasSpreadsheetDirectory: false,
+    hasThreeDimensionalModelEntry: false
+  };
+}
+function updateOpenXmlZipDetectionStateFromFilename(openXmlState, filename) {
+  if (filename.startsWith("word/")) {
+    openXmlState.hasWordDirectory = true;
+  }
+  if (filename.startsWith("ppt/")) {
+    openXmlState.hasPresentationDirectory = true;
+  }
+  if (filename.startsWith("xl/")) {
+    openXmlState.hasSpreadsheetDirectory = true;
+  }
+  if (filename.startsWith("3D/") && filename.endsWith(".model")) {
+    openXmlState.hasThreeDimensionalModelEntry = true;
+  }
+}
+function getOpenXmlFileTypeFromZipEntries(openXmlState) {
+  if (!openXmlState.hasContentTypesEntry || openXmlState.hasUnparseableContentTypes || openXmlState.isParsingContentTypes || openXmlState.hasParsedContentTypesEntry) {
+    return;
+  }
+  if (openXmlState.hasWordDirectory) {
+    return {
+      ext: "docx",
+      mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    };
+  }
+  if (openXmlState.hasPresentationDirectory) {
+    return {
+      ext: "pptx",
+      mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    };
+  }
+  if (openXmlState.hasSpreadsheetDirectory) {
+    return {
+      ext: "xlsx",
+      mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    };
+  }
+  if (openXmlState.hasThreeDimensionalModelEntry) {
+    return {
+      ext: "3mf",
+      mime: "model/3mf"
+    };
+  }
+}
+function getOpenXmlMimeTypeFromContentTypesXml(xmlContent) {
+  const endPosition = xmlContent.indexOf('.main+xml"');
+  if (endPosition === -1) {
+    const mimeType = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml";
+    if (xmlContent.includes(`ContentType="${mimeType}"`)) {
+      return mimeType;
+    }
+    return;
+  }
+  const truncatedContent = xmlContent.slice(0, endPosition);
+  const firstQuotePosition = truncatedContent.lastIndexOf('"');
+  return truncatedContent.slice(firstQuotePosition + 1);
+}
 async function fileTypeFromTokenizer(tokenizer, options) {
   return new FileTypeParser(options).fromTokenizer(tokenizer);
 }
 
 class FileTypeParser {
   constructor(options) {
+    const normalizedMpegOffsetTolerance = normalizeMpegOffsetTolerance(options?.mpegOffsetTolerance);
     this.options = {
-      mpegOffsetTolerance: 0,
-      ...options
+      ...options,
+      mpegOffsetTolerance: normalizedMpegOffsetTolerance
     };
     this.detectors = [
-      ...options?.customDetectors ?? [],
+      ...this.options.customDetectors ?? [],
       { id: "core", detect: this.detectConfident },
       { id: "core.imprecise", detect: this.detectImprecise }
     ];
     this.tokenizerOptions = {
-      abortSignal: options?.signal
+      abortSignal: this.options.signal
     };
   }
   async fromTokenizer(tokenizer) {
     const initialPosition = tokenizer.position;
     for (const detector of this.detectors) {
-      const fileType = await detector.detect(tokenizer);
+      let fileType;
+      try {
+        fileType = await detector.detect(tokenizer);
+      } catch (error2) {
+        if (error2 instanceof EndOfStreamError) {
+          return;
+        }
+        if (error2 instanceof ParserHardLimitError) {
+          return;
+        }
+        throw error2;
+      }
       if (fileType) {
         return fileType;
       }
@@ -13848,7 +14272,7 @@ class FileTypeParser {
     }
   }
   async toDetectionStream(stream, options) {
-    const { sampleSize = reasonableDetectionSizeInBytes } = options;
+    const sampleSize = normalizeSampleSize(options?.sampleSize ?? reasonableDetectionSizeInBytes);
     let detectedFileType;
     let firstChunk;
     const reader = stream.getReader({ mode: "byob" });
@@ -13950,7 +14374,7 @@ class FileTypeParser {
       };
     }
     if (this.check([239, 187, 191])) {
-      this.tokenizer.ignore(3);
+      await this.tokenizer.ignore(3);
       return this.detectConfident(tokenizer);
     }
     if (this.check([71, 73, 70])) {
@@ -13967,26 +14391,21 @@ class FileTypeParser {
     }
     if (this.check([31, 139, 8])) {
       const gzipHandler = new GzipHandler(tokenizer);
-      const stream = gzipHandler.inflate();
-      let shouldCancelStream = true;
+      const limitedInflatedStream = createByteLimitedReadableStream(gzipHandler.inflate(), maximumNestedGzipDetectionSizeInBytes);
+      let compressedFileType;
       try {
-        let compressedFileType;
-        try {
-          compressedFileType = await this.fromStream(stream);
-        } catch {
-          shouldCancelStream = false;
-        }
-        if (compressedFileType && compressedFileType.ext === "tar") {
-          return {
-            ext: "tar.gz",
-            mime: "application/gzip"
-          };
-        }
-      } finally {
-        if (shouldCancelStream) {
-          await stream.cancel();
+        compressedFileType = await this.fromStream(limitedInflatedStream);
+      } catch (error2) {
+        if (error2?.name === "AbortError") {
+          throw error2;
         }
       }
+      if (compressedFileType?.ext === "tar") {
+        return {
+          ext: "tar.gz",
+          mime: "application/gzip"
+        };
+      }
       return {
         ext: "gz",
         mime: "application/gzip"
@@ -13999,15 +14418,35 @@ class FileTypeParser {
       };
     }
     if (this.checkString("ID3")) {
-      await tokenizer.ignore(6);
+      await safeIgnore(tokenizer, 6, {
+        maximumLength: 6,
+        reason: "ID3 header prefix"
+      });
       const id3HeaderLength = await tokenizer.readToken(uint32SyncSafeToken);
+      const isUnknownFileSize = hasUnknownFileSize(tokenizer);
+      if (!Number.isFinite(id3HeaderLength) || id3HeaderLength < 0 || isUnknownFileSize && id3HeaderLength > maximumId3HeaderSizeInBytes) {
+        return;
+      }
       if (tokenizer.position + id3HeaderLength > tokenizer.fileInfo.size) {
+        if (isUnknownFileSize) {
+          return;
+        }
         return {
           ext: "mp3",
           mime: "audio/mpeg"
         };
       }
-      await tokenizer.ignore(id3HeaderLength);
+      try {
+        await safeIgnore(tokenizer, id3HeaderLength, {
+          maximumLength: isUnknownFileSize ? maximumId3HeaderSizeInBytes : tokenizer.fileInfo.size,
+          reason: "ID3 payload"
+        });
+      } catch (error2) {
+        if (error2 instanceof EndOfStreamError) {
+          return;
+        }
+        throw error2;
+      }
       return this.fromTokenizer(tokenizer);
     }
     if (this.checkString("MP+")) {
@@ -14072,67 +14511,88 @@ class FileTypeParser {
     }
     if (this.check([80, 75, 3, 4])) {
       let fileType;
-      await new ZipHandler(tokenizer).unzip((zipHeader) => {
-        switch (zipHeader.filename) {
-          case "META-INF/mozilla.rsa":
-            fileType = {
-              ext: "xpi",
-              mime: "application/x-xpinstall"
-            };
-            return {
-              stop: true
-            };
-          case "META-INF/MANIFEST.MF":
-            fileType = {
-              ext: "jar",
-              mime: "application/java-archive"
-            };
-            return {
-              stop: true
-            };
-          case "mimetype":
+      const openXmlState = createOpenXmlZipDetectionState();
+      try {
+        await new ZipHandler(tokenizer).unzip((zipHeader) => {
+          updateOpenXmlZipDetectionStateFromFilename(openXmlState, zipHeader.filename);
+          const isOpenXmlContentTypesEntry = zipHeader.filename === "[Content_Types].xml";
+          const openXmlFileTypeFromEntries = getOpenXmlFileTypeFromZipEntries(openXmlState);
+          if (!isOpenXmlContentTypesEntry && openXmlFileTypeFromEntries) {
+            fileType = openXmlFileTypeFromEntries;
             return {
-              async handler(fileData) {
-                const mimeType = new TextDecoder("utf-8").decode(fileData).trim();
-                fileType = getFileTypeFromMimeType(mimeType);
-              },
               stop: true
             };
-          case "[Content_Types].xml":
-            return {
-              async handler(fileData) {
-                let xmlContent = new TextDecoder("utf-8").decode(fileData);
-                const endPos = xmlContent.indexOf('.main+xml"');
-                if (endPos === -1) {
-                  const mimeType = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml";
-                  if (xmlContent.includes(`ContentType="${mimeType}"`)) {
+          }
+          switch (zipHeader.filename) {
+            case "META-INF/mozilla.rsa":
+              fileType = {
+                ext: "xpi",
+                mime: "application/x-xpinstall"
+              };
+              return {
+                stop: true
+              };
+            case "META-INF/MANIFEST.MF":
+              fileType = {
+                ext: "jar",
+                mime: "application/java-archive"
+              };
+              return {
+                stop: true
+              };
+            case "mimetype":
+              if (!canReadZipEntryForDetection(zipHeader)) {
+                return {};
+              }
+              return {
+                async handler(fileData) {
+                  const mimeType = new TextDecoder("utf-8").decode(fileData).trim();
+                  fileType = getFileTypeFromMimeType(mimeType);
+                },
+                stop: true
+              };
+            case "[Content_Types].xml": {
+              openXmlState.hasContentTypesEntry = true;
+              const maximumContentTypesEntrySize = hasUnknownFileSize(tokenizer) ? maximumZipEntrySizeInBytes : Number.MAX_SAFE_INTEGER;
+              if (!canReadZipEntryForDetection(zipHeader, maximumContentTypesEntrySize)) {
+                openXmlState.hasUnparseableContentTypes = true;
+                return {};
+              }
+              openXmlState.isParsingContentTypes = true;
+              return {
+                async handler(fileData) {
+                  const xmlContent = new TextDecoder("utf-8").decode(fileData);
+                  const mimeType = getOpenXmlMimeTypeFromContentTypesXml(xmlContent);
+                  if (mimeType) {
                     fileType = getFileTypeFromMimeType(mimeType);
                   }
-                } else {
-                  xmlContent = xmlContent.slice(0, Math.max(0, endPos));
-                  const firstPos = xmlContent.lastIndexOf('"');
-                  const mimeType = xmlContent.slice(Math.max(0, firstPos + 1));
-                  fileType = getFileTypeFromMimeType(mimeType);
-                }
-              },
-              stop: true
-            };
-          default:
-            if (/classes\d*\.dex/.test(zipHeader.filename)) {
-              fileType = {
-                ext: "apk",
-                mime: "application/vnd.android.package-archive"
+                  openXmlState.hasParsedContentTypesEntry = true;
+                  openXmlState.isParsingContentTypes = false;
+                },
+                stop: true
               };
-              return { stop: true };
             }
-            return {};
-        }
-      }).catch((error2) => {
-        if (!(error2 instanceof EndOfStreamError)) {
+            default:
+              if (/classes\d*\.dex/.test(zipHeader.filename)) {
+                fileType = {
+                  ext: "apk",
+                  mime: "application/vnd.android.package-archive"
+                };
+                return { stop: true };
+              }
+              return {};
+          }
+        });
+      } catch (error2) {
+        if (!isRecoverableZipError(error2)) {
           throw error2;
         }
-      });
-      return fileType ?? {
+        if (openXmlState.isParsingContentTypes) {
+          openXmlState.isParsingContentTypes = false;
+          openXmlState.hasUnparseableContentTypes = true;
+        }
+      }
+      return fileType ?? getOpenXmlFileTypeFromZipEntries(openXmlState) ?? {
         ext: "zip",
         mime: "application/zip"
       };
@@ -14282,7 +14742,10 @@ class FileTypeParser {
           mask >>= 1;
         }
         const id = new Uint8Array(ic + 1);
-        await tokenizer.readBuffer(id);
+        await safeReadBuffer(tokenizer, id, undefined, {
+          maximumLength: id.length,
+          reason: "EBML field"
+        });
         return id;
       }
       async function readElement() {
@@ -14298,18 +14761,33 @@ class FileTypeParser {
         };
       }
       async function readChildren(children) {
+        let ebmlElementCount = 0;
         while (children > 0) {
+          ebmlElementCount++;
+          if (ebmlElementCount > maximumEbmlElementCount) {
+            return;
+          }
           const element = await readElement();
           if (element.id === 17026) {
-            const rawValue = await tokenizer.readToken(new StringType2(element.len));
+            if (element.len > maximumEbmlDocumentTypeSizeInBytes) {
+              return;
+            }
+            const documentTypeLength = getSafeBound(element.len, maximumEbmlDocumentTypeSizeInBytes, "EBML DocType");
+            const rawValue = await tokenizer.readToken(new StringType2(documentTypeLength));
             return rawValue.replaceAll(/\00.*$/g, "");
           }
-          await tokenizer.ignore(element.len);
+          if (hasUnknownFileSize(tokenizer) && (!Number.isFinite(element.len) || element.len < 0 || element.len > maximumEbmlElementPayloadSizeInBytes)) {
+            return;
+          }
+          await safeIgnore(tokenizer, element.len, {
+            maximumLength: hasUnknownFileSize(tokenizer) ? maximumEbmlElementPayloadSizeInBytes : tokenizer.fileInfo.size,
+            reason: "EBML payload"
+          });
           --children;
         }
       }
-      const re = await readElement();
-      const documentType = await readChildren(re.len);
+      const rootElement = await readElement();
+      const documentType = await readChildren(rootElement.len);
       switch (documentType) {
         case "webm":
           return {
@@ -14572,6 +15050,14 @@ class FileTypeParser {
       };
     }
     if (this.check([137, 80, 78, 71, 13, 10, 26, 10])) {
+      const pngFileType = {
+        ext: "png",
+        mime: "image/png"
+      };
+      const apngFileType = {
+        ext: "apng",
+        mime: "image/apng"
+      };
       await tokenizer.ignore(8);
       async function readChunkHeader() {
         return {
@@ -14579,30 +15065,39 @@ class FileTypeParser {
           type: await tokenizer.readToken(new StringType2(4, "latin1"))
         };
       }
+      const isUnknownPngStream = hasUnknownFileSize(tokenizer);
+      const pngScanStart = tokenizer.position;
       do {
+        if (hasExceededUnknownSizeScanBudget(tokenizer, pngScanStart, maximumPngChunkSizeInBytes)) {
+          break;
+        }
         const chunk = await readChunkHeader();
         if (chunk.length < 0) {
           return;
         }
         switch (chunk.type) {
           case "IDAT":
-            return {
-              ext: "png",
-              mime: "image/png"
-            };
+            return pngFileType;
           case "acTL":
-            return {
-              ext: "apng",
-              mime: "image/apng"
-            };
+            return apngFileType;
           default:
-            await tokenizer.ignore(chunk.length + 4);
+            if (isUnknownPngStream && chunk.length > maximumPngChunkSizeInBytes) {
+              return;
+            }
+            try {
+              await safeIgnore(tokenizer, chunk.length + 4, {
+                maximumLength: isUnknownPngStream ? maximumPngChunkSizeInBytes + 4 : tokenizer.fileInfo.size,
+                reason: "PNG chunk payload"
+              });
+            } catch (error2) {
+              if (!isUnknownPngStream && (error2 instanceof ParserHardLimitError || error2 instanceof EndOfStreamError)) {
+                return pngFileType;
+              }
+              throw error2;
+            }
         }
       } while (tokenizer.position + 8 < tokenizer.fileInfo.size);
-      return {
-        ext: "png",
-        mime: "image/png"
-      };
+      return pngFileType;
     }
     if (this.check([65, 82, 82, 79, 87, 49, 0, 0])) {
       return {
@@ -14722,36 +15217,76 @@ class FileTypeParser {
       };
     }
     if (this.check([48, 38, 178, 117, 142, 102, 207, 17, 166, 217])) {
-      async function readHeader() {
-        const guid2 = new Uint8Array(16);
-        await tokenizer.readBuffer(guid2);
-        return {
-          id: guid2,
-          size: Number(await tokenizer.readToken(UINT64_LE))
-        };
-      }
-      await tokenizer.ignore(30);
-      while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
-        const header = await readHeader();
-        let payload = header.size - 24;
-        if (_check2(header.id, [145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101])) {
-          const typeId = new Uint8Array(16);
-          payload -= await tokenizer.readBuffer(typeId);
-          if (_check2(typeId, [64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
-            return {
-              ext: "asf",
-              mime: "audio/x-ms-asf"
-            };
+      let isMalformedAsf = false;
+      try {
+        async function readHeader() {
+          const guid2 = new Uint8Array(16);
+          await safeReadBuffer(tokenizer, guid2, undefined, {
+            maximumLength: guid2.length,
+            reason: "ASF header GUID"
+          });
+          return {
+            id: guid2,
+            size: Number(await tokenizer.readToken(UINT64_LE))
+          };
+        }
+        await safeIgnore(tokenizer, 30, {
+          maximumLength: 30,
+          reason: "ASF header prelude"
+        });
+        const isUnknownFileSize = hasUnknownFileSize(tokenizer);
+        const asfHeaderScanStart = tokenizer.position;
+        while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
+          if (hasExceededUnknownSizeScanBudget(tokenizer, asfHeaderScanStart, maximumUntrustedSkipSizeInBytes)) {
+            break;
           }
-          if (_check2(typeId, [192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
-            return {
-              ext: "asf",
-              mime: "video/x-ms-asf"
-            };
+          const previousPosition = tokenizer.position;
+          const header = await readHeader();
+          let payload = header.size - 24;
+          if (!Number.isFinite(payload) || payload < 0) {
+            isMalformedAsf = true;
+            break;
           }
-          break;
+          if (_check2(header.id, [145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101])) {
+            const typeId = new Uint8Array(16);
+            payload -= await safeReadBuffer(tokenizer, typeId, undefined, {
+              maximumLength: typeId.length,
+              reason: "ASF stream type GUID"
+            });
+            if (_check2(typeId, [64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
+              return {
+                ext: "asf",
+                mime: "audio/x-ms-asf"
+              };
+            }
+            if (_check2(typeId, [192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
+              return {
+                ext: "asf",
+                mime: "video/x-ms-asf"
+              };
+            }
+            break;
+          }
+          await safeIgnore(tokenizer, payload, {
+            maximumLength: isUnknownFileSize ? maximumUntrustedSkipSizeInBytes : tokenizer.fileInfo.size,
+            reason: "ASF header payload"
+          });
+          if (tokenizer.position <= previousPosition) {
+            isMalformedAsf = true;
+            break;
+          }
+        }
+      } catch (error2) {
+        if (error2 instanceof EndOfStreamError || error2 instanceof ParserHardLimitError) {
+          if (hasUnknownFileSize(tokenizer)) {
+            isMalformedAsf = true;
+          }
+        } else {
+          throw error2;
         }
-        await tokenizer.ignore(payload);
+      }
+      if (isMalformedAsf) {
+        return;
       }
       return {
         ext: "asf",
@@ -15002,7 +15537,8 @@ class FileTypeParser {
   };
   detectImprecise = async (tokenizer) => {
     this.buffer = new Uint8Array(reasonableDetectionSizeInBytes);
-    await tokenizer.peekBuffer(this.buffer, { length: Math.min(8, tokenizer.fileInfo.size), mayBeLess: true });
+    const fileSize = getKnownFileSizeOrMaximum(tokenizer.fileInfo.size);
+    await tokenizer.peekBuffer(this.buffer, { length: Math.min(8, fileSize), mayBeLess: true });
     if (this.check([0, 0, 1, 186]) || this.check([0, 0, 1, 179])) {
       return {
         ext: "mpg",
@@ -15027,7 +15563,7 @@ class FileTypeParser {
         mime: "image/x-icon"
       };
     }
-    await tokenizer.peekBuffer(this.buffer, { length: Math.min(2 + this.options.mpegOffsetTolerance, tokenizer.fileInfo.size), mayBeLess: true });
+    await tokenizer.peekBuffer(this.buffer, { length: Math.min(2 + this.options.mpegOffsetTolerance, fileSize), mayBeLess: true });
     if (this.buffer.length >= 2 + this.options.mpegOffsetTolerance) {
       for (let depth = 0;depth <= this.options.mpegOffsetTolerance; ++depth) {
         const type = this.scanMpeg(depth);
@@ -15039,7 +15575,7 @@ class FileTypeParser {
   };
   async readTiffTag(bigEndian) {
     const tagId = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
-    this.tokenizer.ignore(10);
+    await this.tokenizer.ignore(10);
     switch (tagId) {
       case 50341:
         return {
@@ -15056,6 +15592,9 @@ class FileTypeParser {
   }
   async readTiffIFD(bigEndian) {
     const numberOfTags = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
+    if (hasUnknownFileSize(this.tokenizer) && 2 + numberOfTags * 12 > maximumTiffIfdOffsetInBytes) {
+      return;
+    }
     for (let n = 0;n < numberOfTags; ++n) {
       const fileType = await this.readTiffTag(bigEndian);
       if (fileType) {
@@ -15064,6 +15603,10 @@ class FileTypeParser {
     }
   }
   async readTiffHeader(bigEndian) {
+    const tiffFileType = {
+      ext: "tif",
+      mime: "image/tiff"
+    };
     const version2 = (bigEndian ? UINT16_BE : UINT16_LE).get(this.buffer, 2);
     const ifdOffset = (bigEndian ? UINT32_BE : UINT32_LE).get(this.buffer, 4);
     if (version2 === 42) {
@@ -15085,18 +15628,31 @@ class FileTypeParser {
           }
         }
       }
-      await this.tokenizer.ignore(ifdOffset);
-      const fileType = await this.readTiffIFD(bigEndian);
-      return fileType ?? {
-        ext: "tif",
-        mime: "image/tiff"
-      };
+      const maximumTiffOffset = hasUnknownFileSize(this.tokenizer) ? maximumTiffIfdOffsetInBytes : this.tokenizer.fileInfo.size;
+      try {
+        await safeIgnore(this.tokenizer, ifdOffset, {
+          maximumLength: maximumTiffOffset,
+          reason: "TIFF IFD offset"
+        });
+      } catch (error2) {
+        if (error2 instanceof EndOfStreamError) {
+          return;
+        }
+        throw error2;
+      }
+      let fileType;
+      try {
+        fileType = await this.readTiffIFD(bigEndian);
+      } catch (error2) {
+        if (error2 instanceof EndOfStreamError) {
+          return;
+        }
+        throw error2;
+      }
+      return fileType ?? tiffFileType;
     }
     if (version2 === 43) {
-      return {
-        ext: "tif",
-        mime: "image/tiff"
-      };
+      return tiffFileType;
     }
   }
   scanMpeg(offset) {
@@ -15134,7 +15690,7 @@ class FileTypeParser {
     }
   }
 }
-var reasonableDetectionSizeInBytes = 4100, supportedExtensions, supportedMimeTypes;
+var reasonableDetectionSizeInBytes = 4100, maximumMpegOffsetTolerance, maximumZipEntrySizeInBytes, maximumUntrustedSkipSizeInBytes, maximumNestedGzipDetectionSizeInBytes, maximumId3HeaderSizeInBytes, maximumEbmlDocumentTypeSizeInBytes = 64, maximumEbmlElementPayloadSizeInBytes, maximumEbmlElementCount = 256, maximumPngChunkSizeInBytes, maximumTiffIfdOffsetInBytes, recoverableZipErrorMessages, recoverableZipErrorMessagePrefixes, recoverableZipErrorCodes, ParserHardLimitError, supportedExtensions, supportedMimeTypes;
 var init_core2 = __esm(() => {
   init_lib3();
   init_core();
@@ -15142,6 +15698,41 @@ var init_core2 = __esm(() => {
   init_uint8array_extras();
   init_util();
   init_supported();
+  maximumMpegOffsetTolerance = reasonableDetectionSizeInBytes - 2;
+  maximumZipEntrySizeInBytes = 1024 * 1024;
+  maximumUntrustedSkipSizeInBytes = 16 * 1024 * 1024;
+  maximumNestedGzipDetectionSizeInBytes = maximumUntrustedSkipSizeInBytes;
+  maximumId3HeaderSizeInBytes = maximumUntrustedSkipSizeInBytes;
+  maximumEbmlElementPayloadSizeInBytes = maximumUntrustedSkipSizeInBytes;
+  maximumPngChunkSizeInBytes = maximumUntrustedSkipSizeInBytes;
+  maximumTiffIfdOffsetInBytes = maximumUntrustedSkipSizeInBytes;
+  recoverableZipErrorMessages = new Set([
+    "Unexpected signature",
+    "Encrypted ZIP",
+    "Expected Central-File-Header signature"
+  ]);
+  recoverableZipErrorMessagePrefixes = [
+    "Unsupported ZIP compression method:",
+    "ZIP entry decompressed data exceeds "
+  ];
+  recoverableZipErrorCodes = new Set([
+    "Z_BUF_ERROR",
+    "Z_DATA_ERROR",
+    "ERR_INVALID_STATE"
+  ]);
+  ParserHardLimitError = class ParserHardLimitError extends Error {
+  };
+  ZipHandler.prototype.inflate = async function(zipHeader, fileData, callback) {
+    if (zipHeader.compressedMethod === 0) {
+      return callback(fileData);
+    }
+    if (zipHeader.compressedMethod !== 8) {
+      throw new Error(`Unsupported ZIP compression method: ${zipHeader.compressedMethod}`);
+    }
+    const maximumLength = hasUnknownFileSize(this.tokenizer) ? maximumZipEntrySizeInBytes : Number.MAX_SAFE_INTEGER;
+    const uncompressedData = await decompressDeflateRawWithLimit(fileData, { maximumLength });
+    return callback(uncompressedData);
+  };
   supportedExtensions = new Set(extensions);
   supportedMimeTypes = new Set(mimeTypes);
 });
@@ -15161,6 +15752,12 @@ __export(exports_file_type, {
 });
 import { ReadableStream as WebReadableStream } from "node:stream/web";
 import { pipeline as pipeline2, PassThrough, Readable } from "node:stream";
+function isTokenizerStreamBoundsError(error2) {
+  if (!(error2 instanceof RangeError) || error2.message !== "offset is out of bounds" || typeof error2.stack !== "string") {
+    return false;
+  }
+  return /strtok3[/\\]lib[/\\]stream[/\\]/.test(error2.stack);
+}
 async function fileTypeFromFile(path2, options) {
   return new FileTypeParser2(options).fromFile(path2, options);
 }
@@ -15180,6 +15777,11 @@ var init_file_type = __esm(() => {
       const tokenizer = await (stream instanceof WebReadableStream ? fromWebStream(stream, this.tokenizerOptions) : fromStream2(stream, this.tokenizerOptions));
       try {
         return await super.fromTokenizer(tokenizer);
+      } catch (error2) {
+        if (isTokenizerStreamBoundsError(error2)) {
+          return;
+        }
+        throw error2;
       } finally {
         await tokenizer.close();
       }
@@ -15196,7 +15798,7 @@ var init_file_type = __esm(() => {
       if (!(readableStream instanceof Readable)) {
         return super.toDetectionStream(readableStream, options);
       }
-      const { sampleSize = reasonableDetectionSizeInBytes } = options;
+      const sampleSize = normalizeSampleSize(options.sampleSize ?? reasonableDetectionSizeInBytes);
       return new Promise((resolve, reject) => {
         readableStream.on("error", reject);
         readableStream.once("readable", () => {
@@ -16131,10 +16733,14 @@ var isWsl = () => {
     return true;
   }
   try {
-    return fs6.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
-  } catch {
-    return false;
+    if (fs6.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+      return !isInsideContainer();
+    }
+  } catch {}
+  if (fs6.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs6.existsSync("/run/WSL")) {
+    return !isInsideContainer();
   }
+  return false;
 }, is_wsl_default;
 var init_is_wsl = __esm(() => {
   init_is_inside_container();
@@ -16340,11 +16946,11 @@ async function defaultBrowser(_execFileAsync = execFileAsync3) {
     throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
   }
   const { id } = match.groups;
-  const browser = windowsBrowserProgIds[id];
-  if (!browser) {
-    throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
-  }
-  return browser;
+  const dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? undefined : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? undefined : id.slice(0, hyphenIndex);
+  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
 }
 var execFileAsync3, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
 var init_windows = __esm(() => {
@@ -24081,11 +24687,12 @@ init_constants();
 // src/lib/client/index.ts
 init_constants();
 init_errors();
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
 
 // src/lib/client/core.ts
 init_errors();
 init_constants();
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 
 // src/config/endpoints.ts
 var EP = {
@@ -24330,6 +24937,10 @@ function createLogger(bindings = {}) {
 }
 var logger = createLogger();
 // src/lib/client/core.ts
+var orgContextStorage = new AsyncLocalStorage2;
+function runWithOrgContext(client, fn) {
+  return orgContextStorage.run({ orgId: client.getDefaultOrgId() }, fn);
+}
 var apiLogger = logger.withCategory(LogCategory.API);
 var oidcTokenCache = new Map;
 var OIDC_EXPIRY_BUFFER_MS = 5 * 60 * 1000;
@@ -24525,8 +25136,16 @@ class KanboClient {
   }
   setOrganization(orgId) {
     this.orgId = orgId;
+    const ctx = orgContextStorage.getStore();
+    if (ctx) {
+      ctx.orgId = orgId;
+    }
   }
   getOrganizationId() {
+    const ctx = orgContextStorage.getStore();
+    return ctx ? ctx.orgId : this.orgId;
+  }
+  getDefaultOrgId() {
     return this.orgId;
   }
   async validateAndGetContext() {
@@ -25025,7 +25644,7 @@ KanboClient.prototype.batchMoveTickets = async function(projectId, ticketIds, st
 };
 
 // src/lib/client/index.ts
-var requestClientStorage = new AsyncLocalStorage2;
+var requestClientStorage = new AsyncLocalStorage3;
 function runWithClient(client, fn) {
   return requestClientStorage.run(client, fn);
 }
@@ -29893,42 +30512,46 @@ function createMCPServer() {
         isError: true
       };
     }
-    try {
-      const result = await handler(args || {});
-      return {
-        content: [
-          {
-            type: "text",
-            text: formatToolResult(result)
-          }
-        ],
-        isError: !result.success
-      };
-    } catch (error2) {
-      serverLogger.error({ err: error2, toolName: name }, "Tool execution failed");
-      return {
-        content: [
-          {
-            type: "text",
-            text: formatToolResult(errorResultFromError(error2))
-          }
-        ],
-        isError: true
-      };
-    }
+    const client = getKanboClient();
+    return runWithOrgContext(client, async () => {
+      try {
+        const result = await handler(args || {});
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatToolResult(result)
+            }
+          ],
+          isError: !result.success
+        };
+      } catch (error2) {
+        serverLogger.error({ err: error2, toolName: name }, "Tool execution failed");
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatToolResult(errorResultFromError(error2))
+            }
+          ],
+          isError: true
+        };
+      }
+    });
   });
   return server;
 }
+var STARTUP_AUTH_TIMEOUT_MS = 15000;
 async function startStdioServer() {
-  logToolRegistration();
-  serverLogger.info("Starting in stdio mode");
   if (!CONFIG.KANBO_API_KEY) {
-    serverLogger.fatal("KANBO_API_KEY environment variable is required");
-    process.exit(1);
+    throw new Error('KANBO_API_KEY is required. Run "kanbo-mcp login" to authenticate, ' + "or set the KANBO_API_KEY environment variable.");
   }
   try {
     const client = getKanboClient();
-    const authContext = await client.validateAndGetContext();
+    const authContext = await Promise.race([
+      client.validateAndGetContext(),
+      new Promise((_, reject) => setTimeout(() => reject(new Error(`Authentication timed out after ${STARTUP_AUTH_TIMEOUT_MS / 1000}s. ` + "Check your network connection and API URL.")), STARTUP_AUTH_TIMEOUT_MS))
+    ]);
     serverLogger.info({ email: authContext.email }, "Authenticated");
     serverLogger.info({ organizations: authContext.organizations.map((o) => o.name) }, "Available organizations");
     if (client.getOrganizationId()) {
@@ -29937,11 +30560,19 @@ async function startStdioServer() {
     }
   } catch (error2) {
     serverLogger.fatal({ err: error2 }, "Authentication failed");
-    process.exit(1);
+    throw error2;
   }
   const server = createMCPServer();
   const transport = new StdioServerTransport;
+  const shutdown = async () => {
+    serverLogger.info("Shutting down...");
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
   await server.connect(transport);
+  logToolRegistration();
   serverLogger.info("Server running on stdio");
 }
 
@@ -32916,7 +33547,6 @@ var Type = exports_type3;
 
 // node_modules/elysia/dist/index.mjs
 var import_fast_decode_uri_component4 = __toESM(require_fast_decode_uri_component(), 1);
-
 // node_modules/@sinclair/typebox/build/esm/errors/function.mjs
 function DefaultErrorFunction(error2) {
   switch (error2.errorType) {
@@ -34194,6 +34824,7 @@ function Errors(...args) {
   const iterator = args.length === 3 ? Visit6(args[0], args[1], "", args[2]) : Visit6(args[0], [], "", args[1]);
   return new ValueErrorIterator(iterator);
 }
+
 // node_modules/@sinclair/typebox/build/esm/value/assert/assert.mjs
 var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
   if (kind === "m")
@@ -36810,6 +37441,15 @@ var TypeCompiler;
 
 // node_modules/elysia/dist/universal/utils.mjs
 var isBun = typeof Bun < "u";
+function isCloudflareWorker() {
+  try {
+    if (typeof caches < "u" && typeof caches.default < "u" || typeof WebSocketPair < "u")
+      return true;
+  } catch {
+    return false;
+  }
+  return false;
+}
 
 // node_modules/elysia/dist/universal/file.mjs
 var mime = {
@@ -36939,7 +37579,6 @@ class ElysiaFile {
 }
 
 // node_modules/elysia/dist/utils.mjs
-var hasHeaderShorthand = "toJSON" in new Headers;
 var replaceUrlPath = (url, pathname) => {
   const pathStartIndex = url.indexOf("/", 11), queryIndex = url.indexOf("?", pathStartIndex);
   return queryIndex === -1 ? `${url.slice(0, pathStartIndex)}${pathname.charCodeAt(0) === 47 ? "" : "/"}${pathname}` : `${url.slice(0, pathStartIndex)}${pathname.charCodeAt(0) === 47 ? "" : "/"}${pathname}${url.slice(queryIndex)}`;
@@ -37071,8 +37710,7 @@ var lifeCycleToArray = (a) => {
   let beforeHandle = [];
   return a.resolve && (beforeHandle = fnToContainer(Array.isArray(a.resolve) ? a.resolve : [a.resolve], "resolve"), delete a.resolve), a.beforeHandle && (beforeHandle.length ? beforeHandle = beforeHandle.concat(Array.isArray(a.beforeHandle) ? a.beforeHandle : [a.beforeHandle]) : beforeHandle = Array.isArray(a.beforeHandle) ? a.beforeHandle : [a.beforeHandle]), beforeHandle.length && (a.beforeHandle = beforeHandle), a;
 };
-var isBun2 = typeof Bun < "u";
-var hasBunHash = isBun2 && typeof Bun.hash == "function";
+var hasHeaderShorthand = isBun ? "toJSON" in new Headers : false;
 var hasSetImmediate = typeof setImmediate == "function";
 var checksum = (s) => {
   let h = 9;
@@ -37222,8 +37860,8 @@ function removeTrailingEquals(digest) {
 }
 var encoder = new TextEncoder;
 var signCookie = async (val, secret) => {
-  if (typeof val == "object" ? val = JSON.stringify(val) : typeof val != "string" && (val = val + ""), secret === null)
-    throw new TypeError("Secret key must be provided.");
+  if (typeof val == "object" ? val = JSON.stringify(val) : typeof val != "string" && (val = val + ""), secret == null)
+    throw new TypeError("Secret key must be provided");
   const secretKey = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]), hmacBuffer = await crypto.subtle.sign("HMAC", secretKey, encoder.encode(val));
   return val + "." + removeTrailingEquals(Buffer.from(hmacBuffer).toString("base64"));
 };
@@ -37234,11 +37872,9 @@ var constantTimeEqual = typeof crypto?.timingSafeEqual == "function" ? (a, b) =>
 var unsignCookie = async (input, secret) => {
   if (typeof input != "string")
     throw new TypeError("Signed cookie string must be provided.");
-  if (secret === null)
-    throw new TypeError("Secret key must be provided.");
   const dot = input.lastIndexOf(".");
-  if (dot <= 0)
-    return false;
+  if (dot === -1)
+    return secret === null ? input : false;
   const tentativeValue = input.slice(0, dot), expectedInput = await signCookie(tentativeValue, secret);
   return constantTimeEqual(expectedInput, input) ? tentativeValue : false;
 };
@@ -37350,11 +37986,11 @@ var form = (items) => {
     }
   return formData;
 };
-var randomId = typeof crypto > "u" ? () => {
+var randomId = typeof crypto > "u" || isCloudflareWorker() ? () => {
   let result = "";
-  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", charactersLength = characters.length;
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
   for (let i = 0;i < 16; i++)
-    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    result += characters.charAt(Math.floor(Math.random() * 62));
   return result;
 } : () => {
   const uuid2 = crypto.randomUUID();
@@ -37580,7 +38216,7 @@ class ValidationError2 extends Error {
         value,
         property: accessor,
         message: error2?.message,
-        summary: mapValueError(error2).summary,
+        summary: mapValueError(error2)?.summary,
         found: value,
         expected,
         errors: "Errors" in validator ? [
@@ -37597,7 +38233,7 @@ class ValidationError2 extends Error {
         on: type,
         property: accessor,
         message: error2?.message,
-        summary: mapValueError(error2).summary,
+        summary: mapValueError(error2)?.summary,
         expected,
         found: value,
         errors: "Errors" in validator ? [...validator.Errors(value)].map(mapValueError) : [...exports_value2.Errors(validator, value)].map(mapValueError)
@@ -37621,7 +38257,7 @@ class ValidationError2 extends Error {
       path: issue2.path?.join(".") || "root",
       message: issue2.message,
       value: this.value
-    })) || [] : ("Errors" in this.validator) ? [...this.validator.Errors(this.value)].map(mapValueError) : [...exports_value2.Errors(this.validator, this.value)].map(mapValueError);
+    })) || [] : ("Errors" in this.validator) ? [...this.validator.Errors(this.value)].filter((x) => x).map((x) => mapValueError(x)) : [...exports_value2.Errors(this.validator, this.value)].map(mapValueError);
   }
   static simplifyModel(validator) {
     const model = "schema" in validator ? validator.schema : validator;
@@ -37657,7 +38293,7 @@ class ValidationError2 extends Error {
       on: this.type,
       property: this.valueError?.path || "root",
       message,
-      summary: this.valueError ? mapValueError(this.valueError).summary : undefined,
+      summary: mapValueError(this.valueError)?.summary,
       found: value,
       expected,
       errors: errors3
@@ -37758,7 +38394,7 @@ var fullFormats = {
   uri,
   "uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
   "uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
-  url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
+  url: /^(?:https?|ftp):\/\/(?:[^\s:@]+(?::[^\s@]*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
   email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
   hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
   ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
@@ -38209,6 +38845,270 @@ t.BooleanString = ElysiaType.BooleanString, t.ObjectString = ElysiaType.ObjectSt
   }
 })), t.Nullable = ElysiaType.Nullable, t.MaybeEmpty = ElysiaType.MaybeEmpty, t.Cookie = ElysiaType.Cookie, t.Date = ElysiaType.Date, t.UnionEnum = ElysiaType.UnionEnum, t.NoValidate = ElysiaType.NoValidate, t.Form = ElysiaType.Form, t.ArrayBuffer = ElysiaType.ArrayBuffer, t.Uint8Array = ElysiaType.Uint8Array;
 
+// node_modules/elysia/dist/sucrose.mjs
+var separateFunction = (code) => {
+  code.startsWith("async") && (code = code.slice(5)), code = code.trimStart();
+  let index = -1;
+  if (code.charCodeAt(0) === 40 && (index = code.indexOf("=>", code.indexOf(")")), index !== -1)) {
+    let bracketEndIndex = index;
+    for (;bracketEndIndex > 0 && code.charCodeAt(--bracketEndIndex) !== 41; )
+      ;
+    let body = code.slice(index + 2);
+    return body.charCodeAt(0) === 32 && (body = body.trimStart()), [
+      code.slice(1, bracketEndIndex),
+      body,
+      {
+        isArrowReturn: body.charCodeAt(0) !== 123
+      }
+    ];
+  }
+  if (/^(\w+)=>/g.test(code) && (index = code.indexOf("=>"), index !== -1)) {
+    let body = code.slice(index + 2);
+    return body.charCodeAt(0) === 32 && (body = body.trimStart()), [
+      code.slice(0, index),
+      body,
+      {
+        isArrowReturn: body.charCodeAt(0) !== 123
+      }
+    ];
+  }
+  if (code.startsWith("function")) {
+    index = code.indexOf("(");
+    const end = code.indexOf(")");
+    return [
+      code.slice(index + 1, end),
+      code.slice(end + 2),
+      {
+        isArrowReturn: false
+      }
+    ];
+  }
+  const start = code.indexOf("(");
+  if (start !== -1) {
+    const sep = code.indexOf(`
+`, 2), parameter = code.slice(0, sep), end = parameter.lastIndexOf(")") + 1, body = code.slice(sep + 1);
+    return [
+      parameter.slice(start, end),
+      "{" + body,
+      {
+        isArrowReturn: false
+      }
+    ];
+  }
+  const x = code.split(`
+`, 2);
+  return [x[0], x[1], { isArrowReturn: false }];
+};
+var bracketPairRange = (parameter) => {
+  const start = parameter.indexOf("{");
+  if (start === -1)
+    return [-1, 0];
+  let end = start + 1, deep = 1;
+  for (;end < parameter.length; end++) {
+    const char = parameter.charCodeAt(end);
+    if (char === 123 ? deep++ : char === 125 && deep--, deep === 0)
+      break;
+  }
+  return deep !== 0 ? [0, parameter.length] : [start, end + 1];
+};
+var bracketPairRangeReverse = (parameter) => {
+  const end = parameter.lastIndexOf("}");
+  if (end === -1)
+    return [-1, 0];
+  let start = end - 1, deep = 1;
+  for (;start >= 0; start--) {
+    const char = parameter.charCodeAt(start);
+    if (char === 125 ? deep++ : char === 123 && deep--, deep === 0)
+      break;
+  }
+  return deep !== 0 ? [-1, 0] : [start, end + 1];
+};
+var removeColonAlias = (parameter) => {
+  for (;; ) {
+    const start = parameter.indexOf(":");
+    if (start === -1)
+      break;
+    let end = parameter.indexOf(",", start);
+    end === -1 && (end = parameter.indexOf("}", start) - 1), end === -2 && (end = parameter.length), parameter = parameter.slice(0, start) + parameter.slice(end);
+  }
+  return parameter;
+};
+var retrieveRootparameters = (parameter) => {
+  let hasParenthesis = false;
+  parameter.charCodeAt(0) === 40 && (parameter = parameter.slice(1, -1)), parameter.charCodeAt(0) === 123 && (hasParenthesis = true, parameter = parameter.slice(1, -1)), parameter = parameter.replace(/( |\t|\n)/g, "").trim();
+  let parameters = [];
+  for (;; ) {
+    let [start, end] = bracketPairRange(parameter);
+    if (start === -1)
+      break;
+    parameters.push(parameter.slice(0, start - 1)), parameter.charCodeAt(end) === 44 && end++, parameter = parameter.slice(end);
+  }
+  parameter = removeColonAlias(parameter), parameter && (parameters = parameters.concat(parameter.split(",")));
+  const parameterMap = /* @__PURE__ */ Object.create(null);
+  for (const p of parameters) {
+    if (p.indexOf(",") === -1) {
+      parameterMap[p] = true;
+      continue;
+    }
+    for (const q of p.split(","))
+      parameterMap[q.trim()] = true;
+  }
+  return {
+    hasParenthesis,
+    parameters: parameterMap
+  };
+};
+var findParameterReference = (parameter, inference) => {
+  const { parameters, hasParenthesis } = retrieveRootparameters(parameter);
+  return parameters.query && (inference.query = true), parameters.headers && (inference.headers = true), parameters.body && (inference.body = true), parameters.cookie && (inference.cookie = true), parameters.set && (inference.set = true), parameters.server && (inference.server = true), parameters.route && (inference.route = true), parameters.url && (inference.url = true), parameters.path && (inference.path = true), hasParenthesis ? `{ ${Object.keys(parameters).join(", ")} }` : Object.keys(parameters).join(", ");
+};
+var findEndIndex = (type, content, index) => {
+  const regex2 = new RegExp(`${type.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\n\\t,; ]`);
+  index !== undefined && (regex2.lastIndex = index);
+  const match = regex2.exec(content);
+  return match ? match.index : -1;
+};
+var findAlias = (type, body, depth = 0) => {
+  if (depth > 5)
+    return [];
+  const aliases = [];
+  let content = body;
+  for (;; ) {
+    let index = findEndIndex(" = " + type, content);
+    if (index === -1 && (index = findEndIndex("=" + type, content)), index === -1) {
+      let lastIndex = content.indexOf(" = " + type);
+      if (lastIndex === -1 && (lastIndex = content.indexOf("=" + type)), lastIndex + 3 + type.length !== content.length)
+        break;
+      index = lastIndex;
+    }
+    const part = content.slice(0, index), lastPart = part.lastIndexOf(" ");
+    let variable = part.slice(lastPart !== -1 ? lastPart + 1 : -1);
+    if (variable === "}") {
+      const [start, end] = bracketPairRangeReverse(part);
+      aliases.push(removeColonAlias(content.slice(start, end))), content = content.slice(index + 3 + type.length);
+      continue;
+    }
+    for (;variable.charCodeAt(0) === 44; )
+      variable = variable.slice(1);
+    for (;variable.charCodeAt(0) === 9; )
+      variable = variable.slice(1);
+    variable.includes("(") || aliases.push(variable), content = content.slice(index + 3 + type.length);
+  }
+  for (const alias of aliases) {
+    if (alias.charCodeAt(0) === 123)
+      continue;
+    const deepAlias = findAlias(alias, body);
+    deepAlias.length > 0 && aliases.push(...deepAlias);
+  }
+  return aliases;
+};
+var extractMainParameter = (parameter) => {
+  if (!parameter)
+    return;
+  if (parameter.charCodeAt(0) !== 123)
+    return parameter;
+  if (parameter = parameter.slice(2, -2), !parameter.includes(","))
+    return parameter.indexOf("...") !== -1 ? parameter.slice(parameter.indexOf("...") + 3) : undefined;
+  const spreadIndex = parameter.indexOf("...");
+  if (spreadIndex !== -1)
+    return parameter.slice(spreadIndex + 3).trimEnd();
+};
+var inferBodyReference = (code, aliases, inference) => {
+  const access = (type, alias) => new RegExp(`${alias}\\.(${type})|${alias}\\["${type}"\\]|${alias}\\['${type}'\\]`).test(code);
+  for (const alias of aliases)
+    if (alias) {
+      if (alias.charCodeAt(0) === 123) {
+        const parameters = retrieveRootparameters(alias).parameters;
+        parameters.query && (inference.query = true), parameters.headers && (inference.headers = true), parameters.body && (inference.body = true), parameters.cookie && (inference.cookie = true), parameters.set && (inference.set = true), parameters.server && (inference.server = true), parameters.url && (inference.url = true), parameters.route && (inference.route = true), parameters.path && (inference.path = true);
+        continue;
+      }
+      if (!inference.query && (access("query", alias) || code.includes("return " + alias) || code.includes("return " + alias + ".query")) && (inference.query = true), !inference.headers && access("headers", alias) && (inference.headers = true), !inference.body && access("body", alias) && (inference.body = true), !inference.cookie && access("cookie", alias) && (inference.cookie = true), !inference.set && access("set", alias) && (inference.set = true), !inference.server && access("server", alias) && (inference.server = true), !inference.route && access("route", alias) && (inference.route = true), !inference.url && access("url", alias) && (inference.url = true), !inference.path && access("path", alias) && (inference.path = true), inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.server && inference.route && inference.url && inference.path)
+        break;
+    }
+  return aliases;
+};
+var isContextPassToFunction = (context, body, inference) => {
+  try {
+    const captureFunction = new RegExp(`\\w\\((?:.*?)?${context}(?:.*?)?\\)`, "gs"), exactParameter = new RegExp(`${context}(,|\\))`, "gs"), length = body.length;
+    let fn;
+    for (fn = captureFunction.exec(body) + "";captureFunction.lastIndex !== 0 && captureFunction.lastIndex < length + (fn ? fn.length : 0); ) {
+      if (fn && exactParameter.test(fn))
+        return inference.query = true, inference.headers = true, inference.body = true, inference.cookie = true, inference.set = true, inference.server = true, inference.url = true, inference.route = true, inference.path = true, true;
+      fn = captureFunction.exec(body) + "";
+    }
+    const nextChar = body.charCodeAt(captureFunction.lastIndex);
+    return nextChar === 41 || nextChar === 44 ? (inference.query = true, inference.headers = true, inference.body = true, inference.cookie = true, inference.set = true, inference.server = true, inference.url = true, inference.route = true, inference.path = true, true) : false;
+  } catch {
+    return console.log("[Sucrose] warning: unexpected isContextPassToFunction error, you may continue development as usual but please report the following to maintainers:"), console.log("--- body ---"), console.log(body), console.log("--- context ---"), console.log(context), true;
+  }
+};
+var pendingGC;
+var caches2 = {};
+var clearSucroseCache = (delay) => {
+  delay === null || isCloudflareWorker() || (delay === undefined && (delay = 4 * 60 * 1000 + 55 * 1000), pendingGC && clearTimeout(pendingGC), pendingGC = setTimeout(() => {
+    caches2 = {}, pendingGC = undefined, isBun && Bun.gc(false);
+  }, delay), pendingGC.unref?.());
+};
+var mergeInference = (a, b) => ({
+  body: a.body || b.body,
+  cookie: a.cookie || b.cookie,
+  headers: a.headers || b.headers,
+  query: a.query || b.query,
+  set: a.set || b.set,
+  server: a.server || b.server,
+  url: a.url || b.url,
+  route: a.route || b.route,
+  path: a.path || b.path
+});
+var sucrose = (lifeCycle, inference = {
+  query: false,
+  headers: false,
+  body: false,
+  cookie: false,
+  set: false,
+  server: false,
+  url: false,
+  route: false,
+  path: false
+}, settings = {}) => {
+  const events = [];
+  lifeCycle.request?.length && events.push(...lifeCycle.request), lifeCycle.beforeHandle?.length && events.push(...lifeCycle.beforeHandle), lifeCycle.parse?.length && events.push(...lifeCycle.parse), lifeCycle.error?.length && events.push(...lifeCycle.error), lifeCycle.transform?.length && events.push(...lifeCycle.transform), lifeCycle.afterHandle?.length && events.push(...lifeCycle.afterHandle), lifeCycle.mapResponse?.length && events.push(...lifeCycle.mapResponse), lifeCycle.afterResponse?.length && events.push(...lifeCycle.afterResponse), lifeCycle.handler && typeof lifeCycle.handler == "function" && events.push(lifeCycle.handler);
+  for (let i = 0;i < events.length; i++) {
+    const e = events[i];
+    if (!e)
+      continue;
+    const event = typeof e == "object" ? e.fn : e;
+    if (typeof event != "function")
+      continue;
+    const content = event.toString(), key = checksum(content), cachedInference = caches2[key];
+    if (cachedInference) {
+      inference = mergeInference(inference, cachedInference);
+      continue;
+    }
+    clearSucroseCache(settings.gcTime);
+    const fnInference = {
+      query: false,
+      headers: false,
+      body: false,
+      cookie: false,
+      set: false,
+      server: false,
+      url: false,
+      route: false,
+      path: false
+    }, [parameter, body] = separateFunction(content), rootParameters = findParameterReference(parameter, fnInference), mainParameter = extractMainParameter(rootParameters);
+    if (mainParameter) {
+      const aliases = findAlias(mainParameter, body.slice(1, -1));
+      aliases.splice(0, -1, mainParameter);
+      let code = body;
+      code.charCodeAt(0) === 123 && code.charCodeAt(body.length - 1) === 125 && (code = code.slice(1, -1).trim()), isContextPassToFunction(mainParameter, code, fnInference) || inferBodyReference(code, aliases, fnInference), !fnInference.query && code.includes("return " + mainParameter + ".query") && (fnInference.query = true);
+    }
+    if (caches2[key] || (caches2[key] = fnInference), inference = mergeInference(inference, fnInference), inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.server && inference.url && inference.route && inference.path)
+      break;
+  }
+  return inference;
+};
+
 // node_modules/elysia/dist/cookies.mjs
 var import_cookie = __toESM(require_dist2(), 1);
 var import_fast_decode_uri_component = __toESM(require_fast_decode_uri_component(), 1);
@@ -38221,7 +39121,7 @@ var hashString = (str) => {
 };
 
 class Cookie {
-  constructor(name, jar, initial = {}) {
+  constructor(name, jar, initial = /* @__PURE__ */ Object.create(null)) {
     this.name = name;
     this.jar = jar;
     this.initial = initial;
@@ -38341,7 +39241,7 @@ class Cookie {
     return typeof this.value == "object" ? JSON.stringify(this.value) : this.value?.toString() ?? "";
   }
 }
-var createCookieJar = (set2, store, initial) => (set2.cookie || (set2.cookie = {}), new Proxy(store, {
+var createCookieJar = (set2, store, initial) => (set2.cookie || (set2.cookie = /* @__PURE__ */ Object.create(null)), new Proxy(store, {
   get(_, key) {
     return key in store ? new Cookie(key, set2.cookie, Object.assign({}, initial ?? {}, store[key])) : new Cookie(key, set2.cookie, Object.assign({}, initial));
   }
@@ -38350,23 +39250,16 @@ var parseCookie = async (set2, cookieString, {
   secrets,
   sign,
   ...initial
-} = {}) => {
+} = /* @__PURE__ */ Object.create(null)) => {
   if (!cookieString)
-    return createCookieJar(set2, {}, initial);
+    return createCookieJar(set2, /* @__PURE__ */ Object.create(null), initial);
   const isStringKey = typeof secrets == "string";
   sign && sign !== true && !Array.isArray(sign) && (sign = [sign]);
-  const jar = {}, cookies = import_cookie.parse(cookieString);
+  const jar = /* @__PURE__ */ Object.create(null), cookies = import_cookie.parse(cookieString);
   for (const [name, v] of Object.entries(cookies)) {
-    if (v === undefined)
+    if (v === undefined || name === "__proto__" || name === "constructor" || name === "prototype")
       continue;
     let value = import_fast_decode_uri_component.default(v);
-    if (value) {
-      const starts = value.charCodeAt(0), ends = value.charCodeAt(value.length - 1);
-      if (starts === 123 && ends === 125 || starts === 91 && ends === 93)
-        try {
-          value = JSON.parse(value);
-        } catch {}
-    }
     if (sign === true || sign?.includes(name)) {
       if (!secrets)
         throw new Error("No secret is provided to cookie plugin");
@@ -38392,9 +39285,14 @@ var parseCookie = async (set2, cookieString, {
           throw new InvalidCookieSignature(name);
       }
     }
-    jar[name] = {
-      value
-    };
+    if (value) {
+      const starts = value.charCodeAt(0), ends = value.charCodeAt(value.length - 1);
+      if (starts === 123 && ends === 125 || starts === 91 && ends === 93)
+        try {
+          value = JSON.parse(value);
+        } catch {}
+    }
+    jar[name] = /* @__PURE__ */ Object.create(null), jar[name].value = value;
   }
   return createCookieJar(set2, jar, initial);
 };
@@ -38572,32 +39470,33 @@ var handleSet = (set2) => {
   }
   set2.headers["set-cookie"] && Array.isArray(set2.headers["set-cookie"]) && (set2.headers = parseSetCookies(new Headers(set2.headers), set2.headers["set-cookie"]));
 };
+function mergeHeaders(responseHeaders, setHeaders) {
+  const headers = new Headers(responseHeaders);
+  if (setHeaders instanceof Headers)
+    for (const key of setHeaders.keys())
+      if (key === "set-cookie") {
+        if (headers.has("set-cookie"))
+          continue;
+        for (const cookie of setHeaders.getSetCookie())
+          headers.append("set-cookie", cookie);
+      } else
+        responseHeaders.has(key) || headers.set(key, setHeaders?.get(key) ?? "");
+  else
+    for (const key in setHeaders)
+      key === "set-cookie" ? headers.append(key, setHeaders[key]) : responseHeaders.has(key) || headers.set(key, setHeaders[key]);
+  return headers;
+}
+function mergeStatus(responseStatus, setStatus) {
+  return typeof setStatus == "string" && (setStatus = StatusMap[setStatus]), responseStatus === 200 ? setStatus : responseStatus;
+}
 var createResponseHandler = (handler) => {
   const handleStream = createStreamHandler(handler);
   return (response, set2, request) => {
-    let isCookieSet = false;
-    if (set2.headers instanceof Headers)
-      for (const key of set2.headers.keys())
-        if (key === "set-cookie") {
-          if (isCookieSet)
-            continue;
-          isCookieSet = true;
-          for (const cookie of set2.headers.getSetCookie())
-            response.headers.append("set-cookie", cookie);
-        } else
-          response.headers.has(key) || response.headers.set(key, set2.headers?.get(key) ?? "");
-    else
-      for (const key in set2.headers)
-        key === "set-cookie" ? response.headers.append(key, set2.headers[key]) : response.headers.has(key) || response.headers.set(key, set2.headers[key]);
-    const status2 = set2.status ?? 200;
-    if (response.status !== status2 && status2 !== 200 && (response.status <= 300 || response.status > 400)) {
-      const newResponse = new Response(response.body, {
-        headers: response.headers,
-        status: set2.status
-      });
-      return !newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked" ? handleStream(streamResponse(newResponse), responseToSetHeaders(newResponse, set2), request, true) : newResponse;
-    }
-    return !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked" ? handleStream(streamResponse(response), responseToSetHeaders(response, set2), request, true) : response;
+    const newResponse = new Response(response.body, {
+      headers: mergeHeaders(response.headers, set2.headers),
+      status: mergeStatus(response.status, set2.status)
+    });
+    return !newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked" ? handleStream(streamResponse(newResponse), responseToSetHeaders(newResponse, set2), request, true) : newResponse;
   };
 };
 async function tee(source, branches = 2) {
@@ -38678,6 +39577,12 @@ var mapResponse = (response, set2, request) => {
           return handleStream(response, set2, request);
         if (typeof response?.then == "function")
           return response.then((x) => mapResponse(x, set2));
+        if (Array.isArray(response))
+          return new Response(JSON.stringify(response), {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
         if (typeof response?.toResponse == "function")
           return mapResponse(response.toResponse(), set2);
         if ("charCodeAt" in response) {
@@ -38738,6 +39643,12 @@ var mapEarlyResponse = (response, set2, request) => {
             return response.then((x) => mapEarlyResponse(x, set2));
           if (typeof response?.toResponse == "function")
             return mapEarlyResponse(response.toResponse(), set2);
+          if (Array.isArray(response))
+            return new Response(JSON.stringify(response), {
+              headers: {
+                "Content-Type": "application/json"
+              }
+            });
           if ("charCodeAt" in response) {
             const code = response.charCodeAt(0);
             if (code === 123 || code === 91)
@@ -38800,6 +39711,12 @@ var mapEarlyResponse = (response, set2, request) => {
             return response.then((x) => mapEarlyResponse(x, set2));
           if (typeof response?.toResponse == "function")
             return mapEarlyResponse(response.toResponse(), set2);
+          if (Array.isArray(response))
+            return new Response(JSON.stringify(response), {
+              headers: {
+                "Content-Type": "application/json"
+              }
+            });
           if ("charCodeAt" in response) {
             const code = response.charCodeAt(0);
             if (code === 123 || code === 91)
@@ -38871,6 +39788,12 @@ var mapCompactResponse = (response, request) => {
         return response.then((x) => mapCompactResponse(x, request));
       if (typeof response?.toResponse == "function")
         return mapCompactResponse(response.toResponse());
+      if (Array.isArray(response))
+        return new Response(JSON.stringify(response), {
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
       if ("charCodeAt" in response) {
         const code = response.charCodeAt(0);
         if (code === 123 || code === 91)
@@ -38954,10 +39877,57 @@ for(const [k,v] of c.request.headers.entries())c.headers[k]=v
 c.body={}
 `;
         return isOptional ? fnLiteral += "let form;try{form=await c.request.formData()}catch{}" : fnLiteral += `const form=await c.request.formData()
-`, fnLiteral + `for(const key of form.keys()){if(c.body[key]) continue
+`, fnLiteral + `const dangerousKeys=new Set(['__proto__','constructor','prototype'])
+const isDangerousKey=(k)=>{if(dangerousKeys.has(k))return true;const m=k.match(/^(.+)\\[(\\d+)\\]$/);return m?dangerousKeys.has(m[1]):false}
+const parseArrayKey=(k)=>{const m=k.match(/^(.+)\\[(\\d+)\\]$/);return m?{name:m[1],index:parseInt(m[2],10)}:null}
+for(const key of form.keys()){if(c.body[key])continue
 const value=form.getAll(key)
-if(value.length===1)c.body[key]=value[0]
-else c.body[key]=value}`;
+let finalValue
+if(value.length===1){
+const sv=value[0]
+if(typeof sv==='string'&&(sv.charCodeAt(0)===123||sv.charCodeAt(0)===91)){
+try{
+const p=JSON.parse(sv)
+if(p&&typeof p==='object')finalValue=p
+}catch{}
+}
+if(finalValue===undefined)finalValue=sv
+}else finalValue=value
+if(Array.isArray(finalValue)){
+const stringValue=finalValue.find((entry)=>typeof entry==='string')
+const files=typeof File==='undefined'?[]:finalValue.filter((entry)=>entry instanceof File)
+if(stringValue&&files.length&&stringValue.charCodeAt(0)===123){
+try{
+const parsed=JSON.parse(stringValue)
+if(parsed&&typeof parsed==='object'&&!Array.isArray(parsed)){
+if(!('file' in parsed)&&files.length===1)parsed.file=files[0]
+else if(!('files' in parsed)&&files.length>1)parsed.files=files
+finalValue=parsed
+}
+}catch{}
+}
+}
+if(key.includes('.')||key.includes('[')){const keys=key.split('.')
+const lastKey=keys.pop()
+if(isDangerousKey(lastKey)||keys.some(isDangerousKey))continue
+let current=c.body
+for(const k of keys){const arrayInfo=parseArrayKey(k)
+if(arrayInfo){if(!Array.isArray(current[arrayInfo.name]))current[arrayInfo.name]=[]
+const existing=current[arrayInfo.name][arrayInfo.index]
+const isFile=typeof File!=='undefined'&&existing instanceof File
+if(!existing||typeof existing!=='object'||Array.isArray(existing)||isFile){
+let parsed
+if(typeof existing==='string'&&existing.charCodeAt(0)===123){
+try{parsed=JSON.parse(existing)
+if(!parsed||typeof parsed!=='object'||Array.isArray(parsed))parsed=undefined}catch{}
+}
+current[arrayInfo.name][arrayInfo.index]=parsed||{}
+}
+current=current[arrayInfo.name][arrayInfo.index]}else{if(!current[k]||typeof current[k]!=='object')current[k]={}
+current=current[k]}}
+const arrayInfo=parseArrayKey(lastKey)
+if(arrayInfo){if(!Array.isArray(current[arrayInfo.name]))current[arrayInfo.name]=[]
+current[arrayInfo.name][arrayInfo.index]=finalValue}else{current[lastKey]=finalValue}}else c.body[key]=finalValue}`;
       }
     }
   },
@@ -39004,6 +39974,278 @@ const error404=new Response(error404Message,{status:404})
   }
 };
 
+// node_modules/elysia/dist/adapter/bun/handler.mjs
+var mapResponse2 = (response, set2, request) => {
+  if (isNotEmpty(set2.headers) || set2.status !== 200 || set2.cookie)
+    switch (handleSet(set2), response?.constructor?.name) {
+      case "String":
+        return new Response(response, set2);
+      case "Array":
+      case "Object":
+        return Response.json(response, set2);
+      case "ElysiaFile":
+        return handleFile(response.value, set2);
+      case "File":
+        return handleFile(response, set2);
+      case "Blob":
+        return handleFile(response, set2);
+      case "ElysiaCustomStatusResponse":
+        return set2.status = response.code, mapResponse2(response.response, set2, request);
+      case undefined:
+        return response ? Response.json(response, set2) : new Response("", set2);
+      case "Response":
+        return handleResponse2(response, set2, request);
+      case "Error":
+        return errorToResponse2(response, set2);
+      case "Promise":
+        return response.then((x) => mapResponse2(x, set2, request));
+      case "Function":
+        return mapResponse2(response(), set2, request);
+      case "Number":
+      case "Boolean":
+        return new Response(response.toString(), set2);
+      case "Cookie":
+        return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
+      case "FormData":
+        return new Response(response, set2);
+      default:
+        if (response instanceof Response)
+          return handleResponse2(response, set2, request);
+        if (response instanceof Promise)
+          return response.then((x) => mapResponse2(x, set2));
+        if (response instanceof Error)
+          return errorToResponse2(response, set2);
+        if (response instanceof ElysiaCustomStatusResponse)
+          return set2.status = response.code, mapResponse2(response.response, set2, request);
+        if (typeof response?.next == "function" || response instanceof ReadableStream)
+          return handleStream2(response, set2, request);
+        if (typeof response?.then == "function")
+          return response.then((x) => mapResponse2(x, set2));
+        if (Array.isArray(response))
+          return Response.json(response);
+        if (typeof response?.toResponse == "function")
+          return mapResponse2(response.toResponse(), set2);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91)
+            return Response.json(response, set2);
+        }
+        return new Response(response, set2);
+    }
+  return typeof response?.next == "function" || response instanceof ReadableStream ? handleStream2(response, set2, request) : mapCompactResponse2(response, request);
+};
+var mapEarlyResponse2 = (response, set2, request) => {
+  if (response != null)
+    if (isNotEmpty(set2.headers) || set2.status !== 200 || set2.cookie)
+      switch (handleSet(set2), response?.constructor?.name) {
+        case "String":
+          return new Response(response, set2);
+        case "Array":
+        case "Object":
+          return Response.json(response, set2);
+        case "ElysiaFile":
+          return handleFile(response.value, set2);
+        case "File":
+          return handleFile(response, set2);
+        case "Blob":
+          return handleFile(response, set2);
+        case "ElysiaCustomStatusResponse":
+          return set2.status = response.code, mapEarlyResponse2(response.response, set2, request);
+        case undefined:
+          return response ? Response.json(response, set2) : undefined;
+        case "Response":
+          return handleResponse2(response, set2, request);
+        case "Promise":
+          return response.then((x) => mapEarlyResponse2(x, set2));
+        case "Error":
+          return errorToResponse2(response, set2);
+        case "Function":
+          return mapEarlyResponse2(response(), set2);
+        case "Number":
+        case "Boolean":
+          return new Response(response.toString(), set2);
+        case "FormData":
+          return new Response(response);
+        case "Cookie":
+          return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
+        default:
+          if (response instanceof Response)
+            return handleResponse2(response, set2, request);
+          if (response instanceof Promise)
+            return response.then((x) => mapEarlyResponse2(x, set2));
+          if (response instanceof Error)
+            return errorToResponse2(response, set2);
+          if (response instanceof ElysiaCustomStatusResponse)
+            return set2.status = response.code, mapEarlyResponse2(response.response, set2, request);
+          if (typeof response?.next == "function" || response instanceof ReadableStream)
+            return handleStream2(response, set2, request);
+          if (typeof response?.then == "function")
+            return response.then((x) => mapEarlyResponse2(x, set2));
+          if (typeof response?.toResponse == "function")
+            return mapEarlyResponse2(response.toResponse(), set2);
+          if (Array.isArray(response))
+            return Response.json(response);
+          if ("charCodeAt" in response) {
+            const code = response.charCodeAt(0);
+            if (code === 123 || code === 91)
+              return Response.json(response, set2);
+          }
+          return new Response(response, set2);
+      }
+    else
+      switch (response?.constructor?.name) {
+        case "String":
+          return new Response(response);
+        case "Array":
+        case "Object":
+          return Response.json(response, set2);
+        case "ElysiaFile":
+          return handleFile(response.value, set2);
+        case "File":
+          return handleFile(response, set2);
+        case "Blob":
+          return handleFile(response, set2);
+        case "ElysiaCustomStatusResponse":
+          return set2.status = response.code, mapEarlyResponse2(response.response, set2, request);
+        case undefined:
+          return response ? Response.json(response) : new Response("");
+        case "Response":
+          return response;
+        case "Promise":
+          return response.then((x) => {
+            const r = mapEarlyResponse2(x, set2);
+            if (r !== undefined)
+              return r;
+          });
+        case "Error":
+          return errorToResponse2(response, set2);
+        case "Function":
+          return mapCompactResponse2(response(), request);
+        case "Number":
+        case "Boolean":
+          return new Response(response.toString());
+        case "Cookie":
+          return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
+        case "FormData":
+          return new Response(response);
+        default:
+          if (response instanceof Response)
+            return response;
+          if (response instanceof Promise)
+            return response.then((x) => mapEarlyResponse2(x, set2));
+          if (response instanceof Error)
+            return errorToResponse2(response, set2);
+          if (response instanceof ElysiaCustomStatusResponse)
+            return set2.status = response.code, mapEarlyResponse2(response.response, set2, request);
+          if (typeof response?.next == "function" || response instanceof ReadableStream)
+            return handleStream2(response, set2, request);
+          if (typeof response?.then == "function")
+            return response.then((x) => mapEarlyResponse2(x, set2));
+          if (typeof response?.toResponse == "function")
+            return mapEarlyResponse2(response.toResponse(), set2);
+          if (Array.isArray(response))
+            return Response.json(response);
+          if ("charCodeAt" in response) {
+            const code = response.charCodeAt(0);
+            if (code === 123 || code === 91)
+              return Response.json(response, set2);
+          }
+          return new Response(response);
+      }
+};
+var mapCompactResponse2 = (response, request) => {
+  switch (response?.constructor?.name) {
+    case "String":
+      return new Response(response);
+    case "Object":
+    case "Array":
+      return Response.json(response);
+    case "ElysiaFile":
+      return handleFile(response.value);
+    case "File":
+      return handleFile(response);
+    case "Blob":
+      return handleFile(response);
+    case "ElysiaCustomStatusResponse":
+      return mapResponse2(response.response, {
+        status: response.code,
+        headers: {}
+      });
+    case undefined:
+      return response ? Response.json(response) : new Response("");
+    case "Response":
+      return response;
+    case "Error":
+      return errorToResponse2(response);
+    case "Promise":
+      return response.then((x) => mapCompactResponse2(x, request));
+    case "Function":
+      return mapCompactResponse2(response(), request);
+    case "Number":
+    case "Boolean":
+      return new Response(response.toString());
+    case "FormData":
+      return new Response(response);
+    default:
+      if (response instanceof Response)
+        return response;
+      if (response instanceof Promise)
+        return response.then((x) => mapCompactResponse2(x, request));
+      if (response instanceof Error)
+        return errorToResponse2(response);
+      if (response instanceof ElysiaCustomStatusResponse)
+        return mapResponse2(response.response, {
+          status: response.code,
+          headers: {}
+        });
+      if (typeof response?.next == "function" || response instanceof ReadableStream)
+        return handleStream2(response, undefined, request);
+      if (typeof response?.then == "function")
+        return response.then((x) => mapCompactResponse2(x, request));
+      if (typeof response?.toResponse == "function")
+        return mapCompactResponse2(response.toResponse());
+      if (Array.isArray(response))
+        return Response.json(response);
+      if ("charCodeAt" in response) {
+        const code = response.charCodeAt(0);
+        if (code === 123 || code === 91)
+          return Response.json(response);
+      }
+      return new Response(response);
+  }
+};
+var errorToResponse2 = (error2, set2) => {
+  if (typeof error2?.toResponse == "function") {
+    const raw = error2.toResponse(), targetSet = set2 ?? { headers: {}, status: 200, redirect: "" }, apply = (resolved) => (resolved instanceof Response && (targetSet.status = resolved.status), mapResponse2(resolved, targetSet));
+    return typeof raw?.then == "function" ? raw.then(apply) : apply(raw);
+  }
+  return Response.json({
+    name: error2?.name,
+    message: error2?.message,
+    cause: error2?.cause
+  }, {
+    status: set2?.status !== 200 ? set2?.status ?? 500 : 500,
+    headers: set2?.headers
+  });
+};
+var createStaticHandler2 = (handle, hooks, setHeaders = {}) => {
+  if (typeof handle == "function")
+    return;
+  const response = mapResponse2(handle, {
+    headers: setHeaders
+  });
+  if (!hooks.parse?.length && !hooks.transform?.length && !hooks.beforeHandle?.length && !hooks.afterHandle?.length)
+    return () => response.clone();
+};
+var handleResponse2 = createResponseHandler({
+  mapResponse: mapResponse2,
+  mapCompactResponse: mapCompactResponse2
+});
+var handleStream2 = createStreamHandler({
+  mapResponse: mapResponse2,
+  mapCompactResponse: mapCompactResponse2
+});
+
 // node_modules/elysia/dist/compose.mjs
 var import_fast_decode_uri_component3 = __toESM(require_fast_decode_uri_component(), 1);
 
@@ -39306,7 +40548,7 @@ var handleTuple = (schema, property, instruction) => {
   for (let i2 = 0;i2 < schema.length; i2++) {
     if (i2 !== 0)
       v += ",";
-    v += mirror(schema[i2], joinProperty(property, i2, instruction.parentIsOptional), instruction);
+    v += mirror(schema[i2], joinProperty(property, i2, instruction.parentIsOptional || instruction.fromUnion), instruction);
   }
   v += `];`;
   if (!isRoot)
@@ -39377,13 +40619,15 @@ var handleUnion = (schemas3, property, instruction) => {
     v += `if(d.unions[${ui}][${i}].Check(${property})){return ${mirror(type, property, {
       ...instruction,
       recursion: instruction.recursion + 1,
-      parentIsOptional: true
+      parentIsOptional: true,
+      fromUnion: true
     })}}
 `;
     cleanThenCheck += (i ? "" : "let ") + "tmp=" + mirror(type, property, {
       ...instruction,
       recursion: instruction.recursion + 1,
-      parentIsOptional: true
+      parentIsOptional: true,
+      fromUnion: true
     }) + `
 if(d.unions[${ui}][${i}].Check(tmp))return tmp
 `;
@@ -39423,7 +40667,7 @@ var mirror = (schema, property, instruction) => {
       for (let i2 = 0;i2 < keys.length; i2++) {
         const key = keys[i2];
         let isOptional = !schema.required || schema.required && !schema.required.includes(key) || Array.isArray(schema.properties[key].anyOf);
-        const name = joinProperty(property, key, instruction.parentIsOptional);
+        const name = joinProperty(property, key, instruction.parentIsOptional || instruction.fromUnion);
         if (isOptional) {
           const index = instruction.array;
           if (property.startsWith("ar")) {
@@ -39778,10 +41022,16 @@ var hasElysiaMeta = (meta2, _schema) => {
 };
 var hasProperty = (expectedProperty, _schema) => {
   if (!_schema)
-    return;
+    return false;
   const schema = _schema.schema ?? _schema;
   if (schema[Kind] === "Import" && _schema.References)
     return _schema.References().some((schema2) => hasProperty(expectedProperty, schema2));
+  if (schema.anyOf)
+    return schema.anyOf.some((s) => hasProperty(expectedProperty, s));
+  if (schema.allOf)
+    return schema.allOf.some((s) => hasProperty(expectedProperty, s));
+  if (schema.oneOf)
+    return schema.oneOf.some((s) => hasProperty(expectedProperty, s));
   if (schema.type === "object") {
     const properties = schema.properties;
     if (!properties)
@@ -39933,6 +41183,42 @@ var getSchemaValidator = (s, {
   };
   let schema = mapSchema(s), _validators = validators;
   if ("~standard" in schema || validators?.length && validators.some((x) => x && typeof x != "string" && ("~standard" in x))) {
+    let Check22 = function(value, validated = false) {
+      let v = validated ? value : mainCheck.validate(value);
+      if (v instanceof Promise)
+        return v.then((v2) => Check22(v2, true));
+      if (v.issues)
+        return v;
+      const values = [];
+      return v && typeof v == "object" && values.push(v.value), runCheckers2(value, 0, values, v);
+    }, runCheckers2 = function(value, startIndex, values, lastV) {
+      for (let i = startIndex;i < checkers.length; i++) {
+        let v = checkers[i].validate(value);
+        if (v instanceof Promise)
+          return v.then((resolved) => {
+            if (resolved.issues)
+              return resolved;
+            const nextValues = [...values];
+            return resolved && typeof resolved == "object" && nextValues.push(resolved.value), runCheckers2(value, i + 1, nextValues, resolved);
+          });
+        if (v.issues)
+          return v;
+        v && typeof v == "object" && values.push(v.value), lastV = v;
+      }
+      return mergeValues22(values, lastV);
+    }, mergeValues22 = function(values, lastV) {
+      if (!values.length)
+        return { value: lastV };
+      if (values.length === 1)
+        return { value: values[0] };
+      if (values.length === 2)
+        return { value: mergeDeep(values[0], values[1]) };
+      let newValue = mergeDeep(values[0], values[1]);
+      for (let i = 2;i < values.length; i++)
+        newValue = mergeDeep(newValue, values[i]);
+      return { value: newValue };
+    };
+    var Check2 = Check22, runCheckers = runCheckers2, mergeValues2 = mergeValues22;
     const typeboxSubValidator = (schema2) => {
       let mirror2;
       if (normalize === true || normalize === "exactMirror")
@@ -39955,12 +41241,14 @@ var getSchemaValidator = (s, {
         coerce,
         additionalCoerce
       });
-      return vali.Decode = mirror2, (v) => vali.Check(v) ? {
-        value: vali.Decode(v)
-      } : {
-        issues: [...vali.Errors(v)]
+      return vali.Decode = mirror2, {
+        validate: (v) => vali.Check(v) ? {
+          value: mirror2 ? mirror2(v) : v
+        } : {
+          issues: [...vali.Errors(v)]
+        }
       };
-    }, mainCheck = schema["~standard"] ? schema["~standard"].validate : typeboxSubValidator(schema);
+    }, mainCheck = schema["~standard"] ? schema["~standard"] : typeboxSubValidator(schema);
     let checkers = [];
     if (validators?.length) {
       for (const validator2 of validators)
@@ -39975,38 +41263,16 @@ var getSchemaValidator = (s, {
           }
         }
     }
-    async function Check2(value) {
-      let v = mainCheck(value);
-      if (v instanceof Promise && (v = await v), v.issues)
-        return v;
-      const values = [];
-      v && typeof v == "object" && values.push(v.value);
-      for (let i = 0;i < checkers.length; i++) {
-        if (v = checkers[i].validate(value), v instanceof Promise && (v = await v), v.issues)
-          return v;
-        v && typeof v == "object" && values.push(v.value);
-      }
-      if (!values.length)
-        return { value: v };
-      if (values.length === 1)
-        return { value: values[0] };
-      if (values.length === 2)
-        return { value: mergeDeep(values[0], values[1]) };
-      let newValue = mergeDeep(values[0], values[1]);
-      for (let i = 2;i < values.length; i++)
-        newValue = mergeDeep(newValue, values[i]);
-      return { value: newValue };
-    }
     const validator = {
       provider: "standard",
       schema,
       references: "",
       checkFunc: () => {},
       code: "",
-      Check: Check2,
-      Errors: (value) => Check2(value)?.then?.((x) => x?.issues),
+      Check: Check22,
+      Errors: (value) => Check22(value)?.then?.((x) => x?.issues),
       Code: () => "",
-      Decode: Check2,
+      Decode: Check22,
       Encode: (value) => value,
       hasAdditionalProperties: false,
       hasDefault: false,
@@ -40271,6 +41537,21 @@ var getSchemaValidator = (s, {
   }), compiled;
 };
 var isUnion = (schema) => schema[Kind] === "Union" || !schema.schema && !!schema.anyOf;
+var getSchemaProperties = (schema) => {
+  if (!schema)
+    return;
+  if (schema.properties)
+    return schema.properties;
+  const members = schema.allOf ?? schema.anyOf ?? schema.oneOf;
+  if (members) {
+    const result = {};
+    for (const member of members) {
+      const props = getSchemaProperties(member);
+      props && Object.assign(result, props);
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+  }
+};
 var mergeObjectSchemas = (schemas3) => {
   if (schemas3.length === 0)
     return {
@@ -40554,7 +41835,7 @@ var isAsync = (v) => {
   if (isObject3 && v.isAsync !== undefined)
     return v.isAsync;
   const fn = isObject3 ? v.fn : v;
-  if (fn.constructor.name === "AsyncFunction")
+  if (fn.constructor.name === "AsyncFunction" || fn.constructor.name === "AsyncGeneratorFunction")
     return true;
   const literal3 = fn.toString();
   if (matchResponseClone.test(literal3))
@@ -40623,8 +41904,14 @@ return function(){return a}`)(handler);
     if (_encodeCookie)
       return _encodeCookie;
     if (cookieMeta?.sign) {
+      if (cookieMeta.secrets === "")
+        throw new Error(`cookie secret can't be an empty string at (${method}) ${path2}`, {
+          cause: `(${method}) ${path2}`
+        });
       if (!cookieMeta.secrets)
-        throw new Error(`t.Cookie required secret which is not set in (${method}) ${path2}.`);
+        throw new Error(`cookie secret must be defined (${method}) ${path2}`, {
+          cause: `(${method}) ${path2}`
+        });
       const secret = cookieMeta.secrets ? typeof cookieMeta.secrets == "string" ? cookieMeta.secrets : cookieMeta.secrets[0] : undefined;
       if (_encodeCookie += `const _setCookie = c.set.cookie
 if(_setCookie){`, cookieMeta.sign === true)
@@ -40659,7 +41946,7 @@ if(_setCookie){`, cookieMeta.sign === true)
     const get = (name, defaultValue) => {
       const value = cookieMeta?.[name] ?? defaultValue;
       return value === undefined ? "" : value ? typeof value == "string" ? `${name}:${JSON.stringify(value)},` : value instanceof Date ? `${name}: new Date(${value.getTime()}),` : `${name}:${value},` : typeof defaultValue == "string" ? `${name}:"${defaultValue}",` : `${name}:${defaultValue},`;
-    }, options = cookieMeta ? `{secrets:${cookieMeta.secrets !== undefined ? typeof cookieMeta.secrets == "string" ? JSON.stringify(cookieMeta.secrets) : "[" + cookieMeta.secrets.map((x) => JSON.stringify(x)).join(",") + "]" : "undefined"},sign:${cookieMeta.sign === true ? true : cookieMeta.sign !== undefined ? typeof cookieMeta.sign == "string" ? JSON.stringify(cookieMeta.sign) : "[" + cookieMeta.sign.map((x) => JSON.stringify(x)).join(",") + "]" : "undefined"},` + get("domain") + get("expires") + get("httpOnly") + get("maxAge") + get("path", "/") + get("priority") + get("sameSite") + get("secure") + "}" : "undefined";
+    }, options = cookieMeta ? `{secrets:${cookieMeta.secrets !== undefined && cookieMeta.secrets !== null ? typeof cookieMeta.secrets == "string" ? JSON.stringify(cookieMeta.secrets) : "[" + cookieMeta.secrets.map((x) => JSON.stringify(x)).join(",") + "]" : "undefined"},sign:${cookieMeta.sign === true ? true : cookieMeta.sign !== undefined ? typeof cookieMeta.sign == "string" ? JSON.stringify(cookieMeta.sign) : "[" + cookieMeta.sign.map((x) => JSON.stringify(x)).join(",") + "]" : "undefined"},` + get("domain") + get("expires") + get("httpOnly") + get("maxAge") + get("path", "/") + get("priority") + get("sameSite") + get("secure") + "}" : "undefined";
     hasHeaders ? fnLiteral += `
 c.cookie=await parseCookie(c.set,c.headers.cookie,${options})
 ` : fnLiteral += `
@@ -40669,9 +41956,9 @@ c.cookie=await parseCookie(c.set,c.request.headers.get('cookie'),${options})
   if (hasQuery) {
     let arrayProperties = {}, objectProperties = {}, hasArrayProperty = false, hasObjectProperty = false;
     if (validator.query?.schema) {
-      const schema = unwrapImportSchema(validator.query?.schema);
-      if (Kind in schema && schema.properties)
-        for (const [key, value] of Object.entries(schema.properties))
+      const schema = unwrapImportSchema(validator.query?.schema), properties = getSchemaProperties(schema);
+      if (properties)
+        for (const [key, value] of Object.entries(properties))
           hasElysiaMeta("ArrayQuery", value) && (arrayProperties[key] = true, hasArrayProperty = true), hasElysiaMeta("ObjectString", value) && (objectProperties[key] = true, hasObjectProperty = true);
     }
     fnLiteral += `if(c.qi===-1){c.query=Object.create(null)}else{c.query=parseQueryFromURL(c.url,c.qi+1${hasArrayProperty ? "," + JSON.stringify(arrayProperties) : hasObjectProperty ? ",undefined" : ""}${hasObjectProperty ? "," + JSON.stringify(objectProperties) : ""})}`;
@@ -40706,8 +41993,8 @@ ${prefix}e.afterResponse[${i}](c)
       }
     return reporter.resolve(), afterResponse2 += `})
 `, _afterResponse = afterResponse2;
-  }, mapResponse2 = (r = "r") => {
-    const after = afterResponse(), response = `${hasSet ? "mapResponse" : "mapCompactResponse"}(${saveResponse}${r}${hasSet ? ",c.set" : ""}${mapResponseContext})
+  }, mapResponse3 = (r = "r") => {
+    const after = afterResponse(), response = `${maybeStream && maybeAsync ? "await " : ""}${hasSet ? "mapResponse" : "mapCompactResponse"}(${saveResponse}${r}${hasSet ? ",c.set" : ""}${mapResponseContext})
 `;
     return after ? `const _res=${response}` + after + "return _res" : `return ${response}`;
   }, mapResponseContext = maybeStream && adapter.mapResponseContext ? `,${adapter.mapResponseContext}` : "";
@@ -40851,7 +42138,7 @@ case 'multipart/form-data':` + adapter.parser.formData(isOptionalBody) + `break
         for (const key of Object.keys(app["~parser"]))
           fnLiteral += `case '${key}':let bo${key}=parser['${key}'](c,contentType)
 if(bo${key} instanceof Promise)bo${key}=await bo${key}
-if(bo${key} instanceof ElysiaCustomStatusResponse){` + mapResponse2(`bo${key}`) + `}if(bo${key}!==undefined)c.body=bo${key}
+if(bo${key} instanceof ElysiaCustomStatusResponse){` + mapResponse3(`bo${key}`) + `}if(bo${key}!==undefined)c.body=bo${key}
 break
 `;
         hooks.parse?.length && (fnLiteral += "}"), fnLiteral += "}";
@@ -40872,7 +42159,7 @@ delete c.contentType`);
         const transform3 = hooks.transform[i], endUnit = reporter.resolveChild(transform3.fn.name);
         fnLiteral += isAsync(transform3) ? `transformed=await e.transform[${i}](c)
 ` : `transformed=e.transform[${i}](c)
-`, transform3.subType === "mapDerive" ? fnLiteral += "if(transformed instanceof ElysiaCustomStatusResponse){" + mapResponse2("transformed") + `}else{transformed.request=c.request
+`, transform3.subType === "mapDerive" ? fnLiteral += "if(transformed instanceof ElysiaCustomStatusResponse){" + mapResponse3("transformed") + `}else{transformed.request=c.request
 transformed.store=c.store
 transformed.qi=c.qi
 transformed.path=c.path
@@ -40880,7 +42167,7 @@ transformed.url=c.url
 transformed.redirect=c.redirect
 transformed.set=c.set
 transformed.error=c.error
-c=transformed}` : fnLiteral += "if(transformed instanceof ElysiaCustomStatusResponse){" + mapResponse2("transformed") + `}else Object.assign(c,transformed)
+c=transformed}` : fnLiteral += "if(transformed instanceof ElysiaCustomStatusResponse){" + mapResponse3("transformed") + `}else Object.assign(c,transformed)
 `, endUnit();
       }
     }
@@ -40990,12 +42277,7 @@ if(vab.issues){` + validation.validate("body", undefined, "vab.issues") + `}else
               sanitize: () => app.config.sanitize
             });
             if (candidate) {
-              const isFirst = fileUnions.length === 0;
-              let properties = candidate.schema?.properties ?? type.properties;
-              if (!properties && candidate.schema?.anyOf) {
-                const objectSchema = candidate.schema.anyOf.find((s) => s.type === "object" || (Kind in s) && s[Kind] === "Object");
-                objectSchema && (properties = objectSchema.properties);
-              }
+              const isFirst = fileUnions.length === 0, properties = getSchemaProperties(candidate.schema) ?? getSchemaProperties(type);
               if (!properties)
                 continue;
               const iterator2 = Object.entries(properties);
@@ -41014,9 +42296,12 @@ if(vab.issues){` + validation.validate("body", undefined, "vab.issues") + `}else
           }
         }
       } else if (hasNonUnionFileWithDefault || !hasUnion && (hasType("File", unwrapImportSchema(validator.body.schema)) || hasType("Files", unwrapImportSchema(validator.body.schema)))) {
-        let validateFile2 = "", i = 0;
-        for (const [k, v] of Object.entries(unwrapImportSchema(validator.body.schema).properties))
-          !v.extension || v[Kind] !== "File" && v[Kind] !== "Files" || (i && (validateFile2 += ","), validateFile2 += `fileType(c.body.${k},${JSON.stringify(v.extension)},'body.${k}')`, i++);
+        let validateFile2 = "";
+        const bodyProperties = getSchemaProperties(unwrapImportSchema(validator.body.schema));
+        let i = 0;
+        if (bodyProperties)
+          for (const [k, v] of Object.entries(bodyProperties))
+            !v.extension || v[Kind] !== "File" && v[Kind] !== "Files" || (i && (validateFile2 += ","), validateFile2 += `fileType(c.body.${k},${JSON.stringify(v.extension)},'body.${k}')`, i++);
         i && (fnLiteral += `
 `), i === 1 ? fnLiteral += `await ${validateFile2}
 ` : i > 1 && (fnLiteral += `await Promise.all([${validateFile2}])
@@ -41044,7 +42329,7 @@ if(vac.issues){` + validation.validate("cookie", undefined, "vac.issues") + `}el
 let resolved
 `), fnLiteral += isAsync(beforeHandle) ? `resolved=await e.beforeHandle[${i}](c);
 ` : `resolved=e.beforeHandle[${i}](c);
-`, beforeHandle.subType === "mapResolve" ? fnLiteral += "if(resolved instanceof ElysiaCustomStatusResponse){" + mapResponse2("resolved") + `}else{resolved.request=c.request
+`, beforeHandle.subType === "mapResolve" ? fnLiteral += "if(resolved instanceof ElysiaCustomStatusResponse){" + mapResponse3("resolved") + `}else{resolved.request=c.request
 resolved.store=c.store
 resolved.qi=c.qi
 resolved.path=c.path
@@ -41052,7 +42337,7 @@ resolved.url=c.url
 resolved.redirect=c.redirect
 resolved.set=c.set
 resolved.error=c.error
-c=resolved}` : fnLiteral += "if(resolved instanceof ElysiaCustomStatusResponse){" + mapResponse2("resolved") + `}else Object.assign(c, resolved)
+c=resolved}` : fnLiteral += "if(resolved instanceof ElysiaCustomStatusResponse){" + mapResponse3("resolved") + `}else Object.assign(c, resolved)
 `, endUnit();
         else if (!returning)
           fnLiteral += isAsync(beforeHandle) ? `await e.beforeHandle[${i}](c)
@@ -41108,7 +42393,8 @@ if(mr!==undefined)be=c.response=c.responseValue=mr}`, endUnit2();
     return () => {
       hasTrace && (fnLiteral += 'if(r&&(r[Symbol.iterator]||r[Symbol.asyncIterator])&&typeof r.next==="function"){' + (maybeAsync ? "" : "(async()=>{") + `const stream=await tee(r,3)
 r=stream[0]
-const listener=stream[1]
+` + (hooks.afterHandle?.length ? `c.response=c.responseValue=r
+` : "") + `const listener=stream[1]
 ` + (hasTrace || hooks.afterResponse?.length ? `afterHandlerStreamListener=stream[2]
 ` : "") + `${setImmediateFn}(async ()=>{if(listener)for await(const v of listener){}
 `, handleReporter.resolve(), fnLiteral += "})" + (maybeAsync ? "" : "})()") + "}else{", handleReporter.resolve(), fnLiteral += `}
@@ -41146,7 +42432,7 @@ const listener=stream[1]
 if(mr!==undefined)r=c.response=c.responseValue=mr
 `, endUnit();
       }
-    mapResponseReporter.resolve(), fnLiteral += mapResponse2();
+    mapResponseReporter.resolve(), fnLiteral += mapResponse3();
   } else {
     const resolveHandler = reportHandler(isHandleFn ? handler.name : undefined);
     if (validator.response || hooks.mapResponse?.length || hasTrace) {
@@ -41170,7 +42456,7 @@ if(mr!==undefined)r=c.response=c.responseValue=mr}
       }
       mapResponseReporter.resolve(), fnLiteral += encodeCookie(), handler instanceof Response ? (fnLiteral += afterResponse(), fnLiteral += inference.set ? `if(isNotEmpty(c.set.headers)||c.set.status!==200||c.set.redirect||c.set.cookie)return mapResponse(${saveResponse}${handle}.clone(),c.set${mapResponseContext})
 else return ${handle}.clone()` : `return ${handle}.clone()`, fnLiteral += `
-`) : fnLiteral += mapResponse2();
+`) : fnLiteral += mapResponse3();
     } else if (hasCookie || hasTrace) {
       fnLiteral += isAsyncHandler ? `let r=await ${handle}
 ` : `let r=${handle}
@@ -41187,14 +42473,14 @@ else return ${handle}.clone()` : `return ${handle}.clone()`, fnLiteral += `
 if(mr!==undefined)r=c.response=c.responseValue=mr}`, endUnit();
         }
       }
-      mapResponseReporter.resolve(), fnLiteral += encodeCookie() + mapResponse2();
+      mapResponseReporter.resolve(), fnLiteral += encodeCookie() + mapResponse3();
     } else {
       resolveHandler();
       const handled = isAsyncHandler ? `await ${handle}` : handle;
       handler instanceof Response ? (fnLiteral += afterResponse(), fnLiteral += inference.set ? `if(isNotEmpty(c.set.headers)||c.set.status!==200||c.set.redirect||c.set.cookie)return mapResponse(${saveResponse}${handle}.clone(),c.set${mapResponseContext})
 else return ${handle}.clone()
 ` : `return ${handle}.clone()
-`) : fnLiteral += mapResponse2(handled);
+`) : fnLiteral += mapResponse3(handled);
     }
   }
   if (fnLiteral += `
@@ -41512,9 +42798,9 @@ error.message=error.response}if(set.status===200||!set.status)set.status=error.s
         });
         if (hooks.mapResponse?.length)
           for (let i2 = 0;i2 < hooks.mapResponse.length; i2++) {
-            const mapResponse2 = hooks.mapResponse[i2], endUnit = mapResponseReporter2.resolveChild(mapResponse2.fn.name);
+            const mapResponse3 = hooks.mapResponse[i2], endUnit = mapResponseReporter2.resolveChild(mapResponse3.fn.name);
             fnLiteral += `context.response=context.responseValue=_r
-_r=${isAsyncName(mapResponse2) ? "await " : ""}onMapResponse[${i2}](context)
+_r=${isAsyncName(mapResponse3) ? "await " : ""}onMapResponse[${i2}](context)
 `, endUnit();
           }
         mapResponseReporter2.resolve(), fnLiteral += afterResponse() + `return mapResponse(${saveResponse}_r,set${adapter.mapResponseContext})}`;
@@ -41539,8 +42825,8 @@ if(!context.response)context.response=context.responseValue=error.message??error
     fnLiteral += `let mr
 `;
     for (let i = 0;i < hooks.mapResponse.length; i++) {
-      const mapResponse2 = hooks.mapResponse[i], endUnit = mapResponseReporter.resolveChild(mapResponse2.fn.name);
-      fnLiteral += `if(mr===undefined){mr=${isAsyncName(mapResponse2) ? "await " : ""}onMapResponse[${i}](context)
+      const mapResponse3 = hooks.mapResponse[i], endUnit = mapResponseReporter.resolveChild(mapResponse3.fn.name);
+      fnLiteral += `if(mr===undefined){mr=${isAsyncName(mapResponse3) ? "await " : ""}onMapResponse[${i}](context)
 if(mr!==undefined)error=context.response=context.responseValue=mr}`, endUnit();
     }
   }
@@ -41564,587 +42850,6 @@ return mapResponse(${saveResponse}error,set${adapter.mapResponseContext})}`;
   });
 };
 
-// node_modules/elysia/dist/adapter/cloudflare-worker/index.mjs
-function isCloudflareWorker() {
-  try {
-    if (typeof caches < "u" && typeof caches.default < "u" || typeof WebSocketPair < "u")
-      return true;
-  } catch {
-    return false;
-  }
-  return false;
-}
-var CloudflareAdapter = {
-  ...WebStandardAdapter,
-  name: "cloudflare-worker",
-  composeGeneralHandler: {
-    ...WebStandardAdapter.composeGeneralHandler,
-    error404(hasEventHook, hasErrorHook, afterHandle) {
-      const { code } = WebStandardAdapter.composeGeneralHandler.error404(hasEventHook, hasErrorHook, afterHandle);
-      return {
-        code,
-        declare: hasErrorHook ? "" : `const error404Message=notFound.message.toString()
-const error404={clone:()=>new Response(error404Message,{status:404})}
-`
-      };
-    }
-  },
-  beforeCompile(app) {
-    app.handleError = composeErrorHandler(app);
-    for (const route of app.routes)
-      route.compile();
-  },
-  listen() {
-    return () => {
-      console.warn("Cloudflare Worker does not support listen method. Please export default Elysia instance instead.");
-    };
-  }
-};
-
-// node_modules/elysia/dist/sucrose.mjs
-var separateFunction = (code) => {
-  code.startsWith("async") && (code = code.slice(5)), code = code.trimStart();
-  let index = -1;
-  if (code.charCodeAt(0) === 40 && (index = code.indexOf("=>", code.indexOf(")")), index !== -1)) {
-    let bracketEndIndex = index;
-    for (;bracketEndIndex > 0 && code.charCodeAt(--bracketEndIndex) !== 41; )
-      ;
-    let body = code.slice(index + 2);
-    return body.charCodeAt(0) === 32 && (body = body.trimStart()), [
-      code.slice(1, bracketEndIndex),
-      body,
-      {
-        isArrowReturn: body.charCodeAt(0) !== 123
-      }
-    ];
-  }
-  if (/^(\w+)=>/g.test(code) && (index = code.indexOf("=>"), index !== -1)) {
-    let body = code.slice(index + 2);
-    return body.charCodeAt(0) === 32 && (body = body.trimStart()), [
-      code.slice(0, index),
-      body,
-      {
-        isArrowReturn: body.charCodeAt(0) !== 123
-      }
-    ];
-  }
-  if (code.startsWith("function")) {
-    index = code.indexOf("(");
-    const end = code.indexOf(")");
-    return [
-      code.slice(index + 1, end),
-      code.slice(end + 2),
-      {
-        isArrowReturn: false
-      }
-    ];
-  }
-  const start = code.indexOf("(");
-  if (start !== -1) {
-    const sep = code.indexOf(`
-`, 2), parameter = code.slice(0, sep), end = parameter.lastIndexOf(")") + 1, body = code.slice(sep + 1);
-    return [
-      parameter.slice(start, end),
-      "{" + body,
-      {
-        isArrowReturn: false
-      }
-    ];
-  }
-  const x = code.split(`
-`, 2);
-  return [x[0], x[1], { isArrowReturn: false }];
-};
-var bracketPairRange = (parameter) => {
-  const start = parameter.indexOf("{");
-  if (start === -1)
-    return [-1, 0];
-  let end = start + 1, deep = 1;
-  for (;end < parameter.length; end++) {
-    const char = parameter.charCodeAt(end);
-    if (char === 123 ? deep++ : char === 125 && deep--, deep === 0)
-      break;
-  }
-  return deep !== 0 ? [0, parameter.length] : [start, end + 1];
-};
-var bracketPairRangeReverse = (parameter) => {
-  const end = parameter.lastIndexOf("}");
-  if (end === -1)
-    return [-1, 0];
-  let start = end - 1, deep = 1;
-  for (;start >= 0; start--) {
-    const char = parameter.charCodeAt(start);
-    if (char === 125 ? deep++ : char === 123 && deep--, deep === 0)
-      break;
-  }
-  return deep !== 0 ? [-1, 0] : [start, end + 1];
-};
-var removeColonAlias = (parameter) => {
-  for (;; ) {
-    const start = parameter.indexOf(":");
-    if (start === -1)
-      break;
-    let end = parameter.indexOf(",", start);
-    end === -1 && (end = parameter.indexOf("}", start) - 1), end === -2 && (end = parameter.length), parameter = parameter.slice(0, start) + parameter.slice(end);
-  }
-  return parameter;
-};
-var retrieveRootParamters = (parameter) => {
-  let hasParenthesis = false;
-  parameter.charCodeAt(0) === 40 && (parameter = parameter.slice(1, -1)), parameter.charCodeAt(0) === 123 && (hasParenthesis = true, parameter = parameter.slice(1, -1)), parameter = parameter.replace(/( |\t|\n)/g, "").trim();
-  let parameters = [];
-  for (;; ) {
-    let [start, end] = bracketPairRange(parameter);
-    if (start === -1)
-      break;
-    parameters.push(parameter.slice(0, start - 1)), parameter.charCodeAt(end) === 44 && end++, parameter = parameter.slice(end);
-  }
-  parameter = removeColonAlias(parameter), parameter && (parameters = parameters.concat(parameter.split(",")));
-  const parameterMap = /* @__PURE__ */ Object.create(null);
-  for (const p of parameters) {
-    if (p.indexOf(",") === -1) {
-      parameterMap[p] = true;
-      continue;
-    }
-    for (const q of p.split(","))
-      parameterMap[q.trim()] = true;
-  }
-  return {
-    hasParenthesis,
-    parameters: parameterMap
-  };
-};
-var findParameterReference = (parameter, inference) => {
-  const { parameters, hasParenthesis } = retrieveRootParamters(parameter);
-  return parameters.query && (inference.query = true), parameters.headers && (inference.headers = true), parameters.body && (inference.body = true), parameters.cookie && (inference.cookie = true), parameters.set && (inference.set = true), parameters.server && (inference.server = true), parameters.route && (inference.route = true), parameters.url && (inference.url = true), parameters.path && (inference.path = true), hasParenthesis ? `{ ${Object.keys(parameters).join(", ")} }` : Object.keys(parameters).join(", ");
-};
-var findEndIndex = (type, content, index) => {
-  const regex2 = new RegExp(`${type.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\n\\t,; ]`);
-  index !== undefined && (regex2.lastIndex = index);
-  const match = regex2.exec(content);
-  return match ? match.index : -1;
-};
-var findAlias = (type, body, depth = 0) => {
-  if (depth > 5)
-    return [];
-  const aliases = [];
-  let content = body;
-  for (;; ) {
-    let index = findEndIndex(" = " + type, content);
-    if (index === -1 && (index = findEndIndex("=" + type, content)), index === -1) {
-      let lastIndex = content.indexOf(" = " + type);
-      if (lastIndex === -1 && (lastIndex = content.indexOf("=" + type)), lastIndex + 3 + type.length !== content.length)
-        break;
-      index = lastIndex;
-    }
-    const part = content.slice(0, index), lastPart = part.lastIndexOf(" ");
-    let variable = part.slice(lastPart !== -1 ? lastPart + 1 : -1);
-    if (variable === "}") {
-      const [start, end] = bracketPairRangeReverse(part);
-      aliases.push(removeColonAlias(content.slice(start, end))), content = content.slice(index + 3 + type.length);
-      continue;
-    }
-    for (;variable.charCodeAt(0) === 44; )
-      variable = variable.slice(1);
-    for (;variable.charCodeAt(0) === 9; )
-      variable = variable.slice(1);
-    variable.includes("(") || aliases.push(variable), content = content.slice(index + 3 + type.length);
-  }
-  for (const alias of aliases) {
-    if (alias.charCodeAt(0) === 123)
-      continue;
-    const deepAlias = findAlias(alias, body);
-    deepAlias.length > 0 && aliases.push(...deepAlias);
-  }
-  return aliases;
-};
-var extractMainParameter = (parameter) => {
-  if (!parameter)
-    return;
-  if (parameter.charCodeAt(0) !== 123)
-    return parameter;
-  if (parameter = parameter.slice(2, -2), !parameter.includes(","))
-    return parameter.indexOf("...") !== -1 ? parameter.slice(parameter.indexOf("...") + 3) : undefined;
-  const spreadIndex = parameter.indexOf("...");
-  if (spreadIndex !== -1)
-    return parameter.slice(spreadIndex + 3).trimEnd();
-};
-var inferBodyReference = (code, aliases, inference) => {
-  const access = (type, alias) => new RegExp(`${alias}\\.(${type})|${alias}\\["${type}"\\]|${alias}\\['${type}'\\]`).test(code);
-  for (const alias of aliases)
-    if (alias) {
-      if (alias.charCodeAt(0) === 123) {
-        const parameters = retrieveRootParamters(alias).parameters;
-        parameters.query && (inference.query = true), parameters.headers && (inference.headers = true), parameters.body && (inference.body = true), parameters.cookie && (inference.cookie = true), parameters.set && (inference.set = true), parameters.server && (inference.server = true), parameters.url && (inference.url = true), parameters.route && (inference.route = true), parameters.path && (inference.path = true);
-        continue;
-      }
-      if (!inference.query && (access("query", alias) || code.includes("return " + alias) || code.includes("return " + alias + ".query")) && (inference.query = true), !inference.headers && access("headers", alias) && (inference.headers = true), !inference.body && access("body", alias) && (inference.body = true), !inference.cookie && access("cookie", alias) && (inference.cookie = true), !inference.set && access("set", alias) && (inference.set = true), !inference.server && access("server", alias) && (inference.server = true), !inference.route && access("route", alias) && (inference.route = true), !inference.url && access("url", alias) && (inference.url = true), !inference.path && access("path", alias) && (inference.path = true), inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.server && inference.route && inference.url && inference.path)
-        break;
-    }
-  return aliases;
-};
-var isContextPassToFunction = (context, body, inference) => {
-  try {
-    const captureFunction = new RegExp(`\\w\\((?:.*?)?${context}(?:.*?)?\\)`, "gs"), exactParameter = new RegExp(`${context}(,|\\))`, "gs"), length = body.length;
-    let fn;
-    for (fn = captureFunction.exec(body) + "";captureFunction.lastIndex !== 0 && captureFunction.lastIndex < length + (fn ? fn.length : 0); ) {
-      if (fn && exactParameter.test(fn))
-        return inference.query = true, inference.headers = true, inference.body = true, inference.cookie = true, inference.set = true, inference.server = true, inference.url = true, inference.route = true, inference.path = true, true;
-      fn = captureFunction.exec(body) + "";
-    }
-    const nextChar = body.charCodeAt(captureFunction.lastIndex);
-    return nextChar === 41 || nextChar === 44 ? (inference.query = true, inference.headers = true, inference.body = true, inference.cookie = true, inference.set = true, inference.server = true, inference.url = true, inference.route = true, inference.path = true, true) : false;
-  } catch {
-    return console.log("[Sucrose] warning: unexpected isContextPassToFunction error, you may continue development as usual but please report the following to maintainers:"), console.log("--- body ---"), console.log(body), console.log("--- context ---"), console.log(context), true;
-  }
-};
-var pendingGC;
-var caches2 = {};
-var clearSucroseCache = (delay) => {
-  delay === null || isCloudflareWorker() || (delay === undefined && (delay = 4 * 60 * 1000 + 55 * 1000), pendingGC && clearTimeout(pendingGC), pendingGC = setTimeout(() => {
-    caches2 = {}, pendingGC = undefined, isBun && Bun.gc(false);
-  }, delay), pendingGC.unref?.());
-};
-var mergeInference = (a, b) => ({
-  body: a.body || b.body,
-  cookie: a.cookie || b.cookie,
-  headers: a.headers || b.headers,
-  query: a.query || b.query,
-  set: a.set || b.set,
-  server: a.server || b.server,
-  url: a.url || b.url,
-  route: a.route || b.route,
-  path: a.path || b.path
-});
-var sucrose = (lifeCycle, inference = {
-  query: false,
-  headers: false,
-  body: false,
-  cookie: false,
-  set: false,
-  server: false,
-  url: false,
-  route: false,
-  path: false
-}, settings = {}) => {
-  const events = [];
-  lifeCycle.request?.length && events.push(...lifeCycle.request), lifeCycle.beforeHandle?.length && events.push(...lifeCycle.beforeHandle), lifeCycle.parse?.length && events.push(...lifeCycle.parse), lifeCycle.error?.length && events.push(...lifeCycle.error), lifeCycle.transform?.length && events.push(...lifeCycle.transform), lifeCycle.afterHandle?.length && events.push(...lifeCycle.afterHandle), lifeCycle.mapResponse?.length && events.push(...lifeCycle.mapResponse), lifeCycle.afterResponse?.length && events.push(...lifeCycle.afterResponse), lifeCycle.handler && typeof lifeCycle.handler == "function" && events.push(lifeCycle.handler);
-  for (let i = 0;i < events.length; i++) {
-    const e = events[i];
-    if (!e)
-      continue;
-    const event = typeof e == "object" ? e.fn : e;
-    if (typeof event != "function")
-      continue;
-    const content = event.toString(), key = checksum(content), cachedInference = caches2[key];
-    if (cachedInference) {
-      inference = mergeInference(inference, cachedInference);
-      continue;
-    }
-    clearSucroseCache(settings.gcTime);
-    const fnInference = {
-      query: false,
-      headers: false,
-      body: false,
-      cookie: false,
-      set: false,
-      server: false,
-      url: false,
-      route: false,
-      path: false
-    }, [parameter, body] = separateFunction(content), rootParameters = findParameterReference(parameter, fnInference), mainParameter = extractMainParameter(rootParameters);
-    if (mainParameter) {
-      const aliases = findAlias(mainParameter, body.slice(1, -1));
-      aliases.splice(0, -1, mainParameter);
-      let code = body;
-      code.charCodeAt(0) === 123 && code.charCodeAt(body.length - 1) === 125 && (code = code.slice(1, -1).trim()), isContextPassToFunction(mainParameter, code, fnInference) || inferBodyReference(code, aliases, fnInference), !fnInference.query && code.includes("return " + mainParameter + ".query") && (fnInference.query = true);
-    }
-    if (caches2[key] || (caches2[key] = fnInference), inference = mergeInference(inference, fnInference), inference.query && inference.headers && inference.body && inference.cookie && inference.set && inference.server && inference.url && inference.route && inference.path)
-      break;
-  }
-  return inference;
-};
-
-// node_modules/elysia/dist/adapter/bun/handler.mjs
-var mapResponse2 = (response, set2, request) => {
-  if (isNotEmpty(set2.headers) || set2.status !== 200 || set2.cookie)
-    switch (handleSet(set2), response?.constructor?.name) {
-      case "String":
-        return new Response(response, set2);
-      case "Array":
-      case "Object":
-        return set2.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set2);
-      case "ElysiaFile":
-        return handleFile(response.value, set2);
-      case "File":
-        return handleFile(response, set2);
-      case "Blob":
-        return handleFile(response, set2);
-      case "ElysiaCustomStatusResponse":
-        return set2.status = response.code, mapResponse2(response.response, set2, request);
-      case undefined:
-        return response ? new Response(JSON.stringify(response), set2) : new Response("", set2);
-      case "Response":
-        return handleResponse2(response, set2, request);
-      case "Error":
-        return errorToResponse2(response, set2);
-      case "Promise":
-        return response.then((x) => mapResponse2(x, set2, request));
-      case "Function":
-        return mapResponse2(response(), set2, request);
-      case "Number":
-      case "Boolean":
-        return new Response(response.toString(), set2);
-      case "Cookie":
-        return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
-      case "FormData":
-        return new Response(response, set2);
-      default:
-        if (response instanceof Response)
-          return handleResponse2(response, set2, request);
-        if (response instanceof Promise)
-          return response.then((x) => mapResponse2(x, set2));
-        if (response instanceof Error)
-          return errorToResponse2(response, set2);
-        if (response instanceof ElysiaCustomStatusResponse)
-          return set2.status = response.code, mapResponse2(response.response, set2, request);
-        if (typeof response?.next == "function" || response instanceof ReadableStream)
-          return handleStream2(response, set2, request);
-        if (typeof response?.then == "function")
-          return response.then((x) => mapResponse2(x, set2));
-        if (typeof response?.toResponse == "function")
-          return mapResponse2(response.toResponse(), set2);
-        if ("charCodeAt" in response) {
-          const code = response.charCodeAt(0);
-          if (code === 123 || code === 91)
-            return set2.headers["Content-Type"] || (set2.headers["Content-Type"] = "application/json"), new Response(JSON.stringify(response), set2);
-        }
-        return new Response(response, set2);
-    }
-  return typeof response?.next == "function" || response instanceof ReadableStream ? handleStream2(response, set2, request) : mapCompactResponse2(response, request);
-};
-var mapEarlyResponse2 = (response, set2, request) => {
-  if (response != null)
-    if (isNotEmpty(set2.headers) || set2.status !== 200 || set2.cookie)
-      switch (handleSet(set2), response?.constructor?.name) {
-        case "String":
-          return new Response(response, set2);
-        case "Array":
-        case "Object":
-          return set2.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set2);
-        case "ElysiaFile":
-          return handleFile(response.value, set2);
-        case "File":
-          return handleFile(response, set2);
-        case "Blob":
-          return handleFile(response, set2);
-        case "ElysiaCustomStatusResponse":
-          return set2.status = response.code, mapEarlyResponse2(response.response, set2, request);
-        case undefined:
-          return response ? new Response(JSON.stringify(response), set2) : undefined;
-        case "Response":
-          return handleResponse2(response, set2, request);
-        case "Promise":
-          return response.then((x) => mapEarlyResponse2(x, set2));
-        case "Error":
-          return errorToResponse2(response, set2);
-        case "Function":
-          return mapEarlyResponse2(response(), set2);
-        case "Number":
-        case "Boolean":
-          return new Response(response.toString(), set2);
-        case "FormData":
-          return new Response(response);
-        case "Cookie":
-          return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
-        default:
-          if (response instanceof Response)
-            return handleResponse2(response, set2, request);
-          if (response instanceof Promise)
-            return response.then((x) => mapEarlyResponse2(x, set2));
-          if (response instanceof Error)
-            return errorToResponse2(response, set2);
-          if (response instanceof ElysiaCustomStatusResponse)
-            return set2.status = response.code, mapEarlyResponse2(response.response, set2, request);
-          if (typeof response?.next == "function" || response instanceof ReadableStream)
-            return handleStream2(response, set2, request);
-          if (typeof response?.then == "function")
-            return response.then((x) => mapEarlyResponse2(x, set2));
-          if (typeof response?.toResponse == "function")
-            return mapEarlyResponse2(response.toResponse(), set2);
-          if ("charCodeAt" in response) {
-            const code = response.charCodeAt(0);
-            if (code === 123 || code === 91)
-              return set2.headers["Content-Type"] || (set2.headers["Content-Type"] = "application/json"), new Response(JSON.stringify(response), set2);
-          }
-          return new Response(response, set2);
-      }
-    else
-      switch (response?.constructor?.name) {
-        case "String":
-          return new Response(response);
-        case "Array":
-        case "Object":
-          return set2.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set2);
-        case "ElysiaFile":
-          return handleFile(response.value, set2);
-        case "File":
-          return handleFile(response, set2);
-        case "Blob":
-          return handleFile(response, set2);
-        case "ElysiaCustomStatusResponse":
-          return set2.status = response.code, mapEarlyResponse2(response.response, set2, request);
-        case undefined:
-          return response ? new Response(JSON.stringify(response), {
-            headers: {
-              "content-type": "application/json"
-            }
-          }) : new Response("");
-        case "Response":
-          return response;
-        case "Promise":
-          return response.then((x) => {
-            const r = mapEarlyResponse2(x, set2);
-            if (r !== undefined)
-              return r;
-          });
-        case "Error":
-          return errorToResponse2(response, set2);
-        case "Function":
-          return mapCompactResponse2(response(), request);
-        case "Number":
-        case "Boolean":
-          return new Response(response.toString());
-        case "Cookie":
-          return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
-        case "FormData":
-          return new Response(response);
-        default:
-          if (response instanceof Response)
-            return response;
-          if (response instanceof Promise)
-            return response.then((x) => mapEarlyResponse2(x, set2));
-          if (response instanceof Error)
-            return errorToResponse2(response, set2);
-          if (response instanceof ElysiaCustomStatusResponse)
-            return set2.status = response.code, mapEarlyResponse2(response.response, set2, request);
-          if (typeof response?.next == "function" || response instanceof ReadableStream)
-            return handleStream2(response, set2, request);
-          if (typeof response?.then == "function")
-            return response.then((x) => mapEarlyResponse2(x, set2));
-          if (typeof response?.toResponse == "function")
-            return mapEarlyResponse2(response.toResponse(), set2);
-          if ("charCodeAt" in response) {
-            const code = response.charCodeAt(0);
-            if (code === 123 || code === 91)
-              return set2.headers["Content-Type"] || (set2.headers["Content-Type"] = "application/json"), new Response(JSON.stringify(response), set2);
-          }
-          return new Response(response);
-      }
-};
-var mapCompactResponse2 = (response, request) => {
-  switch (response?.constructor?.name) {
-    case "String":
-      return new Response(response);
-    case "Object":
-    case "Array":
-      return new Response(JSON.stringify(response), {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-    case "ElysiaFile":
-      return handleFile(response.value);
-    case "File":
-      return handleFile(response);
-    case "Blob":
-      return handleFile(response);
-    case "ElysiaCustomStatusResponse":
-      return mapResponse2(response.response, {
-        status: response.code,
-        headers: {}
-      });
-    case undefined:
-      return response ? new Response(JSON.stringify(response), {
-        headers: {
-          "content-type": "application/json"
-        }
-      }) : new Response("");
-    case "Response":
-      return response;
-    case "Error":
-      return errorToResponse2(response);
-    case "Promise":
-      return response.then((x) => mapCompactResponse2(x, request));
-    case "Function":
-      return mapCompactResponse2(response(), request);
-    case "Number":
-    case "Boolean":
-      return new Response(response.toString());
-    case "FormData":
-      return new Response(response);
-    default:
-      if (response instanceof Response)
-        return response;
-      if (response instanceof Promise)
-        return response.then((x) => mapCompactResponse2(x, request));
-      if (response instanceof Error)
-        return errorToResponse2(response);
-      if (response instanceof ElysiaCustomStatusResponse)
-        return mapResponse2(response.response, {
-          status: response.code,
-          headers: {}
-        });
-      if (typeof response?.next == "function" || response instanceof ReadableStream)
-        return handleStream2(response, undefined, request);
-      if (typeof response?.then == "function")
-        return response.then((x) => mapCompactResponse2(x, request));
-      if (typeof response?.toResponse == "function")
-        return mapCompactResponse2(response.toResponse());
-      if ("charCodeAt" in response) {
-        const code = response.charCodeAt(0);
-        if (code === 123 || code === 91)
-          return new Response(JSON.stringify(response), {
-            headers: {
-              "Content-Type": "application/json"
-            }
-          });
-      }
-      return new Response(response);
-  }
-};
-var errorToResponse2 = (error2, set2) => {
-  if (typeof error2?.toResponse == "function") {
-    const raw = error2.toResponse(), targetSet = set2 ?? { headers: {}, status: 200, redirect: "" }, apply = (resolved) => (resolved instanceof Response && (targetSet.status = resolved.status), mapResponse2(resolved, targetSet));
-    return typeof raw?.then == "function" ? raw.then(apply) : apply(raw);
-  }
-  return new Response(JSON.stringify({
-    name: error2?.name,
-    message: error2?.message,
-    cause: error2?.cause
-  }), {
-    status: set2?.status !== 200 ? set2?.status ?? 500 : 500,
-    headers: set2?.headers
-  });
-};
-var createStaticHandler2 = (handle, hooks, setHeaders = {}) => {
-  if (typeof handle == "function")
-    return;
-  const response = mapResponse2(handle, {
-    headers: setHeaders
-  });
-  if (!hooks.parse?.length && !hooks.transform?.length && !hooks.beforeHandle?.length && !hooks.afterHandle?.length)
-    return () => response.clone();
-};
-var handleResponse2 = createResponseHandler({
-  mapResponse: mapResponse2,
-  mapCompactResponse: mapCompactResponse2
-});
-var handleStream2 = createStreamHandler({
-  mapResponse: mapResponse2,
-  mapCompactResponse: mapCompactResponse2
-});
-
 // node_modules/elysia/dist/adapter/bun/compose.mjs
 var allocateIf2 = (value, condition) => condition ? value : "";
 var createContext = (app, route, inference, isInline = false) => {
@@ -42202,7 +42907,7 @@ var createNativeStaticHandler = (handle, hooks, set2) => {
     return;
   if (isHTMLBundle(handle))
     return () => handle;
-  const response = mapResponse2(handle, set2 ?? {
+  const response = mapResponse2(handle instanceof Response ? handle.clone() : handle instanceof Promise ? handle.then((x) => x instanceof Response ? x.clone() : x) : handle, set2 ?? {
     headers: {}
   });
   if (!hooks.parse?.length && !hooks.transform?.length && !hooks.beforeHandle?.length && !hooks.afterHandle?.length)
@@ -42388,6 +43093,11 @@ var mergeRoutes = (r1, r2) => {
     }
   return r1;
 };
+var removeTrailingPath = (routes) => {
+  for (const key of Object.keys(routes))
+    key.charCodeAt(key.length - 1) === 47 && (routes[key.slice(0, -1)] = routes[key], delete routes[key]);
+  return routes;
+};
 var BunAdapter = {
   ...WebStandardAdapter,
   name: "bun",
@@ -42444,13 +43154,13 @@ for(const [k,v] of c.request.headers.entries())c.headers[k]=v
             staticRoutes[path2] = route;
           }
         return withAsync ? Promise.all(ops).then(() => staticRoutes) : staticRoutes;
-      }, serve = typeof options == "object" ? {
+      }, routes = removeTrailingPath(mergeRoutes(mergeRoutes(createStaticRoute(app.router.response), mapRoutes(app)), app.config.serve?.routes)), serve = typeof options == "object" ? {
         development: !isProduction2,
         reusePort: true,
         idleTimeout: 30,
         ...app.config.serve || {},
         ...options || {},
-        routes: mergeRoutes(mergeRoutes(createStaticRoute(app.router.response), mapRoutes(app)), app.config.serve?.routes),
+        routes,
         websocket: {
           ...app.config.websocket || {},
           ...websocket || {},
@@ -42462,7 +43172,7 @@ for(const [k,v] of c.request.headers.entries())c.headers[k]=v
         reusePort: true,
         idleTimeout: 30,
         ...app.config.serve || {},
-        routes: mergeRoutes(mergeRoutes(createStaticRoute(app.router.response), mapRoutes(app)), app.config.serve?.routes),
+        routes,
         websocket: {
           ...app.config.websocket || {},
           ...websocket || {}
@@ -42478,12 +43188,14 @@ for(const [k,v] of c.request.headers.entries())c.headers[k]=v
           for (let i = 0;i < app.event.stop.length; i++)
             app.event.stop[i].fn(app);
       }), app.promisedModules.then(async () => {
-        app.config.aot, app.compile(), app.server?.reload({
+        app.config.aot, app.compile();
+        const routes2 = removeTrailingPath(mergeRoutes(mergeRoutes(await createStaticRoute(app.router.response, {
+          withAsync: true
+        }), mapRoutes(app)), app.config.serve?.routes));
+        app.server?.reload({
           ...serve,
           fetch: app.fetch,
-          routes: mergeRoutes(mergeRoutes(await createStaticRoute(app.router.response, {
-            withAsync: true
-          }), mapRoutes(app)), app.config.serve?.routes)
+          routes: routes2
         }), Bun?.gc(false);
       });
     };
@@ -42593,10 +43305,81 @@ for(const [k,v] of c.request.headers.entries())c.headers[k]=v
 };
 
 // node_modules/elysia/dist/dynamic-handle.mjs
+var ARRAY_INDEX_REGEX = /^(.+)\[(\d+)\]$/;
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var isDangerousKey = (key) => {
+  if (DANGEROUS_KEYS.has(key))
+    return true;
+  const match = key.match(ARRAY_INDEX_REGEX);
+  return match ? DANGEROUS_KEYS.has(match[1]) : false;
+};
+var parseArrayKey = (key) => {
+  const match = key.match(ARRAY_INDEX_REGEX);
+  return match ? {
+    name: match[1],
+    index: parseInt(match[2], 10)
+  } : null;
+};
+var parseObjectString = (entry) => {
+  if (!(typeof entry != "string" || entry.charCodeAt(0) !== 123))
+    try {
+      const parsed = JSON.parse(entry);
+      if (parsed && typeof parsed == "object" && !Array.isArray(parsed))
+        return parsed;
+    } catch {
+      return;
+    }
+};
+var setNestedValue = (obj, path2, value) => {
+  const keys = path2.split("."), lastKey = keys.pop();
+  if (isDangerousKey(lastKey) || keys.some(isDangerousKey))
+    return;
+  let current = obj;
+  for (const key of keys) {
+    const arrayInfo2 = parseArrayKey(key);
+    if (arrayInfo2) {
+      Array.isArray(current[arrayInfo2.name]) || (current[arrayInfo2.name] = []);
+      const existing = current[arrayInfo2.name][arrayInfo2.index], isFile = typeof File < "u" && existing instanceof File;
+      (!existing || typeof existing != "object" || Array.isArray(existing) || isFile) && (current[arrayInfo2.name][arrayInfo2.index] = parseObjectString(existing) ?? {}), current = current[arrayInfo2.name][arrayInfo2.index];
+    } else
+      (!current[key] || typeof current[key] != "object") && (current[key] = {}), current = current[key];
+  }
+  const arrayInfo = parseArrayKey(lastKey);
+  arrayInfo ? (Array.isArray(current[arrayInfo.name]) || (current[arrayInfo.name] = []), current[arrayInfo.name][arrayInfo.index] = value) : current[lastKey] = value;
+};
+var normalizeFormValue = (value) => {
+  if (value.length === 1) {
+    const stringValue2 = value[0];
+    if (typeof stringValue2 == "string" && (stringValue2.charCodeAt(0) === 123 || stringValue2.charCodeAt(0) === 91))
+      try {
+        const parsed2 = JSON.parse(stringValue2);
+        if (parsed2 && typeof parsed2 == "object")
+          return parsed2;
+      } catch {}
+    return value[0];
+  }
+  const stringValue = value.find((entry) => typeof entry == "string");
+  if (!stringValue || typeof File > "u")
+    return value;
+  const files = value.filter((entry) => entry instanceof File);
+  if (!files.length || stringValue.charCodeAt(0) !== 123)
+    return value;
+  let parsed;
+  try {
+    parsed = JSON.parse(stringValue);
+  } catch {
+    return value;
+  }
+  return typeof parsed != "object" || parsed === null ? value : (!("file" in parsed) && files.length === 1 ? parsed.file = files[0] : !("files" in parsed) && files.length > 1 && (parsed.files = files), parsed);
+};
 var injectDefaultValues = (typeChecker, obj) => {
   let schema = typeChecker.schema;
-  if (schema && (schema.$defs?.[schema.$ref] && (schema = schema.$defs[schema.$ref]), !!schema?.properties))
-    for (const [key, keySchema] of Object.entries(schema.properties))
+  if (!schema)
+    return;
+  schema.$defs?.[schema.$ref] && (schema = schema.$defs[schema.$ref]);
+  const properties = getSchemaProperties(schema);
+  if (properties)
+    for (const [key, keySchema] of Object.entries(properties))
       obj[key] ??= keySchema.default;
 };
 var createDynamicHandler = (app) => {
@@ -42653,8 +43436,8 @@ var createDynamicHandler = (app) => {
               for (const key of form2.keys()) {
                 if (body[key])
                   continue;
-                const value = form2.getAll(key);
-                value.length === 1 ? body[key] = value[0] : body[key] = value;
+                const value = form2.getAll(key), finalValue = normalizeFormValue(value);
+                key.includes(".") || key.includes("[") ? setNestedValue(body, key, finalValue) : body[key] = finalValue;
               }
               break;
             }
@@ -42691,8 +43474,8 @@ var createDynamicHandler = (app) => {
                       for (const key of form2.keys()) {
                         if (body[key])
                           continue;
-                        const value = form2.getAll(key);
-                        value.length === 1 ? body[key] = value[0] : body[key] = value;
+                        const value = form2.getAll(key), finalValue = normalizeFormValue(value);
+                        key.includes(".") || key.includes("[") ? setNestedValue(body, key, finalValue) : body[key] = finalValue;
                       }
                       break;
                     }
@@ -42736,8 +43519,8 @@ var createDynamicHandler = (app) => {
                   for (const key of form2.keys()) {
                     if (body[key])
                       continue;
-                    const value = form2.getAll(key);
-                    value.length === 1 ? body[key] = value[0] : body[key] = value;
+                    const value = form2.getAll(key), finalValue = normalizeFormValue(value);
+                    key.includes(".") || key.includes("[") ? setNestedValue(body, key, finalValue) : body[key] = finalValue;
                   }
                   break;
                 }
@@ -42791,11 +43574,12 @@ var createDynamicHandler = (app) => {
         if (validator.params?.Decode && (context.params = validator.params.Decode(context.params)), validator.query?.schema) {
           let schema = validator.query.schema;
           schema.$defs?.[schema.$ref] && (schema = schema.$defs[schema.$ref]);
-          const properties = schema.properties;
-          for (const property of Object.keys(properties)) {
-            const value = properties[property];
-            (value.type === "array" || value.items?.type === "string") && typeof context.query[property] == "string" && context.query[property] && (context.query[property] = context.query[property].split(","));
-          }
+          const properties = getSchemaProperties(schema);
+          if (properties)
+            for (const property of Object.keys(properties)) {
+              const value = properties[property];
+              (value.type === "array" || value.items?.type === "string") && typeof context.query[property] == "string" && context.query[property] && (context.query[property] = context.query[property].split(","));
+            }
         }
         if (queryValidator?.Check(context.query) === false)
           throw new ValidationError2("query", validator.query, context.query);
@@ -42809,7 +43593,10 @@ var createDynamicHandler = (app) => {
         }
         if (validator.createBody?.()?.Check(body) === false)
           throw new ValidationError2("body", validator.body, body);
-        validator.body?.Decode && (context.body = validator.body.Decode(body));
+        if (validator.body?.Decode) {
+          let decoded = validator.body.Decode(body);
+          decoded instanceof Promise && (decoded = await decoded), context.body = decoded?.value ?? decoded;
+        }
       }
       if (hooks.beforeHandle)
         for (let i = 0;i < hooks.beforeHandle.length; i++) {
@@ -42845,14 +43632,21 @@ var createDynamicHandler = (app) => {
           isCustomStatuResponse && (set2.status = status2, response2 = response2.response);
           const responseValidator = validator?.createResponse?.()?.[status2];
           if (responseValidator?.Check(response2) === false)
-            if (responseValidator?.Clean) {
-              const temp = responseValidator.Clean(response2);
-              if (responseValidator?.Check(temp) === false)
-                throw new ValidationError2("response", responseValidator, response2);
-              response2 = temp;
-            } else
+            if (responseValidator?.Clean)
+              try {
+                const temp = responseValidator.Clean(response2);
+                if (responseValidator?.Check(temp) === false)
+                  throw new ValidationError2("response", responseValidator, response2);
+                response2 = temp;
+              } catch (error2) {
+                throw error2 instanceof ValidationError2 ? error2 : new ValidationError2("response", responseValidator, response2);
+              }
+            else
               throw new ValidationError2("response", responseValidator, response2);
-          responseValidator?.Encode && (context.response = response2 = responseValidator.Encode(response2)), responseValidator?.Clean && (context.response = response2 = responseValidator.Clean(response2));
+          if (responseValidator?.Encode && (context.response = response2 = responseValidator.Encode(response2)), responseValidator?.Clean)
+            try {
+              context.response = response2 = responseValidator.Clean(response2);
+            } catch {}
           const result = mapEarlyResponse3(response2, context.set);
           if (result !== undefined)
             return context.response = result;
@@ -42862,14 +43656,21 @@ var createDynamicHandler = (app) => {
         isCustomStatuResponse && (set2.status = status2, response = response.response);
         const responseValidator = validator?.createResponse?.()?.[status2];
         if (responseValidator?.Check(response) === false)
-          if (responseValidator?.Clean) {
-            const temp = responseValidator.Clean(response);
-            if (responseValidator?.Check(temp) === false)
-              throw new ValidationError2("response", responseValidator, response);
-            response = temp;
-          } else
+          if (responseValidator?.Clean)
+            try {
+              const temp = responseValidator.Clean(response);
+              if (responseValidator?.Check(temp) === false)
+                throw new ValidationError2("response", responseValidator, response);
+              response = temp;
+            } catch (error2) {
+              throw error2 instanceof ValidationError2 ? error2 : new ValidationError2("response", responseValidator, response);
+            }
+          else
             throw new ValidationError2("response", responseValidator, response);
-        responseValidator?.Encode && (response = responseValidator.Encode(response)), responseValidator?.Clean && (response = responseValidator.Clean(response));
+        if (responseValidator?.Encode && (response = responseValidator.Encode(response)), responseValidator?.Clean)
+          try {
+            response = responseValidator.Clean(response);
+          } catch {}
       }
       if (context.set.cookie && cookieMeta?.sign) {
         const secret = cookieMeta.secrets ? typeof cookieMeta.secrets == "string" ? cookieMeta.secrets : cookieMeta.secrets[0] : undefined;
@@ -42878,10 +43679,10 @@ var createDynamicHandler = (app) => {
             for (const [key, cookie] of Object.entries(context.set.cookie))
               context.set.cookie[key].value = await signCookie(cookie.value, secret);
         } else {
-          const properties = validator?.cookie?.schema?.properties;
+          const properties = getSchemaProperties(validator?.cookie?.schema);
           if (secret)
             for (const name of cookieMeta.sign)
-              name in properties && context.set.cookie[name]?.value && (context.set.cookie[name].value = await signCookie(context.set.cookie[name].value, secret));
+              !properties || !(name in properties) || context.set.cookie[name]?.value && (context.set.cookie[name].value = await signCookie(context.set.cookie[name].value, secret));
         }
       }
       return mapResponse3(context.response = response, context.set);
@@ -43512,7 +44313,7 @@ var _Elysia = class _Elysia2 {
     }, this.inference, this.config.sucrose));
     for (const handle of handles) {
       const fn = asHookType(handle, "global", { skipIfHasType: true });
-      switch (type) {
+      switch ((this.config.name || this.config.seed) && (fn.checksum = checksum(this.config.name + JSON.stringify(this.config.seed))), type) {
         case "start":
           this.event.start ??= [], this.event.start.push(fn);
           break;
@@ -43898,19 +44699,7 @@ var _Elysia = class _Elysia2 {
     if (path2 instanceof _Elysia2 || typeof path2 == "function" || path2.length === 0 || path2 === "/") {
       const run = typeof path2 == "function" ? path2 : path2 instanceof _Elysia2 ? path2.compile().fetch : handleOrConfig instanceof _Elysia2 ? handleOrConfig.compile().fetch : typeof handleOrConfig == "function" ? handleOrConfig : (() => {
         throw new Error("Invalid handler");
-      })(), handler2 = ({ request, path: path22 }) => run(new Request(replaceUrlPath(request.url, path22), {
-        method: request.method,
-        headers: request.headers,
-        signal: request.signal,
-        credentials: request.credentials,
-        referrerPolicy: request.referrerPolicy,
-        duplex: request.duplex,
-        redirect: request.redirect,
-        mode: request.mode,
-        keepalive: request.keepalive,
-        integrity: request.integrity,
-        body: request.body
-      }));
+      })(), handler2 = ({ request, path: path22 }) => run(new Request(replaceUrlPath(request.url, path22), request));
       return this.route("ALL", "/*", handler2, {
         parse: "none",
         ...config3,
@@ -43925,19 +44714,7 @@ var _Elysia = class _Elysia2 {
     }
     const handle = handleOrConfig instanceof _Elysia2 ? handleOrConfig.compile().fetch : typeof handleOrConfig == "function" ? handleOrConfig : (() => {
       throw new Error("Invalid handler");
-    })(), length = (typeof path2 == "string" && this.config.prefix ? this.config.prefix + path2 : path2).length - (path2.endsWith("*") ? 1 : 0), handler = ({ request, path: path22 }) => handle(new Request(replaceUrlPath(request.url, path22.slice(length) || "/"), {
-      method: request.method,
-      headers: request.headers,
-      signal: request.signal,
-      credentials: request.credentials,
-      referrerPolicy: request.referrerPolicy,
-      duplex: request.duplex,
-      redirect: request.redirect,
-      mode: request.mode,
-      keepalive: request.keepalive,
-      integrity: request.integrity,
-      body: request.body
-    }));
+    })(), length = (typeof path2 == "string" && this.config.prefix ? this.config.prefix + path2 : path2).length - (path2.endsWith("*") ? 1 : 0), handler = ({ request, path: path22 }) => handle(new Request(replaceUrlPath(request.url, path22.slice(length) || "/"), request));
     return this.route("ALL", path2, handler, {
       parse: "none",
       ...config3,
@@ -44430,6 +45207,14 @@ function showVersion() {
   console.log(`kanbo-mcp v${SERVER_INFO.version}`);
 }
 async function startMcpServer() {
+  if (CONFIG.TRANSPORT === "http") {
+    printBanner();
+    await startHttpServer();
+  } else {
+    await startStdioServer();
+  }
+}
+function printBanner() {
   console.error("═══════════════════════════════════════════════════════════════");
   console.error(`  Kanbo MCP Server v${SERVER_INFO.version}`);
   console.error("  AI-native project management via Model Context Protocol");
@@ -44438,11 +45223,6 @@ async function startMcpServer() {
   console.error(`  API URL: ${CONFIG.KANBO_API_URL}`);
   console.error(`  API Key: ${CONFIG.KANBO_API_KEY ? "***configured***" : "NOT SET"}`);
   console.error("═══════════════════════════════════════════════════════════════");
-  if (CONFIG.TRANSPORT === "http") {
-    await startHttpServer();
-  } else {
-    await startStdioServer();
-  }
 }
 async function main() {
   const command = process.argv[2];
@@ -44466,4 +45246,7 @@ async function main() {
     process.exit(1);
   }
 }
-main();
+main().catch((error2) => {
+  console.error("[kanbo-mcp] Unhandled fatal error:", error2);
+  process.exit(1);
+});