@donezone/cli 0.1.41 → 0.1.43

package/dist/index.js

@@ -8618,6 +8618,10 @@ var require_bn = __commonJS((exports, module) => {
         var mask = 67108863 ^ 67108863 >>> r << r;
         this.words[this.length - 1] &= mask;
       }
+      if (this.length === 0) {
+        this.words[0] = 0;
+        this.length = 1;
+      }
       return this.strip();
     };
     BN.prototype.maskn = function maskn(bits) {
@@ -16952,12 +16956,18 @@ var require_immutable = __commonJS((exports, module) => {
     function get(collection, key, notSetValue) {
       return isImmutable(collection) ? collection.get(key, notSetValue) : !has(collection, key) ? notSetValue : typeof collection.get === "function" ? collection.get(key) : collection[key];
     }
+    function isProtoKey(key) {
+      return typeof key === "string" && (key === "__proto__" || key === "constructor");
+    }
     function shallowCopy(from) {
       if (Array.isArray(from)) {
         return arrCopy(from);
       }
       var to = {};
       for (var key in from) {
+        if (isProtoKey(key)) {
+          continue;
+        }
         if (hasOwnProperty.call(from, key)) {
           to[key] = from[key];
         }
@@ -16986,6 +16996,9 @@ var require_immutable = __commonJS((exports, module) => {
       return collectionCopy;
     }
     function set(collection, key, value) {
+      if (isProtoKey(key)) {
+        return collection;
+      }
       if (!isDataStructure(collection)) {
         throw new TypeError("Cannot update non-data-structure value: " + collection);
       }
@@ -17135,6 +17148,9 @@ var require_immutable = __commonJS((exports, module) => {
         }
         merged.push(value);
       } : function(value, key) {
+        if (isProtoKey(key)) {
+          return;
+        }
         var hasVal = hasOwnProperty.call(merged, key);
         var nextVal = hasVal && merger ? merger(merged[key], value, key) : value;
         if (!hasVal || nextVal !== merged[key]) {
@@ -18687,6 +18703,9 @@ var require_immutable = __commonJS((exports, module) => {
       if (isKeyed(value)) {
         var result$1 = {};
         value.__iterate(function(v, k) {
+          if (isProtoKey(k)) {
+            return;
+          }
           result$1[k] = toJS(v);
         });
         return result$1;
@@ -19019,6 +19038,9 @@ var require_immutable = __commonJS((exports, module) => {
       assertNotInfinite(this.size);
       var object = {};
       this.__iterate(function(v, k) {
+        if (isProtoKey(k)) {
+          return;
+        }
         object[k] = v;
       });
       return object;
@@ -19858,7 +19880,7 @@ var require_immutable = __commonJS((exports, module) => {
     function defaultConverter(k, v) {
       return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();
     }
-    var version = "4.3.7";
+    var version = "4.3.8";
     var Immutable = {
       version,
       Collection,
@@ -22545,52 +22567,135 @@ function textDecode(bytes2, 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(bytes2) {
   const parts = [];
-  let out = "";
+  const chunk = [];
   let i = 0;
+  if (bytes2.length >= 3 && bytes2[0] === 239 && bytes2[1] === 187 && bytes2[2] === 191) {
+    i = 3;
+  }
   while (i < bytes2.length) {
-    const b1 = bytes2[i++];
-    if (b1 < 128) {
-      out += String.fromCharCode(b1);
-    } else if (b1 < 224) {
-      const b2 = bytes2[i++] & 63;
-      out += String.fromCharCode((b1 & 31) << 6 | b2);
-    } else if (b1 < 240) {
-      const b2 = bytes2[i++] & 63;
-      const b3 = bytes2[i++] & 63;
-      out += String.fromCharCode((b1 & 15) << 12 | b2 << 6 | b3);
-    } else {
-      const b2 = bytes2[i++] & 63;
-      const b3 = bytes2[i++] & 63;
-      const b4 = bytes2[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 = bytes2[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 >= bytes2.length) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const b22 = bytes2[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 >= bytes2.length) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const b22 = bytes2[i + 1];
+      const b32 = bytes2[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 >= bytes2.length) {
+      pushCodeUnit(parts, chunk, REPLACEMENT);
+      i++;
+      continue;
+    }
+    const b2 = bytes2[i + 1];
+    const b3 = bytes2[i + 2];
+    const b4 = bytes2[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(bytes2) {
-  const len = bytes2.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] = bytes2[i] | bytes2[i + 1] << 8;
+  const chunk = [];
+  const len = bytes2.length;
+  let i = 0;
+  while (i + 1 < len) {
+    const u1 = bytes2[i] | bytes2[i + 1] << 8;
+    i += 2;
+    if (u1 >= 55296 && u1 <= 56319) {
+      if (i + 1 < len) {
+        const u2 = bytes2[i] | bytes2[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(bytes2) {
@@ -22633,7 +22738,7 @@ function decodeWindows1252(bytes2) {
     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: "\u20AC",
@@ -24143,6 +24248,188 @@ 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 output2 = input.pipeThrough(new DecompressionStream("deflate-raw"));
+  const reader = output2.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 findZipDataDescriptorOffset(buffer, bytesConsumed) {
+  if (buffer.length < zipDataDescriptorLengthInBytes) {
+    return -1;
+  }
+  const lastPossibleDescriptorOffset = buffer.length - zipDataDescriptorLengthInBytes;
+  for (let index = 0;index <= lastPossibleDescriptorOffset; index++) {
+    if (UINT32_LE.get(buffer, index) === zipDataDescriptorSignature && UINT32_LE.get(buffer, index + 8) === bytesConsumed + index) {
+      return index;
+    }
+  }
+  return -1;
+}
+function isPngAncillaryChunk(type) {
+  return (type.codePointAt(0) & 32) !== 0;
+}
+function mergeByteChunks(chunks, totalLength) {
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return merged;
+}
+async function readZipDataDescriptorEntryWithLimit(zipHandler, { shouldBuffer, maximumLength = maximumZipEntrySizeInBytes } = {}) {
+  const { syncBuffer } = zipHandler;
+  const { length: syncBufferLength } = syncBuffer;
+  const chunks = [];
+  let bytesConsumed = 0;
+  for (;; ) {
+    const length = await zipHandler.tokenizer.peekBuffer(syncBuffer, { mayBeLess: true });
+    const dataDescriptorOffset = findZipDataDescriptorOffset(syncBuffer.subarray(0, length), bytesConsumed);
+    const retainedLength = dataDescriptorOffset >= 0 ? 0 : length === syncBufferLength ? Math.min(zipDataDescriptorOverlapLengthInBytes, length - 1) : 0;
+    const chunkLength = dataDescriptorOffset >= 0 ? dataDescriptorOffset : length - retainedLength;
+    if (chunkLength === 0) {
+      break;
+    }
+    bytesConsumed += chunkLength;
+    if (bytesConsumed > maximumLength) {
+      throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+    }
+    if (shouldBuffer) {
+      const data = new Uint8Array(chunkLength);
+      await zipHandler.tokenizer.readBuffer(data);
+      chunks.push(data);
+    } else {
+      await zipHandler.tokenizer.ignore(chunkLength);
+    }
+    if (dataDescriptorOffset >= 0) {
+      break;
+    }
+  }
+  if (!hasUnknownFileSize(zipHandler.tokenizer)) {
+    zipHandler.knownSizeDescriptorScannedBytes += bytesConsumed;
+  }
+  if (!shouldBuffer) {
+    return;
+  }
+  return mergeByteChunks(chunks, bytesConsumed);
+}
+function getRemainingZipScanBudget(zipHandler, startOffset) {
+  if (hasUnknownFileSize(zipHandler.tokenizer)) {
+    return Math.max(0, maximumUntrustedSkipSizeInBytes - (zipHandler.tokenizer.position - startOffset));
+  }
+  return Math.max(0, maximumZipEntrySizeInBytes - zipHandler.knownSizeDescriptorScannedBytes);
+}
+async function readZipEntryData(zipHandler, zipHeader, { shouldBuffer, maximumDescriptorLength = maximumZipEntrySizeInBytes } = {}) {
+  if (zipHeader.dataDescriptor && zipHeader.compressedSize === 0) {
+    return readZipDataDescriptorEntryWithLimit(zipHandler, {
+      shouldBuffer,
+      maximumLength: maximumDescriptorLength
+    });
+  }
+  if (!shouldBuffer) {
+    await safeIgnore(zipHandler.tokenizer, zipHeader.compressedSize, {
+      maximumLength: hasUnknownFileSize(zipHandler.tokenizer) ? maximumZipEntrySizeInBytes : zipHandler.tokenizer.fileInfo.size,
+      reason: "ZIP entry compressed data"
+    });
+    return;
+  }
+  const maximumLength = getMaximumZipBufferedReadLength(zipHandler.tokenizer);
+  if (!Number.isFinite(zipHeader.compressedSize) || zipHeader.compressedSize < 0 || zipHeader.compressedSize > maximumLength) {
+    throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+  }
+  const fileData = new Uint8Array(zipHeader.compressedSize);
+  await zipHandler.tokenizer.readBuffer(fileData);
+  return fileData;
+}
+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);
 }
@@ -24296,29 +24583,178 @@ function _check(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 getMaximumZipBufferedReadLength(tokenizer) {
+  const fileSize = tokenizer.fileInfo.size;
+  const remainingBytes = Number.isFinite(fileSize) ? Math.max(0, fileSize - tokenizer.position) : Number.MAX_SAFE_INTEGER;
+  return Math.min(remainingBytes, maximumZipBufferedReadSizeInBytes);
+}
+function isRecoverableZipError(error) {
+  if (error instanceof EndOfStreamError) {
+    return true;
+  }
+  if (error instanceof ParserHardLimitError) {
+    return true;
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if (recoverableZipErrorMessages.has(error.message)) {
+    return true;
+  }
+  if (recoverableZipErrorCodes.has(error.code)) {
+    return true;
+  }
+  for (const prefix of recoverableZipErrorMessagePrefixes) {
+    if (error.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
     };
+    this.gzipProbeDepth = 0;
   }
-  async fromTokenizer(tokenizer) {
+  getTokenizerOptions() {
+    return {
+      ...this.tokenizerOptions
+    };
+  }
+  async fromTokenizer(tokenizer, detectionReentryCount = 0) {
+    this.detectionReentryCount = detectionReentryCount;
     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 (error) {
+        if (error instanceof EndOfStreamError) {
+          return;
+        }
+        if (error instanceof ParserHardLimitError) {
+          return;
+        }
+        throw error;
+      }
       if (fileType) {
         return fileType;
       }
@@ -24335,10 +24771,10 @@ class FileTypeParser {
     if (!(buffer?.length > 1)) {
       return;
     }
-    return this.fromTokenizer(fromBuffer(buffer, this.tokenizerOptions));
+    return this.fromTokenizer(fromBuffer(buffer, this.getTokenizerOptions()));
   }
   async fromBlob(blob) {
-    const tokenizer = fromBlob(blob, this.tokenizerOptions);
+    const tokenizer = fromBlob(blob, this.getTokenizerOptions());
     try {
       return await this.fromTokenizer(tokenizer);
     } finally {
@@ -24346,7 +24782,7 @@ class FileTypeParser {
     }
   }
   async fromStream(stream) {
-    const tokenizer = fromWebStream(stream, this.tokenizerOptions);
+    const tokenizer = fromWebStream(stream, this.getTokenizerOptions());
     try {
       return await this.fromTokenizer(tokenizer);
     } finally {
@@ -24354,7 +24790,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" });
@@ -24456,7 +24892,11 @@ class FileTypeParser {
       };
     }
     if (this.check([239, 187, 191])) {
-      this.tokenizer.ignore(3);
+      if (this.detectionReentryCount >= maximumDetectionReentryCount) {
+        return;
+      }
+      this.detectionReentryCount++;
+      await this.tokenizer.ignore(3);
       return this.detectConfident(tokenizer);
     }
     if (this.check([71, 73, 70])) {
@@ -24472,26 +24912,30 @@ class FileTypeParser {
       };
     }
     if (this.check([31, 139, 8])) {
+      if (this.gzipProbeDepth >= maximumNestedGzipProbeDepth) {
+        return {
+          ext: "gz",
+          mime: "application/gzip"
+        };
+      }
       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"
-          };
+        this.gzipProbeDepth++;
+        compressedFileType = await this.fromStream(limitedInflatedStream);
+      } catch (error) {
+        if (error?.name === "AbortError") {
+          throw error;
         }
       } finally {
-        if (shouldCancelStream) {
-          await stream.cancel();
-        }
+        this.gzipProbeDepth--;
+      }
+      if (compressedFileType?.ext === "tar") {
+        return {
+          ext: "tar.gz",
+          mime: "application/gzip"
+        };
       }
       return {
         ext: "gz",
@@ -24505,16 +24949,40 @@ 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 || tokenizer.position + id3HeaderLength > maximumId3HeaderSizeInBytes)) {
+        return;
+      }
       if (tokenizer.position + id3HeaderLength > tokenizer.fileInfo.size) {
+        if (isUnknownFileSize) {
+          return;
+        }
         return {
           ext: "mp3",
           mime: "audio/mpeg"
         };
       }
-      await tokenizer.ignore(id3HeaderLength);
-      return this.fromTokenizer(tokenizer);
+      try {
+        await safeIgnore(tokenizer, id3HeaderLength, {
+          maximumLength: isUnknownFileSize ? maximumId3HeaderSizeInBytes : tokenizer.fileInfo.size,
+          reason: "ID3 payload"
+        });
+      } catch (error) {
+        if (error instanceof EndOfStreamError) {
+          return;
+        }
+        throw error;
+      }
+      if (this.detectionReentryCount >= maximumDetectionReentryCount) {
+        return;
+      }
+      this.detectionReentryCount++;
+      return this.fromTokenizer(tokenizer, this.detectionReentryCount);
     }
     if (this.checkString("MP+")) {
       return {
@@ -24578,67 +25046,87 @@ 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, maximumZipTextEntrySizeInBytes)) {
+                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;
+              if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) {
+                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((error) => {
-        if (!(error instanceof EndOfStreamError)) {
+            default:
+              if (/classes\d*\.dex/.test(zipHeader.filename)) {
+                fileType = {
+                  ext: "apk",
+                  mime: "application/vnd.android.package-archive"
+                };
+                return { stop: true };
+              }
+              return {};
+          }
+        });
+      } catch (error) {
+        if (!isRecoverableZipError(error)) {
           throw error;
         }
-      });
-      return fileType ?? {
+        if (openXmlState.isParsingContentTypes) {
+          openXmlState.isParsingContentTypes = false;
+          openXmlState.hasUnparseableContentTypes = true;
+        }
+      }
+      return fileType ?? getOpenXmlFileTypeFromZipEntries(openXmlState) ?? {
         ext: "zip",
         mime: "application/zip"
       };
@@ -24788,7 +25276,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() {
@@ -24804,18 +25295,41 @@ class FileTypeParser {
         };
       }
       async function readChildren(children) {
+        let ebmlElementCount = 0;
         while (children > 0) {
+          ebmlElementCount++;
+          if (ebmlElementCount > maximumEbmlElementCount) {
+            return;
+          }
+          if (hasExceededUnknownSizeScanBudget(tokenizer, ebmlScanStart, maximumUntrustedSkipSizeInBytes)) {
+            return;
+          }
+          const previousPosition = tokenizer.position;
           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;
+          if (tokenizer.position <= previousPosition) {
+            return;
+          }
         }
       }
-      const re = await readElement();
-      const documentType = await readChildren(re.len);
+      const rootElement = await readElement();
+      const ebmlScanStart = tokenizer.position;
+      const documentType = await readChildren(rootElement.len);
       switch (documentType) {
         case "webm":
           return {
@@ -25077,6 +25591,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 {
@@ -25084,30 +25606,58 @@ class FileTypeParser {
           type: await tokenizer.readToken(new StringType2(4, "latin1"))
         };
       }
+      const isUnknownPngStream = hasUnknownFileSize(tokenizer);
+      const pngScanStart = tokenizer.position;
+      let pngChunkCount = 0;
+      let hasSeenImageHeader = false;
       do {
+        pngChunkCount++;
+        if (pngChunkCount > maximumPngChunkCount) {
+          break;
+        }
+        if (hasExceededUnknownSizeScanBudget(tokenizer, pngScanStart, maximumPngStreamScanBudgetInBytes)) {
+          break;
+        }
+        const previousPosition = tokenizer.position;
         const chunk = await readChunkHeader();
         if (chunk.length < 0) {
           return;
         }
+        if (chunk.type === "IHDR") {
+          if (chunk.length !== 13) {
+            return;
+          }
+          hasSeenImageHeader = true;
+        }
         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 (!hasSeenImageHeader && chunk.type !== "CgBI") {
+              return;
+            }
+            if (isUnknownPngStream && chunk.length > maximumPngChunkSizeInBytes) {
+              return hasSeenImageHeader && isPngAncillaryChunk(chunk.type) ? pngFileType : undefined;
+            }
+            try {
+              await safeIgnore(tokenizer, chunk.length + 4, {
+                maximumLength: isUnknownPngStream ? maximumPngChunkSizeInBytes + 4 : tokenizer.fileInfo.size,
+                reason: "PNG chunk payload"
+              });
+            } catch (error) {
+              if (!isUnknownPngStream && (error instanceof ParserHardLimitError || error instanceof EndOfStreamError)) {
+                return pngFileType;
+              }
+              throw error;
+            }
+        }
+        if (tokenizer.position <= previousPosition) {
+          break;
         }
       } 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 {
@@ -25226,36 +25776,85 @@ class FileTypeParser {
       };
     }
     if (this.check([48, 38, 178, 117, 142, 102, 207, 17, 166, 217])) {
-      async function readHeader() {
-        const guid = new Uint8Array(16);
-        await tokenizer.readBuffer(guid);
-        return {
-          id: guid,
-          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 (_check(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 (_check(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 guid = new Uint8Array(16);
+          await safeReadBuffer(tokenizer, guid, undefined, {
+            maximumLength: guid.length,
+            reason: "ASF header GUID"
+          });
+          return {
+            id: guid,
+            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;
+        let asfHeaderObjectCount = 0;
+        while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
+          asfHeaderObjectCount++;
+          if (asfHeaderObjectCount > maximumAsfHeaderObjectCount) {
+            break;
           }
-          if (_check(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"
-            };
+          if (hasExceededUnknownSizeScanBudget(tokenizer, asfHeaderScanStart, maximumUntrustedSkipSizeInBytes)) {
+            break;
+          }
+          const previousPosition = tokenizer.position;
+          const header = await readHeader();
+          let payload = header.size - 24;
+          if (!Number.isFinite(payload) || payload < 0) {
+            isMalformedAsf = true;
+            break;
+          }
+          if (_check(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 (_check(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 (_check(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;
+          }
+          if (isUnknownFileSize && payload > maximumAsfHeaderPayloadSizeInBytes) {
+            isMalformedAsf = true;
+            break;
+          }
+          await safeIgnore(tokenizer, payload, {
+            maximumLength: isUnknownFileSize ? maximumAsfHeaderPayloadSizeInBytes : tokenizer.fileInfo.size,
+            reason: "ASF header payload"
+          });
+          if (tokenizer.position <= previousPosition) {
+            isMalformedAsf = true;
+            break;
           }
-          break;
         }
-        await tokenizer.ignore(payload);
+      } catch (error) {
+        if (error instanceof EndOfStreamError || error instanceof ParserHardLimitError) {
+          if (hasUnknownFileSize(tokenizer)) {
+            isMalformedAsf = true;
+          }
+        } else {
+          throw error;
+        }
+      }
+      if (isMalformedAsf) {
+        return;
       }
       return {
         ext: "asf",
@@ -25506,7 +26105,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",
@@ -25531,7 +26131,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);
@@ -25543,7 +26143,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 {
@@ -25560,6 +26160,12 @@ class FileTypeParser {
   }
   async readTiffIFD(bigEndian) {
     const numberOfTags = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
+    if (numberOfTags > maximumTiffTagCount) {
+      return;
+    }
+    if (hasUnknownFileSize(this.tokenizer) && 2 + numberOfTags * 12 > maximumTiffIfdOffsetInBytes) {
+      return;
+    }
     for (let n = 0;n < numberOfTags; ++n) {
       const fileType = await this.readTiffTag(bigEndian);
       if (fileType) {
@@ -25568,6 +26174,10 @@ class FileTypeParser {
     }
   }
   async readTiffHeader(bigEndian) {
+    const tiffFileType = {
+      ext: "tif",
+      mime: "image/tiff"
+    };
     const version = (bigEndian ? UINT16_BE : UINT16_LE).get(this.buffer, 2);
     const ifdOffset = (bigEndian ? UINT32_BE : UINT32_LE).get(this.buffer, 4);
     if (version === 42) {
@@ -25589,18 +26199,34 @@ class FileTypeParser {
           }
         }
       }
-      await this.tokenizer.ignore(ifdOffset);
-      const fileType = await this.readTiffIFD(bigEndian);
-      return fileType ?? {
-        ext: "tif",
-        mime: "image/tiff"
-      };
+      if (hasUnknownFileSize(this.tokenizer) && ifdOffset > maximumTiffStreamIfdOffsetInBytes) {
+        return tiffFileType;
+      }
+      const maximumTiffOffset = hasUnknownFileSize(this.tokenizer) ? maximumTiffIfdOffsetInBytes : this.tokenizer.fileInfo.size;
+      try {
+        await safeIgnore(this.tokenizer, ifdOffset, {
+          maximumLength: maximumTiffOffset,
+          reason: "TIFF IFD offset"
+        });
+      } catch (error) {
+        if (error instanceof EndOfStreamError) {
+          return;
+        }
+        throw error;
+      }
+      let fileType;
+      try {
+        fileType = await this.readTiffIFD(bigEndian);
+      } catch (error) {
+        if (error instanceof EndOfStreamError) {
+          return;
+        }
+        throw error;
+      }
+      return fileType ?? tiffFileType;
     }
     if (version === 43) {
-      return {
-        ext: "tif",
-        mime: "image/tiff"
-      };
+      return tiffFileType;
     }
   }
   scanMpeg(offset) {
@@ -25638,7 +26264,7 @@ class FileTypeParser {
     }
   }
 }
-var reasonableDetectionSizeInBytes = 4100, supportedExtensions, supportedMimeTypes;
+var reasonableDetectionSizeInBytes = 4100, maximumMpegOffsetTolerance, maximumZipEntrySizeInBytes, maximumZipEntryCount = 1024, maximumZipBufferedReadSizeInBytes, maximumUntrustedSkipSizeInBytes, maximumUnknownSizePayloadProbeSizeInBytes, maximumZipTextEntrySizeInBytes, maximumNestedGzipDetectionSizeInBytes, maximumNestedGzipProbeDepth = 1, maximumId3HeaderSizeInBytes, maximumEbmlDocumentTypeSizeInBytes = 64, maximumEbmlElementPayloadSizeInBytes, maximumEbmlElementCount = 256, maximumPngChunkCount = 512, maximumPngStreamScanBudgetInBytes, maximumAsfHeaderObjectCount = 512, maximumTiffTagCount = 512, maximumDetectionReentryCount = 256, maximumPngChunkSizeInBytes, maximumAsfHeaderPayloadSizeInBytes, maximumTiffStreamIfdOffsetInBytes, maximumTiffIfdOffsetInBytes, recoverableZipErrorMessages, recoverableZipErrorMessagePrefixes, recoverableZipErrorCodes, ParserHardLimitError, zipDataDescriptorSignature = 134695760, zipDataDescriptorLengthInBytes = 16, zipDataDescriptorOverlapLengthInBytes, supportedExtensions, supportedMimeTypes;
 var init_core2 = __esm(() => {
   init_lib3();
   init_core();
@@ -25646,6 +26272,88 @@ var init_core2 = __esm(() => {
   init_uint8array_extras();
   init_util();
   init_supported();
+  maximumMpegOffsetTolerance = reasonableDetectionSizeInBytes - 2;
+  maximumZipEntrySizeInBytes = 1024 * 1024;
+  maximumZipBufferedReadSizeInBytes = 2 ** 31 - 1;
+  maximumUntrustedSkipSizeInBytes = 16 * 1024 * 1024;
+  maximumUnknownSizePayloadProbeSizeInBytes = maximumZipEntrySizeInBytes;
+  maximumZipTextEntrySizeInBytes = maximumZipEntrySizeInBytes;
+  maximumNestedGzipDetectionSizeInBytes = maximumUntrustedSkipSizeInBytes;
+  maximumId3HeaderSizeInBytes = maximumUntrustedSkipSizeInBytes;
+  maximumEbmlElementPayloadSizeInBytes = maximumUnknownSizePayloadProbeSizeInBytes;
+  maximumPngStreamScanBudgetInBytes = maximumUntrustedSkipSizeInBytes;
+  maximumPngChunkSizeInBytes = maximumUnknownSizePayloadProbeSizeInBytes;
+  maximumAsfHeaderPayloadSizeInBytes = maximumUnknownSizePayloadProbeSizeInBytes;
+  maximumTiffStreamIfdOffsetInBytes = maximumUnknownSizePayloadProbeSizeInBytes;
+  maximumTiffIfdOffsetInBytes = maximumUntrustedSkipSizeInBytes;
+  recoverableZipErrorMessages = new Set([
+    "Unexpected signature",
+    "Encrypted ZIP",
+    "Expected Central-File-Header signature"
+  ]);
+  recoverableZipErrorMessagePrefixes = [
+    "ZIP entry count exceeds ",
+    "Unsupported ZIP compression method:",
+    "ZIP entry compressed data exceeds ",
+    "ZIP entry decompressed data exceeds "
+  ];
+  recoverableZipErrorCodes = new Set([
+    "Z_BUF_ERROR",
+    "Z_DATA_ERROR",
+    "ERR_INVALID_STATE"
+  ]);
+  ParserHardLimitError = class ParserHardLimitError extends Error {
+  };
+  zipDataDescriptorOverlapLengthInBytes = zipDataDescriptorLengthInBytes - 1;
+  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 uncompressedData = await decompressDeflateRawWithLimit(fileData, { maximumLength: maximumZipEntrySizeInBytes });
+    return callback(uncompressedData);
+  };
+  ZipHandler.prototype.unzip = async function(fileCallback) {
+    let stop = false;
+    let zipEntryCount = 0;
+    const zipScanStart = this.tokenizer.position;
+    this.knownSizeDescriptorScannedBytes = 0;
+    do {
+      if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, maximumUntrustedSkipSizeInBytes)) {
+        throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
+      }
+      const zipHeader = await this.readLocalFileHeader();
+      if (!zipHeader) {
+        break;
+      }
+      zipEntryCount++;
+      if (zipEntryCount > maximumZipEntryCount) {
+        throw new Error(`ZIP entry count exceeds ${maximumZipEntryCount}`);
+      }
+      const next = fileCallback(zipHeader);
+      stop = Boolean(next.stop);
+      await this.tokenizer.ignore(zipHeader.extraFieldLength);
+      const fileData = await readZipEntryData(this, zipHeader, {
+        shouldBuffer: Boolean(next.handler),
+        maximumDescriptorLength: Math.min(maximumZipEntrySizeInBytes, getRemainingZipScanBudget(this, zipScanStart))
+      });
+      if (next.handler) {
+        await this.inflate(zipHeader, fileData, next.handler);
+      }
+      if (zipHeader.dataDescriptor) {
+        const dataDescriptor = new Uint8Array(zipDataDescriptorLengthInBytes);
+        await this.tokenizer.readBuffer(dataDescriptor);
+        if (UINT32_LE.get(dataDescriptor, 0) !== zipDataDescriptorSignature) {
+          throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - dataDescriptor.length}`);
+        }
+      }
+      if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, maximumUntrustedSkipSizeInBytes)) {
+        throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
+      }
+    } while (!stop);
+  };
   supportedExtensions = new Set(extensions);
   supportedMimeTypes = new Set(mimeTypes);
 });
@@ -25665,6 +26373,14 @@ __export(exports_file_type, {
 });
 import { ReadableStream as WebReadableStream } from "node:stream/web";
 import { pipeline, PassThrough, Readable } from "node:stream";
+import fs from "node:fs/promises";
+import { constants as fileSystemConstants } from "node:fs";
+function isTokenizerStreamBoundsError(error) {
+  if (!(error instanceof RangeError) || error.message !== "offset is out of bounds" || typeof error.stack !== "string") {
+    return false;
+  }
+  return /strtok3[/\\]lib[/\\]stream[/\\]/.test(error.stack);
+}
 async function fileTypeFromFile(path, options) {
   return new FileTypeParser2(options).fromFile(path, options);
 }
@@ -25681,15 +26397,32 @@ var init_file_type = __esm(() => {
   init_core2();
   FileTypeParser2 = class FileTypeParser2 extends FileTypeParser {
     async fromStream(stream) {
-      const tokenizer = await (stream instanceof WebReadableStream ? fromWebStream(stream, this.tokenizerOptions) : fromStream2(stream, this.tokenizerOptions));
+      const tokenizer = await (stream instanceof WebReadableStream ? fromWebStream(stream, this.getTokenizerOptions()) : fromStream2(stream, this.getTokenizerOptions()));
       try {
         return await super.fromTokenizer(tokenizer);
+      } catch (error) {
+        if (isTokenizerStreamBoundsError(error)) {
+          return;
+        }
+        throw error;
       } finally {
         await tokenizer.close();
       }
     }
     async fromFile(path) {
-      const tokenizer = await fromFile(path);
+      const fileHandle = await fs.open(path, fileSystemConstants.O_RDONLY | fileSystemConstants.O_NONBLOCK);
+      const fileStat = await fileHandle.stat();
+      if (!fileStat.isFile()) {
+        await fileHandle.close();
+        return;
+      }
+      const tokenizer = new FileTokenizer(fileHandle, {
+        ...this.getTokenizerOptions(),
+        fileInfo: {
+          path,
+          size: fileStat.size
+        }
+      });
       try {
         return await super.fromTokenizer(tokenizer);
       } finally {
@@ -25700,7 +26433,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((resolve3, reject) => {
         readableStream.on("error", reject);
         readableStream.once("readable", () => {
@@ -25980,8 +26713,8 @@ var require_dist3 = __commonJS((exports) => {
 var import_chokidar = __toESM(require_chokidar(), 1);
 var import_picocolors = __toESM(require_picocolors(), 1);
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
-import * as fs from "node:fs/promises";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import * as fs2 from "node:fs/promises";
 import path from "node:path";
 import { TextDecoder as TextDecoder2 } from "node:util";
 
@@ -34557,6 +35290,15 @@ var TypeCompiler;
 })(TypeCompiler || (TypeCompiler = {}));
 
 // ../../node_modules/elysia/dist/universal/utils.mjs
+function isCloudflareWorker() {
+  try {
+    if (typeof caches < "u" && typeof caches.default < "u" || typeof WebSocketPair < "u")
+      return true;
+  } catch {
+    return false;
+  }
+  return false;
+}
 var isBun = typeof Bun < "u";
 var isDeno = typeof Deno < "u";
 
@@ -34707,7 +35449,6 @@ async function getResponseLength(response) {
   }
   return length;
 }
-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)}`;
@@ -34841,8 +35582,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;
@@ -34986,8 +35726,8 @@ var StatusMap = {
 var InvertedStatusMap = Object.fromEntries(Object.entries(StatusMap).map(([k, v]) => [v, k]));
 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"));
 };
@@ -34998,11 +35738,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;
 };
@@ -35115,11 +35853,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 uuid = crypto.randomUUID();
@@ -35332,7 +36070,7 @@ class ValidationError extends Error {
         value,
         property: accessor,
         message: error?.message,
-        summary: mapValueError(error).summary,
+        summary: mapValueError(error)?.summary,
         found: value,
         expected,
         errors: "Errors" in validator ? [
@@ -35349,7 +36087,7 @@ class ValidationError extends Error {
         on: type,
         property: accessor,
         message: error?.message,
-        summary: mapValueError(error).summary,
+        summary: mapValueError(error)?.summary,
         expected,
         found: value,
         errors: "Errors" in validator ? [...validator.Errors(value)].map(mapValueError) : [...exports_value2.Errors(validator, value)].map(mapValueError)
@@ -35373,7 +36111,7 @@ class ValidationError extends Error {
       path: issue.path?.join(".") || "root",
       message: issue.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;
@@ -35409,7 +36147,7 @@ class ValidationError 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
@@ -35565,7 +36303,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)$/,
@@ -35961,6 +36699,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_dist3(), 1);
 var import_fast_decode_uri_component = __toESM(require_fast_decode_uri_component(), 1);
@@ -35973,7 +36975,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;
@@ -36094,7 +37096,7 @@ class Cookie {
     return typeof this.value == "object" ? JSON.stringify(this.value) : this.value?.toString() ?? "";
   }
 }
-var createCookieJar = (set, store, initial) => (set.cookie || (set.cookie = {}), new Proxy(store, {
+var createCookieJar = (set, store, initial) => (set.cookie || (set.cookie = /* @__PURE__ */ Object.create(null)), new Proxy(store, {
   get(_, key) {
     return key in store ? new Cookie(key, set.cookie, Object.assign({}, initial ?? {}, store[key])) : new Cookie(key, set.cookie, Object.assign({}, initial));
   }
@@ -36103,24 +37105,16 @@ var parseCookie = async (set, cookieString, {
   secrets,
   sign,
   ...initial
-} = {}) => {
+} = /* @__PURE__ */ Object.create(null)) => {
   if (!cookieString)
-    return createCookieJar(set, {}, initial);
+    return createCookieJar(set, /* @__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");
@@ -36146,9 +37140,15 @@ var parseCookie = async (set, 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(set, jar, initial);
 };
@@ -36166,9 +37166,6 @@ var serializeCookie = (cookies) => {
     return set.length === 1 ? set[0] : set;
 };
 
-// ../../node_modules/elysia/dist/universal/env.mjs
-var env2 = isBun ? Bun.env : typeof process < "u" && process?.env ? process.env : {};
-
 // ../../node_modules/elysia/dist/adapter/utils.mjs
 async function* streamResponse(response) {
   const body = response.body;
@@ -36186,6 +37183,25 @@ async function* streamResponse(response) {
     reader.releaseLock();
   }
 }
+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;
+}
 async function tee(source, branches = 2) {
   const buffer = [];
   let done = false, waiting = [];
@@ -36207,10 +37223,41 @@ async function tee(source, branches = 2) {
   }
   return Array.from({ length: branches }, makeIterator);
 }
-var handleFile = (response, set) => {
+var handleFile = (response, set, request) => {
   if (!isBun && response instanceof Promise)
-    return response.then((res) => handleFile(res, set));
-  const size = response.size, immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416), defaultHeader = immutable ? {} : {
+    return response.then((res) => handleFile(res, set, request));
+  const size = response.size, rangeHeader = request?.headers.get("range");
+  if (rangeHeader) {
+    const match = /bytes=(\d*)-(\d*)/.exec(rangeHeader);
+    if (match) {
+      if (!match[1] && !match[2])
+        return new Response(null, {
+          status: 416,
+          headers: mergeHeaders(new Headers({ "content-range": `bytes */${size}` }), set?.headers ?? {})
+        });
+      let start, end;
+      if (!match[1] && match[2]) {
+        const suffix = parseInt(match[2]);
+        start = Math.max(0, size - suffix), end = size - 1;
+      } else
+        start = match[1] ? parseInt(match[1]) : 0, end = match[2] ? Math.min(parseInt(match[2]), size - 1) : size - 1;
+      if (start >= size || start > end)
+        return new Response(null, {
+          status: 416,
+          headers: mergeHeaders(new Headers({ "content-range": `bytes */${size}` }), set?.headers ?? {})
+        });
+      const contentLength = end - start + 1, rangeHeaders = new Headers({
+        "accept-ranges": "bytes",
+        "content-range": `bytes ${start}-${end}/${size}`,
+        "content-length": String(contentLength)
+      });
+      return new Response(response.slice(start, end + 1, response.type), {
+        status: 206,
+        headers: mergeHeaders(rangeHeaders, set?.headers ?? {})
+      });
+    }
+  }
+  const immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416), defaultHeader = immutable ? {} : {
     "accept-ranges": "bytes",
     "content-range": size ? `bytes 0-${size - 1}/${size}` : undefined
   };
@@ -36271,7 +37318,7 @@ var responseToSetHeaders = (response, set) => {
     key !== "content-encoding" && key in set.headers && (set.headers[key] = value);
   return set;
 };
-var allowRapidStream = env2.ELYSIA_RAPID_STREAM === "true";
+var enqueueBinaryChunk = (controller, chunk) => chunk instanceof Blob ? chunk.arrayBuffer().then((buffer) => (controller.enqueue(new Uint8Array(buffer)), true)) : chunk instanceof Uint8Array ? (controller.enqueue(chunk), true) : chunk instanceof ArrayBuffer ? (controller.enqueue(new Uint8Array(chunk)), true) : ArrayBuffer.isView(chunk) ? (controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength)), true) : false;
 var createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (generator, set, request, skipFormat) => {
   let init = generator.next?.();
   if (set && handleSet(set), init instanceof Promise && (init = await init), init?.value instanceof ReadableStream)
@@ -36290,21 +37337,23 @@ var createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (genera
       connection: "keep-alive"
     }
   };
-  const isBrowser = request?.headers.has("Origin");
+  const iterator = typeof generator.next == "function" ? generator : generator[Symbol.asyncIterator]();
+  let end = false;
   return new Response(new ReadableStream({
-    async start(controller) {
-      let end = false;
+    start(controller) {
       if (request?.signal?.addEventListener("abort", () => {
-        end = true;
+        end = true, iterator.return?.();
         try {
           controller.close();
         } catch {
         }
-      }), !(!init || init.value instanceof ReadableStream)) {
-        if (init.value !== undefined && init.value !== null)
-          if (init.value.toSSE)
-            controller.enqueue(init.value.toSSE());
-          else if (typeof init.value == "object")
+      }), !(!init || init.value instanceof ReadableStream || init.value === undefined || init.value === null))
+        if (init.value.toSSE)
+          controller.enqueue(init.value.toSSE());
+        else {
+          if (enqueueBinaryChunk(controller, init.value))
+            return;
+          if (typeof init.value == "object")
             try {
               controller.enqueue(format(JSON.stringify(init.value)));
             } catch {
@@ -36312,33 +37361,51 @@ var createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (genera
             }
           else
             controller.enqueue(format(init.value.toString()));
+        }
+    },
+    async pull(controller) {
+      if (end) {
+        try {
+          controller.close();
+        } catch {
+        }
+        return;
       }
       try {
-        for await (const chunk of generator) {
-          if (end)
-            break;
-          if (chunk != null)
-            if (chunk.toSSE)
-              controller.enqueue(chunk.toSSE());
-            else {
-              if (typeof chunk == "object")
-                try {
-                  controller.enqueue(format(JSON.stringify(chunk)));
-                } catch {
-                  controller.enqueue(format(chunk.toString()));
-                }
-              else
-                controller.enqueue(format(chunk.toString()));
-              !allowRapidStream && isBrowser && !isSSE && await new Promise((resolve3) => setTimeout(() => resolve3(), 0));
+        const { value: chunk, done } = await iterator.next();
+        if (done || end) {
+          try {
+            controller.close();
+          } catch {
+          }
+          return;
+        }
+        if (chunk == null)
+          return;
+        if (chunk.toSSE)
+          controller.enqueue(chunk.toSSE());
+        else {
+          if (enqueueBinaryChunk(controller, chunk))
+            return;
+          if (typeof chunk == "object")
+            try {
+              controller.enqueue(format(JSON.stringify(chunk)));
+            } catch {
+              controller.enqueue(format(chunk.toString()));
             }
+          else
+            controller.enqueue(format(chunk.toString()));
         }
       } catch (error) {
         console.warn(error);
+        try {
+          controller.close();
+        } catch {
+        }
       }
-      try {
-        controller.close();
-      } catch {
-      }
+    },
+    cancel() {
+      end = true, iterator.return?.();
     }
   }), set);
 };
@@ -36352,56 +37419,38 @@ var handleSet = (set) => {
 var createResponseHandler = (handler) => {
   const handleStream = createStreamHandler(handler);
   return (response, set, request) => {
-    let isCookieSet = false;
-    if (set.headers instanceof Headers)
-      for (const key of set.headers.keys())
-        if (key === "set-cookie") {
-          if (isCookieSet)
-            continue;
-          isCookieSet = true;
-          for (const cookie of set.headers.getSetCookie())
-            response.headers.append("set-cookie", cookie);
-        } else
-          response.headers.has(key) || response.headers.set(key, set.headers?.get(key) ?? "");
-    else
-      for (const key in set.headers)
-        key === "set-cookie" ? response.headers.append(key, set.headers[key]) : response.headers.has(key) || response.headers.set(key, set.headers[key]);
-    const status2 = set.status ?? 200;
-    if (response.status !== status2 && status2 !== 200 && (response.status <= 300 || response.status > 400)) {
-      const newResponse = new Response(response.body, {
-        headers: response.headers,
-        status: set.status
-      });
-      return !newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked" ? handleStream(streamResponse(newResponse), responseToSetHeaders(newResponse, set), request, true) : newResponse;
-    }
-    return !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked" ? handleStream(streamResponse(response), responseToSetHeaders(response, set), request, true) : response;
+    const newResponse = new Response(response.body, {
+      headers: mergeHeaders(response.headers, set.headers),
+      status: mergeStatus(response.status, set.status)
+    });
+    return !newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked" ? handleStream(streamResponse(newResponse), responseToSetHeaders(newResponse, set), request, true) : newResponse;
   };
 };
 
 // ../../node_modules/elysia/dist/adapter/web-standard/handler.mjs
-var handleElysiaFile = (file2, set = {
+var handleElysiaFile = (file, set = {
   headers: {}
-}) => {
-  const path = file2.path, contentType = mime[path.slice(path.lastIndexOf(".") + 1)];
-  return contentType && (set.headers["content-type"] = contentType), file2.stats && set.status !== 206 && set.status !== 304 && set.status !== 412 && set.status !== 416 ? file2.stats.then((stat2) => {
+}, request) => {
+  const path = file.path, contentType = mime[path.slice(path.lastIndexOf(".") + 1)];
+  return contentType && (set.headers["content-type"] = contentType), file.stats && set.status !== 206 && set.status !== 304 && set.status !== 412 && set.status !== 416 ? file.stats.then((stat2) => {
     const size = stat2.size;
-    return size !== undefined && (set.headers["content-range"] = `bytes 0-${size - 1}/${size}`, set.headers["content-length"] = size), handleFile(file2.value, set);
-  }) : handleFile(file2.value, set);
+    return size !== undefined && (set.headers["content-range"] = `bytes 0-${size - 1}/${size}`, set.headers["content-length"] = size), handleFile(file.value, set, request);
+  }) : handleFile(file.value, set, request);
 };
 var mapResponse = (response, set, request) => {
   if (isNotEmpty(set.headers) || set.status !== 200 || set.cookie)
     switch (handleSet(set), response?.constructor?.name) {
       case "String":
-        return set.headers["content-type"] = "text/plain", new Response(response, set);
+        return set.headers["content-type"] || (set.headers["content-type"] = "text/plain"), new Response(response, set);
       case "Array":
       case "Object":
-        return set.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set);
+        return set.headers["content-type"] || (set.headers["content-type"] = "application/json"), new Response(JSON.stringify(response), set);
       case "ElysiaFile":
-        return handleElysiaFile(response, set);
+        return handleElysiaFile(response, set, request);
       case "File":
-        return handleFile(response, set);
+        return handleFile(response, set, request);
       case "Blob":
-        return handleFile(response, set);
+        return handleFile(response, set, request);
       case "ElysiaCustomStatusResponse":
         return set.status = response.code, mapResponse(response.response, set, request);
       case undefined:
@@ -36434,6 +37483,12 @@ var mapResponse = (response, set, request) => {
           return handleStream(response, set, request);
         if (typeof response?.then == "function")
           return response.then((x) => mapResponse(x, set));
+        if (Array.isArray(response))
+          return new Response(JSON.stringify(response), {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
         if (typeof response?.toResponse == "function")
           return mapResponse(response.toResponse(), set);
         if ("charCodeAt" in response) {
@@ -36450,16 +37505,16 @@ var mapEarlyResponse = (response, set, request) => {
     if (isNotEmpty(set.headers) || set.status !== 200 || set.cookie)
       switch (handleSet(set), response?.constructor?.name) {
         case "String":
-          return set.headers["content-type"] = "text/plain", new Response(response, set);
+          return set.headers["content-type"] || (set.headers["content-type"] = "text/plain"), new Response(response, set);
         case "Array":
         case "Object":
-          return set.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set);
+          return set.headers["content-type"] || (set.headers["content-type"] = "application/json"), new Response(JSON.stringify(response), set);
         case "ElysiaFile":
-          return handleElysiaFile(response, set);
+          return handleElysiaFile(response, set, request);
         case "File":
-          return handleFile(response, set);
+          return handleFile(response, set, request);
         case "Blob":
-          return handleFile(response, set);
+          return handleFile(response, set, request);
         case "ElysiaCustomStatusResponse":
           return set.status = response.code, mapEarlyResponse(response.response, set, request);
         case undefined:
@@ -36494,6 +37549,12 @@ var mapEarlyResponse = (response, set, request) => {
             return response.then((x) => mapEarlyResponse(x, set));
           if (typeof response?.toResponse == "function")
             return mapEarlyResponse(response.toResponse(), set);
+          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)
@@ -36504,16 +37565,16 @@ var mapEarlyResponse = (response, set, request) => {
     else
       switch (response?.constructor?.name) {
         case "String":
-          return set.headers["content-type"] = "text/plain", new Response(response);
+          return set.headers["content-type"] || (set.headers["content-type"] = "text/plain"), new Response(response);
         case "Array":
         case "Object":
-          return set.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set);
+          return set.headers["content-type"] || (set.headers["content-type"] = "application/json"), new Response(JSON.stringify(response), set);
         case "ElysiaFile":
-          return handleElysiaFile(response, set);
+          return handleElysiaFile(response, set, request);
         case "File":
-          return handleFile(response, set);
+          return handleFile(response, set, request);
         case "Blob":
-          return handleFile(response, set);
+          return handleFile(response, set, request);
         case "ElysiaCustomStatusResponse":
           return set.status = response.code, mapEarlyResponse(response.response, set, request);
         case undefined:
@@ -36556,6 +37617,12 @@ var mapEarlyResponse = (response, set, request) => {
             return response.then((x) => mapEarlyResponse(x, set));
           if (typeof response?.toResponse == "function")
             return mapEarlyResponse(response.toResponse(), set);
+          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)
@@ -36580,11 +37647,11 @@ var mapCompactResponse = (response, request) => {
         }
       });
     case "ElysiaFile":
-      return handleElysiaFile(response);
+      return handleElysiaFile(response, undefined, request);
     case "File":
-      return handleFile(response);
+      return handleFile(response, undefined, request);
     case "Blob":
-      return handleFile(response);
+      return handleFile(response, undefined, request);
     case "ElysiaCustomStatusResponse":
       return mapResponse(response.response, {
         status: response.code,
@@ -36627,6 +37694,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)
@@ -36710,10 +37783,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}`;
       }
     }
   },
@@ -36760,6 +37880,278 @@ const error404=new Response(error404Message,{status:404})
   }
 };
 
+// ../../node_modules/elysia/dist/adapter/bun/handler.mjs
+var mapResponse2 = (response, set, request) => {
+  if (isNotEmpty(set.headers) || set.status !== 200 || set.cookie)
+    switch (handleSet(set), response?.constructor?.name) {
+      case "String":
+        return new Response(response, set);
+      case "Array":
+      case "Object":
+        return Response.json(response, set);
+      case "ElysiaFile":
+        return handleFile(response.value, set, request);
+      case "File":
+        return handleFile(response, set, request);
+      case "Blob":
+        return handleFile(response, set, request);
+      case "ElysiaCustomStatusResponse":
+        return set.status = response.code, mapResponse2(response.response, set, request);
+      case undefined:
+        return response ? Response.json(response, set) : new Response("", set);
+      case "Response":
+        return handleResponse2(response, set, request);
+      case "Error":
+        return errorToResponse2(response, set);
+      case "Promise":
+        return response.then((x) => mapResponse2(x, set, request));
+      case "Function":
+        return mapResponse2(response(), set, request);
+      case "Number":
+      case "Boolean":
+        return new Response(response.toString(), set);
+      case "Cookie":
+        return response instanceof Cookie ? new Response(response.value, set) : new Response(response?.toString(), set);
+      case "FormData":
+        return new Response(response, set);
+      default:
+        if (response instanceof Response)
+          return handleResponse2(response, set, request);
+        if (response instanceof Promise)
+          return response.then((x) => mapResponse2(x, set));
+        if (response instanceof Error)
+          return errorToResponse2(response, set);
+        if (response instanceof ElysiaCustomStatusResponse)
+          return set.status = response.code, mapResponse2(response.response, set, request);
+        if (typeof response?.next == "function" || response instanceof ReadableStream)
+          return handleStream2(response, set, request);
+        if (typeof response?.then == "function")
+          return response.then((x) => mapResponse2(x, set));
+        if (Array.isArray(response))
+          return Response.json(response);
+        if (typeof response?.toResponse == "function")
+          return mapResponse2(response.toResponse(), set);
+        if ("charCodeAt" in response) {
+          const code = response.charCodeAt(0);
+          if (code === 123 || code === 91)
+            return Response.json(response, set);
+        }
+        return new Response(response, set);
+    }
+  return typeof response?.next == "function" || response instanceof ReadableStream ? handleStream2(response, set, request) : mapCompactResponse2(response, request);
+};
+var mapEarlyResponse2 = (response, set, request) => {
+  if (response != null)
+    if (isNotEmpty(set.headers) || set.status !== 200 || set.cookie)
+      switch (handleSet(set), response?.constructor?.name) {
+        case "String":
+          return new Response(response, set);
+        case "Array":
+        case "Object":
+          return Response.json(response, set);
+        case "ElysiaFile":
+          return handleFile(response.value, set, request);
+        case "File":
+          return handleFile(response, set, request);
+        case "Blob":
+          return handleFile(response, set, request);
+        case "ElysiaCustomStatusResponse":
+          return set.status = response.code, mapEarlyResponse2(response.response, set, request);
+        case undefined:
+          return response ? Response.json(response, set) : undefined;
+        case "Response":
+          return handleResponse2(response, set, request);
+        case "Promise":
+          return response.then((x) => mapEarlyResponse2(x, set));
+        case "Error":
+          return errorToResponse2(response, set);
+        case "Function":
+          return mapEarlyResponse2(response(), set);
+        case "Number":
+        case "Boolean":
+          return new Response(response.toString(), set);
+        case "FormData":
+          return new Response(response);
+        case "Cookie":
+          return response instanceof Cookie ? new Response(response.value, set) : new Response(response?.toString(), set);
+        default:
+          if (response instanceof Response)
+            return handleResponse2(response, set, request);
+          if (response instanceof Promise)
+            return response.then((x) => mapEarlyResponse2(x, set));
+          if (response instanceof Error)
+            return errorToResponse2(response, set);
+          if (response instanceof ElysiaCustomStatusResponse)
+            return set.status = response.code, mapEarlyResponse2(response.response, set, request);
+          if (typeof response?.next == "function" || response instanceof ReadableStream)
+            return handleStream2(response, set, request);
+          if (typeof response?.then == "function")
+            return response.then((x) => mapEarlyResponse2(x, set));
+          if (typeof response?.toResponse == "function")
+            return mapEarlyResponse2(response.toResponse(), set);
+          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, set);
+          }
+          return new Response(response, set);
+      }
+    else
+      switch (response?.constructor?.name) {
+        case "String":
+          return new Response(response);
+        case "Array":
+        case "Object":
+          return Response.json(response, set);
+        case "ElysiaFile":
+          return handleFile(response.value, set, request);
+        case "File":
+          return handleFile(response, set, request);
+        case "Blob":
+          return handleFile(response, set, request);
+        case "ElysiaCustomStatusResponse":
+          return set.status = response.code, mapEarlyResponse2(response.response, set, request);
+        case undefined:
+          return response ? Response.json(response) : new Response("");
+        case "Response":
+          return response;
+        case "Promise":
+          return response.then((x) => {
+            const r = mapEarlyResponse2(x, set);
+            if (r !== undefined)
+              return r;
+          });
+        case "Error":
+          return errorToResponse2(response, set);
+        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, set) : new Response(response?.toString(), set);
+        case "FormData":
+          return new Response(response);
+        default:
+          if (response instanceof Response)
+            return response;
+          if (response instanceof Promise)
+            return response.then((x) => mapEarlyResponse2(x, set));
+          if (response instanceof Error)
+            return errorToResponse2(response, set);
+          if (response instanceof ElysiaCustomStatusResponse)
+            return set.status = response.code, mapEarlyResponse2(response.response, set, request);
+          if (typeof response?.next == "function" || response instanceof ReadableStream)
+            return handleStream2(response, set, request);
+          if (typeof response?.then == "function")
+            return response.then((x) => mapEarlyResponse2(x, set));
+          if (typeof response?.toResponse == "function")
+            return mapEarlyResponse2(response.toResponse(), set);
+          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, set);
+          }
+          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, undefined, request);
+    case "File":
+      return handleFile(response, undefined, request);
+    case "Blob":
+      return handleFile(response, undefined, request);
+    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 = (error, set) => {
+  if (typeof error?.toResponse == "function") {
+    const raw = error.toResponse(), targetSet = set ?? { 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: error?.name,
+    message: error?.message,
+    cause: error?.cause
+  }, {
+    status: set?.status !== 200 ? set?.status ?? 500 : 500,
+    headers: set?.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);
 
@@ -37085,7 +38477,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)
@@ -37135,13 +38527,15 @@ var handleUnion = (schemas, 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
 `;
@@ -37181,7 +38575,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")) {
@@ -37536,10 +38930,16 @@ var hasElysiaMeta = (meta, _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)
@@ -37692,6 +39092,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 mergeValues2(values, lastV);
+    }, mergeValues2 = 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, mergeValues = mergeValues2;
     const typeboxSubValidator = (schema2) => {
       let mirror2;
       if (normalize === true || normalize === "exactMirror")
@@ -37714,12 +39150,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)
@@ -37734,28 +39172,6 @@ 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,
@@ -37763,10 +39179,10 @@ var getSchemaValidator = (s, {
       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,
@@ -38033,6 +39449,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 = (schemas) => {
   if (schemas.length === 0)
     return {
@@ -38302,7 +39733,7 @@ break
       encodeSchema && value.hasTransform && !noValidate ? (code += `try{${name}=validator.response[${status2}].Encode(${name})
 `, appliedCleaner || (code += clean2({ ignoreTryCatch: true })), code += `c.set.status=${status2}}catch{` + (applyErrorCleaner ? `try{
 ` + clean2({ ignoreTryCatch: true }) + `${name}=validator.response[${status2}].Encode(${name})
-}catch{throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails})}` : `throw new ValidationError('response',validator.response[${status2}],${name}),${allowUnsafeValidationDetails}`) + "}") : (appliedCleaner || (code += clean2()), noValidate || (code += `if(validator.response[${status2}].Check(${name})===false)throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails})
+}catch{throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails})}` : `throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails})`) + "}") : (appliedCleaner || (code += clean2()), noValidate || (code += `if(validator.response[${status2}].Check(${name})===false)throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails})
 c.set.status=${status2}
 `)), code += `break
 `;
@@ -38318,7 +39749,7 @@ var isAsync = (v) => {
   if (isObject2 && v.isAsync !== undefined)
     return v.isAsync;
   const fn = isObject2 ? v.fn : v;
-  if (fn.constructor.name === "AsyncFunction")
+  if (fn.constructor.name === "AsyncFunction" || fn.constructor.name === "AsyncGeneratorFunction")
     return true;
   const literal = fn.toString();
   if (matchResponseClone.test(literal))
@@ -38387,8 +39818,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}) ${path}`, {
+          cause: `(${method}) ${path}`
+        });
       if (!cookieMeta.secrets)
-        throw new Error(`t.Cookie required secret which is not set in (${method}) ${path}.`);
+        throw new Error(`cookie secret must be defined (${method}) ${path}`, {
+          cause: `(${method}) ${path}`
+        });
       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)
@@ -38423,7 +39860,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 += `
@@ -38433,9 +39870,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) : ""})}`;
@@ -38470,11 +39907,11 @@ ${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}` : "";
+  }, mapResponseContext = adapter.mapResponseContext ? `,${adapter.mapResponseContext}` : "";
   (hasTrace || inference.route) && (fnLiteral += `c.route=\`${path}\`
 `), (hasTrace || hooks.afterResponse?.length) && (fnLiteral += `let afterHandlerStreamListener
 `);
@@ -38516,7 +39953,7 @@ try{`;
           fnLiteral += adapter.parser.formData(isOptionalBody);
           break;
         default:
-          parser[0] in app["~parser"] && (fnLiteral += hasHeaders ? "let contentType = c.headers['content-type']" : "let contentType = c.request.headers.get('content-type')", fnLiteral += `
+          parser in app["~parser"] && (fnLiteral += hasHeaders ? "let contentType = c.headers['content-type']" : "let contentType = c.request.headers.get('content-type')", fnLiteral += `
 if(contentType){const index=contentType.indexOf(';')
 if(index!==-1)contentType=contentType.substring(0,index)}
 else{contentType=''}c.contentType=contentType
@@ -38615,7 +40052,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 += "}";
@@ -38636,7 +40073,7 @@ delete c.contentType`);
         const transform2 = hooks.transform[i], endUnit = reporter.resolveChild(transform2.fn.name);
         fnLiteral += isAsync(transform2) ? `transformed=await e.transform[${i}](c)
 ` : `transformed=e.transform[${i}](c)
-`, transform2.subType === "mapDerive" ? fnLiteral += "if(transformed instanceof ElysiaCustomStatusResponse){" + mapResponse2("transformed") + `}else{transformed.request=c.request
+`, transform2.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
@@ -38644,7 +40081,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();
       }
     }
@@ -38754,12 +40191,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);
@@ -38778,22 +40210,25 @@ 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}])
 `);
       }
     }
-    validator.cookie && (validator.cookie.config = mergeCookie(validator.cookie.config, validator.cookie?.config ?? {}), fnLiteral += `let cookieValue={}
+    validator.cookie && (validator.cookie.config = mergeCookie(validator.cookie.config, app.config.cookie ?? {}), fnLiteral += `let cookieValue={}
 for(const [key,value] of Object.entries(c.cookie))cookieValue[key]=value.value
 `, validator.cookie.isOptional && (fnLiteral += "if(isNotEmpty(c.cookie)){"), validator.cookie.provider === "standard" ? (fnLiteral += `let vac=validator.cookie.Check(cookieValue)
 if(vac instanceof Promise)vac=await vac
 if(vac.issues){` + validation.validate("cookie", undefined, "vac.issues") + `}else{cookieValue=vac.value}
 `, fnLiteral += `for(const k of Object.keys(cookieValue))c.cookie[k].value=cookieValue[k]
-`) : validator.body?.schema?.noValidate !== true && (fnLiteral += "if(validator.cookie.Check(cookieValue)===false){" + validation.validate("cookie", "cookieValue") + "}", validator.cookie.hasTransform && (fnLiteral += coerceTransformDecodeError("for(const [key,value] of Object.entries(validator.cookie.Decode(cookieValue))){c.cookie[key].cookie.value = value}", "cookie", allowUnsafeValidationDetails))), validator.cookie.isOptional && (fnLiteral += "}"));
+`) : validator.cookie?.schema?.noValidate !== true && (fnLiteral += "if(validator.cookie.Check(cookieValue)===false){" + validation.validate("cookie", "cookieValue") + "}", validator.cookie.hasTransform && (fnLiteral += coerceTransformDecodeError("for(const [key,value] of Object.entries(validator.cookie.Decode(cookieValue))){c.cookie[key].value = value}", "cookie", allowUnsafeValidationDetails))), validator.cookie.isOptional && (fnLiteral += "}"));
   }
   if (hooks?.beforeHandle || hasTrace) {
     const reporter = report("beforeHandle", {
@@ -38808,7 +40243,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
@@ -38816,7 +40251,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)
@@ -38872,7 +40307,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 += `}
@@ -38910,7 +40346,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) {
@@ -38934,7 +40370,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}
@@ -38951,14 +40387,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 += `
@@ -38991,7 +40427,7 @@ if(er instanceof Promise)er=await er
           const mapResponse22 = hooks.mapResponse[i2], endUnit2 = mapResponseReporter.resolveChild(mapResponse22.fn.name);
           fnLiteral += `c.response=c.responseValue=er
 mep=e.mapResponse[${i2}](c)
-if(mep instanceof Promise)er=await er
+if(mep instanceof Promise)mep=await mep
 if(mep!==undefined)er=mep
 `, endUnit2();
         }
@@ -39276,9 +40712,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})}`;
@@ -39303,8 +40739,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();
     }
   }
@@ -39328,587 +40764,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, set, request) => {
-  if (isNotEmpty(set.headers) || set.status !== 200 || set.cookie)
-    switch (handleSet(set), response?.constructor?.name) {
-      case "String":
-        return new Response(response, set);
-      case "Array":
-      case "Object":
-        return set.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set);
-      case "ElysiaFile":
-        return handleFile(response.value, set);
-      case "File":
-        return handleFile(response, set);
-      case "Blob":
-        return handleFile(response, set);
-      case "ElysiaCustomStatusResponse":
-        return set.status = response.code, mapResponse2(response.response, set, request);
-      case undefined:
-        return response ? new Response(JSON.stringify(response), set) : new Response("", set);
-      case "Response":
-        return handleResponse2(response, set, request);
-      case "Error":
-        return errorToResponse2(response, set);
-      case "Promise":
-        return response.then((x) => mapResponse2(x, set, request));
-      case "Function":
-        return mapResponse2(response(), set, request);
-      case "Number":
-      case "Boolean":
-        return new Response(response.toString(), set);
-      case "Cookie":
-        return response instanceof Cookie ? new Response(response.value, set) : new Response(response?.toString(), set);
-      case "FormData":
-        return new Response(response, set);
-      default:
-        if (response instanceof Response)
-          return handleResponse2(response, set, request);
-        if (response instanceof Promise)
-          return response.then((x) => mapResponse2(x, set));
-        if (response instanceof Error)
-          return errorToResponse2(response, set);
-        if (response instanceof ElysiaCustomStatusResponse)
-          return set.status = response.code, mapResponse2(response.response, set, request);
-        if (typeof response?.next == "function" || response instanceof ReadableStream)
-          return handleStream2(response, set, request);
-        if (typeof response?.then == "function")
-          return response.then((x) => mapResponse2(x, set));
-        if (typeof response?.toResponse == "function")
-          return mapResponse2(response.toResponse(), set);
-        if ("charCodeAt" in response) {
-          const code = response.charCodeAt(0);
-          if (code === 123 || code === 91)
-            return set.headers["Content-Type"] || (set.headers["Content-Type"] = "application/json"), new Response(JSON.stringify(response), set);
-        }
-        return new Response(response, set);
-    }
-  return typeof response?.next == "function" || response instanceof ReadableStream ? handleStream2(response, set, request) : mapCompactResponse2(response, request);
-};
-var mapEarlyResponse2 = (response, set, request) => {
-  if (response != null)
-    if (isNotEmpty(set.headers) || set.status !== 200 || set.cookie)
-      switch (handleSet(set), response?.constructor?.name) {
-        case "String":
-          return new Response(response, set);
-        case "Array":
-        case "Object":
-          return set.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set);
-        case "ElysiaFile":
-          return handleFile(response.value, set);
-        case "File":
-          return handleFile(response, set);
-        case "Blob":
-          return handleFile(response, set);
-        case "ElysiaCustomStatusResponse":
-          return set.status = response.code, mapEarlyResponse2(response.response, set, request);
-        case undefined:
-          return response ? new Response(JSON.stringify(response), set) : undefined;
-        case "Response":
-          return handleResponse2(response, set, request);
-        case "Promise":
-          return response.then((x) => mapEarlyResponse2(x, set));
-        case "Error":
-          return errorToResponse2(response, set);
-        case "Function":
-          return mapEarlyResponse2(response(), set);
-        case "Number":
-        case "Boolean":
-          return new Response(response.toString(), set);
-        case "FormData":
-          return new Response(response);
-        case "Cookie":
-          return response instanceof Cookie ? new Response(response.value, set) : new Response(response?.toString(), set);
-        default:
-          if (response instanceof Response)
-            return handleResponse2(response, set, request);
-          if (response instanceof Promise)
-            return response.then((x) => mapEarlyResponse2(x, set));
-          if (response instanceof Error)
-            return errorToResponse2(response, set);
-          if (response instanceof ElysiaCustomStatusResponse)
-            return set.status = response.code, mapEarlyResponse2(response.response, set, request);
-          if (typeof response?.next == "function" || response instanceof ReadableStream)
-            return handleStream2(response, set, request);
-          if (typeof response?.then == "function")
-            return response.then((x) => mapEarlyResponse2(x, set));
-          if (typeof response?.toResponse == "function")
-            return mapEarlyResponse2(response.toResponse(), set);
-          if ("charCodeAt" in response) {
-            const code = response.charCodeAt(0);
-            if (code === 123 || code === 91)
-              return set.headers["Content-Type"] || (set.headers["Content-Type"] = "application/json"), new Response(JSON.stringify(response), set);
-          }
-          return new Response(response, set);
-      }
-    else
-      switch (response?.constructor?.name) {
-        case "String":
-          return new Response(response);
-        case "Array":
-        case "Object":
-          return set.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set);
-        case "ElysiaFile":
-          return handleFile(response.value, set);
-        case "File":
-          return handleFile(response, set);
-        case "Blob":
-          return handleFile(response, set);
-        case "ElysiaCustomStatusResponse":
-          return set.status = response.code, mapEarlyResponse2(response.response, set, 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, set);
-            if (r !== undefined)
-              return r;
-          });
-        case "Error":
-          return errorToResponse2(response, set);
-        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, set) : new Response(response?.toString(), set);
-        case "FormData":
-          return new Response(response);
-        default:
-          if (response instanceof Response)
-            return response;
-          if (response instanceof Promise)
-            return response.then((x) => mapEarlyResponse2(x, set));
-          if (response instanceof Error)
-            return errorToResponse2(response, set);
-          if (response instanceof ElysiaCustomStatusResponse)
-            return set.status = response.code, mapEarlyResponse2(response.response, set, request);
-          if (typeof response?.next == "function" || response instanceof ReadableStream)
-            return handleStream2(response, set, request);
-          if (typeof response?.then == "function")
-            return response.then((x) => mapEarlyResponse2(x, set));
-          if (typeof response?.toResponse == "function")
-            return mapEarlyResponse2(response.toResponse(), set);
-          if ("charCodeAt" in response) {
-            const code = response.charCodeAt(0);
-            if (code === 123 || code === 91)
-              return set.headers["Content-Type"] || (set.headers["Content-Type"] = "application/json"), new Response(JSON.stringify(response), set);
-          }
-          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 = (error, set) => {
-  if (typeof error?.toResponse == "function") {
-    const raw = error.toResponse(), targetSet = set ?? { 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: error?.name,
-    message: error?.message,
-    cause: error?.cause
-  }), {
-    status: set?.status !== 200 ? set?.status ?? 500 : 500,
-    headers: set?.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) => {
@@ -39966,14 +40821,14 @@ var createNativeStaticHandler = (handle, hooks, set) => {
     return;
   if (isHTMLBundle(handle))
     return () => handle;
-  const response = mapResponse2(handle, set ?? {
+  const response = mapResponse2(handle instanceof Response ? handle.clone() : handle instanceof Promise ? handle.then((x) => x instanceof Response ? x.clone() : isHTMLBundle(x) ? () => x : x) : handle, set ?? {
     headers: {}
   });
   if (!hooks.parse?.length && !hooks.transform?.length && !hooks.beforeHandle?.length && !hooks.afterHandle?.length)
     return response instanceof Promise ? response.then((response2) => {
       if (response2)
-        return response2.headers.has("content-type") || response2.headers.append("content-type", "text/plain"), response2.clone();
-    }) : (response.headers.has("content-type") || response.headers.append("content-type", "text/plain"), () => response.clone());
+        return response2.clone();
+    }) : () => response.clone();
 };
 
 // ../../node_modules/elysia/dist/ws/index.mjs
@@ -40153,6 +41008,11 @@ var mergeRoutes = (r1, r2) => {
     }
   return r1;
 };
+var removeTrailingPath = (routes) => {
+  for (const key of Object.keys(routes))
+    key.length > 1 && key.charCodeAt(key.length - 1) === 47 && (routes[key.slice(0, -1)] = routes[key], delete routes[key]);
+  return routes;
+};
 var BunAdapter = {
   ...WebStandardAdapter,
   name: "bun",
@@ -40209,13 +41069,13 @@ for(const [k,v] of c.request.headers.entries())c.headers[k]=v
             staticRoutes[path] = 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: !isProduction,
         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 || {},
@@ -40227,7 +41087,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 || {}
@@ -40243,12 +41103,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);
       });
     };
@@ -40358,11 +41220,86 @@ for(const [k,v] of c.request.headers.entries())c.headers[k]=v
   }
 };
 
+// ../../node_modules/elysia/dist/universal/env.mjs
+var env2 = isBun ? Bun.env : typeof process < "u" && process?.env ? process.env : {};
+
 // ../../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, path, value) => {
+  const keys = path.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) => {
@@ -40419,8 +41356,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;
             }
@@ -40457,8 +41394,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;
                     }
@@ -40502,8 +41439,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;
                 }
@@ -40557,11 +41494,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 ValidationError("query", validator.query, context.query);
@@ -40575,7 +41513,10 @@ var createDynamicHandler = (app) => {
         }
         if (validator.createBody?.()?.Check(body) === false)
           throw new ValidationError("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++) {
@@ -40611,14 +41552,22 @@ var createDynamicHandler = (app) => {
           isCustomStatuResponse && (set.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 ValidationError("response", responseValidator, response2);
-              response2 = temp;
-            } else
+            if (responseValidator?.Clean)
+              try {
+                const temp = responseValidator.Clean(response2);
+                if (responseValidator?.Check(temp) === false)
+                  throw new ValidationError("response", responseValidator, response2);
+                response2 = temp;
+              } catch (error) {
+                throw error instanceof ValidationError ? error : new ValidationError("response", responseValidator, response2);
+              }
+            else
               throw new ValidationError("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;
@@ -40628,14 +41577,22 @@ var createDynamicHandler = (app) => {
         isCustomStatuResponse && (set.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 ValidationError("response", responseValidator, response);
-            response = temp;
-          } else
+          if (responseValidator?.Clean)
+            try {
+              const temp = responseValidator.Clean(response);
+              if (responseValidator?.Check(temp) === false)
+                throw new ValidationError("response", responseValidator, response);
+              response = temp;
+            } catch (error) {
+              throw error instanceof ValidationError ? error : new ValidationError("response", responseValidator, response);
+            }
+          else
             throw new ValidationError("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;
@@ -40644,10 +41601,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);
@@ -41280,7 +42237,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;
@@ -41428,7 +42385,7 @@ var _Elysia = class _Elysia2 {
     });
     instance.singleton = { ...this.singleton }, instance.definitions = { ...this.definitions }, instance.inference = cloneInference(this.inference), instance.extender = { ...this.extender }, instance.getServer = () => this.getServer();
     const sandbox = run(instance);
-    return this.singleton = mergeDeep(this.singleton, instance.singleton), this.definitions = mergeDeep(this.definitions, instance.definitions), sandbox.getServer = () => this.server, sandbox.event.request?.length && (this.event.request = [
+    if (this.singleton = mergeDeep(this.singleton, instance.singleton), this.definitions = mergeDeep(this.definitions, instance.definitions), sandbox.getServer = () => this.server, sandbox.event.request?.length && (this.event.request = [
       ...this.event.request || [],
       ...sandbox.event.request || []
     ]), sandbox.event.mapResponse?.length && (this.event.mapResponse = [
@@ -41465,7 +42422,52 @@ var _Elysia = class _Elysia2 {
           }
         ] : localHook.standaloneValidator
       }));
-    }), this;
+    }), instance.promisedModules.size > 0) {
+      let processedUntil = instance.router.history.length;
+      for (const promise of instance.promisedModules.promises)
+        this.promisedModules.add(promise.then(() => {
+          const {
+            body,
+            headers,
+            query,
+            params,
+            cookie,
+            response,
+            ...guardHook
+          } = hook, hasStandaloneSchema = body || headers || query || params || cookie || response, startIndex = processedUntil;
+          processedUntil = instance.router.history.length;
+          for (let i = startIndex;i < instance.router.history.length; i++) {
+            const {
+              method,
+              path,
+              handler,
+              hooks: localHook
+            } = instance.router.history[i];
+            this.add(method, path, handler, mergeHook(guardHook, {
+              ...localHook || {},
+              error: localHook.error ? Array.isArray(localHook.error) ? [
+                ...localHook.error ?? [],
+                ...sandbox.event.error ?? []
+              ] : [
+                localHook.error,
+                ...sandbox.event.error ?? []
+              ] : sandbox.event.error,
+              standaloneValidator: hasStandaloneSchema ? [
+                ...localHook.standaloneValidator ?? [],
+                {
+                  body,
+                  headers,
+                  query,
+                  params,
+                  cookie,
+                  response
+                }
+              ] : localHook.standaloneValidator
+            }));
+          }
+        }));
+    }
+    return this;
   }
   use(plugin) {
     if (!plugin)
@@ -41666,19 +42668,7 @@ var _Elysia = class _Elysia2 {
     if (path instanceof _Elysia2 || typeof path == "function" || path.length === 0 || path === "/") {
       const run = typeof path == "function" ? path : path instanceof _Elysia2 ? path.compile().fetch : handleOrConfig instanceof _Elysia2 ? handleOrConfig.compile().fetch : typeof handleOrConfig == "function" ? handleOrConfig : (() => {
         throw new Error("Invalid handler");
-      })(), handler2 = ({ request, path: path2 }) => run(new Request(replaceUrlPath(request.url, path2), {
-        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: path2 }) => run(new Request(replaceUrlPath(request.url, path2), request));
       return this.route("ALL", "/*", handler2, {
         parse: "none",
         ...config,
@@ -41693,19 +42683,7 @@ var _Elysia = class _Elysia2 {
     }
     const handle = handleOrConfig instanceof _Elysia2 ? handleOrConfig.compile().fetch : typeof handleOrConfig == "function" ? handleOrConfig : (() => {
       throw new Error("Invalid handler");
-    })(), length = (typeof path == "string" && this.config.prefix ? this.config.prefix + path : path).length - (path.endsWith("*") ? 1 : 0), handler = ({ request, path: path2 }) => handle(new Request(replaceUrlPath(request.url, path2.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 path == "string" && this.config.prefix ? this.config.prefix + path : path).length - (path.endsWith("*") ? 1 : 0), handler = ({ request, path: path2 }) => handle(new Request(replaceUrlPath(request.url, path2.slice(length) || "/"), request));
     return this.route("ALL", path, handler, {
       parse: "none",
       ...config,
@@ -41999,13 +42977,14 @@ async function createDoneHttpLocalServer(config, chain) {
     set.headers["access-control-allow-methods"] = "GET,POST,OPTIONS";
   }).options("*", ({ set }) => {
     set.status = 204;
-  }).get("/healthz", () => ({ ok: true, height: runtime.height })).post("/contracts/js", async ({ body, set }) => {
+  }).get("/healthz", () => ({ ok: true, height: runtime.height, updated: true })).post("/contracts/js", async ({ body, set }) => {
     const payload = body;
     try {
       if (!payload.script && !payload.script_path) {
         set.status = 400;
         return { error: "provide script or script_path" };
       }
+      console.log("deploying...");
       const result = await deployJsContract({
         chain: runtime,
         sender: config.owner,
@@ -42058,6 +43037,7 @@ async function createDoneHttpLocalServer(config, chain) {
     try {
       const msg = decodeQueryMsg(query.msg);
       const result = runtime.query(params.address, msg);
+      console.log("Query result:", result);
       return unwrapQueryResult(result);
     } catch (error) {
       set.status = 400;
@@ -42435,6 +43415,24 @@ var createEventStream = (pubsub, subscriptionPath) => {
   });
 };
 // src/index.ts
+function readCliPackageMetadata() {
+  try {
+    const pkgUrl = new URL("../package.json", import.meta.url);
+    const raw = readFileSync3(pkgUrl);
+    return JSON.parse(raw.toString("utf8"));
+  } catch {
+    return {};
+  }
+}
+function normalizeVersion(value) {
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value.trim();
+  }
+  return null;
+}
+function toCaretRange(version) {
+  return version.startsWith("^") ? version : `^${version}`;
+}
 function notImplemented(label) {
   console.error(`The command segment '${label}' is not implemented yet.\nSee packages/done-cli/SPEC.md for the planned behaviour.`);
   process.exit(1);
@@ -42477,7 +43475,7 @@ async function handleBuild(options) {
     const entryPath = path.resolve(manifestInfo.manifestDir, contract.entry);
     const outFilePath = path.resolve(manifestInfo.manifestDir, contract.outFile);
     await ensureEntryExists(entryPath, contract.name);
-    await fs.mkdir(path.dirname(outFilePath), { recursive: true });
+    await fs2.mkdir(path.dirname(outFilePath), { recursive: true });
     const relEntry = path.relative(process.cwd(), entryPath) || entryPath;
     const relOutFile = path.relative(process.cwd(), outFilePath) || outFilePath;
     console.log(`- bundling ${contract.name} (${relEntry})`);
@@ -42495,7 +43493,7 @@ async function handleBuild(options) {
 async function handlePublish(options) {
   const scriptPath = path.resolve(process.cwd(), options.script);
   await ensureFileExists(scriptPath, "script");
-  const script = await fs.readFile(scriptPath, "utf8");
+  const script = await fs2.readFile(scriptPath, "utf8");
   const msg = options.msg ? await loadMsgPayload(options.msg) : undefined;
   const baseUrl = resolveDoneHttpBase(options.http);
   const backend = new DoneBackendClient({ baseUrl });
@@ -42519,7 +43517,7 @@ async function detectWorkspace(root) {
   if (!existsSync2(configPath)) {
     return null;
   }
-  const configRaw = await fs.readFile(configPath, "utf8");
+  const configRaw = await fs2.readFile(configPath, "utf8");
   const config2 = JSON.parse(configRaw);
   const configuredManifestPath = config2.contractsFile ? path.isAbsolute(config2.contractsFile) ? config2.contractsFile : path.resolve(root, config2.contractsFile) : path.join(root, "done.json");
   const fallbackManifestPath = path.join(root, "done.json");
@@ -42527,7 +43525,7 @@ async function detectWorkspace(root) {
   if (!manifestPath) {
     return null;
   }
-  const manifestRaw = await fs.readFile(manifestPath, "utf8");
+  const manifestRaw = await fs2.readFile(manifestPath, "utf8");
   const manifest = JSON.parse(manifestRaw);
   return { root, manifestPath, configPath, manifest, config: config2 };
 }
@@ -42560,7 +43558,7 @@ async function findWorkspace(startDir) {
 async function readManifest(manifestPath) {
   let raw;
   try {
-    raw = await fs.readFile(manifestPath, "utf8");
+    raw = await fs2.readFile(manifestPath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new Error(`Could not find ${manifestPath}. Pass a valid --contracts path or run from a Done workspace.`);
@@ -42584,7 +43582,7 @@ async function scaffoldWorkspace(rawName, options) {
   await prepareTargetDir(targetDir, options.force === true);
   const localTemplatePath = await resolveLocalTemplate(templateRef);
   if (localTemplatePath) {
-    await fs.cp(localTemplatePath, targetDir, { recursive: true });
+    await fs2.cp(localTemplatePath, targetDir, { recursive: true });
   } else {
     await runCommand("git", ["clone", "--depth", "1", templateRef, targetDir]);
   }
@@ -42595,6 +43593,7 @@ async function scaffoldWorkspace(rawName, options) {
   await updatePackageJson(path.join(targetDir, "frontend", "package.json"), (pkg) => {
     pkg.name = `${slug}-frontend`;
   });
+  await syncWorkspaceDependencyVersions(targetDir);
   if (options.install !== false) {
     await runCommand("bun", ["install"], { cwd: targetDir });
   }
@@ -42615,7 +43614,7 @@ async function scaffoldContract(workspace, rawName, options) {
   const contractsDir = resolveContractsDir(workspace.root, workspace.config.contractsDir);
   const contractDir = path.join(contractsDir, slug);
   await ensureDirAvailable(contractDir, options.force === true);
-  await fs.mkdir(path.join(contractDir, "src"), { recursive: true });
+  await fs2.mkdir(path.join(contractDir, "src"), { recursive: true });
   const pkgJsonPath = path.join(contractDir, "package.json");
   const pkgJson = {
     name: slug,
@@ -42626,7 +43625,7 @@ async function scaffoldContract(workspace, rawName, options) {
       typecheck: "tsc -p tsconfig.json --noEmit"
     },
     dependencies: {
-      "done.zone": "^0.1.0"
+      "done.zone": DONE_ZONE_VERSION_RANGE
     }
   };
   await writeJson(pkgJsonPath, pkgJson);
@@ -42689,7 +43688,7 @@ export default Done.serve()
     },
   );
 `;
-  await fs.writeFile(path.join(contractDir, "src", "index.ts"), contractSource, "utf8");
+  await fs2.writeFile(path.join(contractDir, "src", "index.ts"), contractSource, "utf8");
   workspace.manifest.contracts ??= [];
   const contractDirRel = normalizeJsonPath(path.relative(workspace.root, contractDir));
   const entry = ensureDotSlash(`${contractDirRel}/src/index.ts`);
@@ -42720,7 +43719,7 @@ export default Done.serve()
 async function resolveLocalTemplate(reference) {
   const potentialPath = path.isAbsolute(reference) ? reference : path.resolve(process.cwd(), reference);
   try {
-    const stats = await fs.stat(potentialPath);
+    const stats = await fs2.stat(potentialPath);
     if (stats.isDirectory()) {
       return potentialPath;
     }
@@ -42735,7 +43734,7 @@ async function prepareTargetDir(targetDir, force) {
   if (!force) {
     throw new Error(`Directory '${path.relative(process.cwd(), targetDir) || targetDir}' already exists. Use --force to overwrite.`);
   }
-  await fs.rm(targetDir, { recursive: true, force: true });
+  await fs2.rm(targetDir, { recursive: true, force: true });
 }
 async function ensureDirAvailable(targetDir, force) {
   if (!existsSync2(targetDir)) {
@@ -42744,10 +43743,10 @@ async function ensureDirAvailable(targetDir, force) {
   if (!force) {
     throw new Error(`Directory '${path.relative(process.cwd(), targetDir) || targetDir}' already exists. Use --force to overwrite.`);
   }
-  await fs.rm(targetDir, { recursive: true, force: true });
+  await fs2.rm(targetDir, { recursive: true, force: true });
 }
 async function removeGitFolder(targetDir) {
-  await fs.rm(path.join(targetDir, ".git"), { recursive: true, force: true });
+  await fs2.rm(path.join(targetDir, ".git"), { recursive: true, force: true });
 }
 function resolveContractsDir(root, configured) {
   if (!configured) {
@@ -42760,7 +43759,7 @@ function resolveContractsDir(root, configured) {
 }
 async function updatePackageJson(file2, mutator) {
   try {
-    const current = JSON.parse(await fs.readFile(file2, "utf8"));
+    const current = JSON.parse(await fs2.readFile(file2, "utf8"));
     mutator(current);
     await writeJson(file2, current);
   } catch (error) {
@@ -42777,6 +43776,50 @@ function normalizeJsonPath(relativePath) {
   const normalized = relativePath.split(path.sep).join("/");
   return normalized.startsWith("./") || normalized.startsWith("../") ? normalized : `./${normalized}`;
 }
+function ensureDependency(pkg, field, name, version) {
+  const bucket = pkg[field] ??= {};
+  bucket[name] = version;
+}
+function updateDependencyIfPresent(pkg, name, version) {
+  let updated = false;
+  const fields = ["dependencies", "devDependencies"];
+  for (const field of fields) {
+    const bucket = pkg[field];
+    if (bucket && typeof bucket === "object" && bucket[name]) {
+      bucket[name] = version;
+      updated = true;
+    }
+  }
+  return updated;
+}
+async function syncWorkspaceDependencyVersions(targetDir) {
+  await updatePackageJson(path.join(targetDir, "package.json"), (pkg) => {
+    ensureDependency(pkg, "devDependencies", "@donezone/cli", CLI_VERSION_RANGE);
+    ensureDependency(pkg, "devDependencies", "done.zone", DONE_ZONE_VERSION_RANGE);
+  });
+  await updatePackageJson(path.join(targetDir, "frontend", "package.json"), (pkg) => {
+    if (!updateDependencyIfPresent(pkg, "@donezone/client", DONE_CLIENT_VERSION_RANGE)) {
+      ensureDependency(pkg, "dependencies", "@donezone/client", DONE_CLIENT_VERSION_RANGE);
+    }
+  });
+  await updateContractDependencyVersions(path.join(targetDir, "contracts"));
+}
+async function updateContractDependencyVersions(contractsDir) {
+  let entries;
+  try {
+    entries = await fs2.readdir(contractsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  await Promise.all(entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+    const pkgPath = path.join(contractsDir, entry.name, "package.json");
+    await updatePackageJson(pkgPath, (pkg) => {
+      if (!updateDependencyIfPresent(pkg, "done.zone", DONE_ZONE_VERSION_RANGE)) {
+        ensureDependency(pkg, "dependencies", "done.zone", DONE_ZONE_VERSION_RANGE);
+      }
+    });
+  }));
+}
 function matchesContract(contract, manifestDir, matchers) {
   const candidates = [];
   if (contract.name) {
@@ -42817,7 +43860,7 @@ function escapeRegExp(value) {
 }
 async function ensureEntryExists(entryPath, contractName) {
   try {
-    const stats = await fs.stat(entryPath);
+    const stats = await fs2.stat(entryPath);
     if (!stats.isFile()) {
       const relPath = path.relative(process.cwd(), entryPath) || entryPath;
       throw new Error(`Entry path for contract '${contractName}' is not a file (${relPath})`);
@@ -42832,7 +43875,7 @@ async function ensureEntryExists(entryPath, contractName) {
 }
 async function ensureFileExists(filePath, label) {
   try {
-    const stats = await fs.stat(filePath);
+    const stats = await fs2.stat(filePath);
     if (!stats.isFile()) {
       throw new Error(`The ${label} path is not a file (${filePath})`);
     }
@@ -42846,7 +43889,7 @@ async function ensureFileExists(filePath, label) {
 async function loadMsgPayload(input) {
   const potentialPath = path.resolve(process.cwd(), input);
   if (await pathExists(potentialPath)) {
-    const raw = await fs.readFile(potentialPath, "utf8");
+    const raw = await fs2.readFile(potentialPath, "utf8");
     return JSON.parse(raw);
   }
   return JSON.parse(input);
@@ -42856,7 +43899,7 @@ function resolveDoneHttpBase(override) {
 }
 async function pathExists(candidate) {
   try {
-    await fs.access(candidate);
+    await fs2.access(candidate);
     return true;
   } catch {
     return false;
@@ -42885,7 +43928,7 @@ async function runBunBuild(entryPath, outFilePath) {
       throw new Error("Bun.build did not emit an output file");
     }
     const bundledSource = await output2.text();
-    await fs.writeFile(outFilePath, bundledSource);
+    await fs2.writeFile(outFilePath, bundledSource);
     return;
   }
   await runBunCliBuild(entryPath, outFilePath);
@@ -42946,7 +43989,7 @@ function toContractName(slug) {
 }
 async function writeJson(file2, data) {
   const json = JSON.stringify(data, null, 2);
-  await fs.writeFile(file2, `${json}\n`, "utf8");
+  await fs2.writeFile(file2, `${json}\n`, "utf8");
 }
 function describeStorageEntry(entry) {
   const valueBase64 = entry.value ?? "";
@@ -43053,15 +44096,15 @@ function resolveDevConfig(workspace) {
   };
 }
 async function writeDevEnvFile(file2, entries) {
-  await fs.mkdir(path.dirname(file2), { recursive: true });
+  await fs2.mkdir(path.dirname(file2), { recursive: true });
   const lines = ["# generated by done dev", `# ${new Date().toISOString()}`];
   for (const key of Object.keys(entries).sort()) {
     lines.push(`${key}=${entries[key]}`);
   }
-  await fs.writeFile(file2, `${lines.join("\n")}\n`, "utf8");
+  await fs2.writeFile(file2, `${lines.join("\n")}\n`, "utf8");
 }
 async function readDevEnvFile(file2) {
-  const data = await fs.readFile(file2, "utf8");
+  const data = await fs2.readFile(file2, "utf8");
   const entries = {};
   for (const line of data.split(/\r?\n/)) {
     if (!line || line.startsWith("#"))
@@ -43098,6 +44141,13 @@ function openBrowser(url) {
     }
   });
 }
+var packageMetadata = readCliPackageMetadata();
+var CLI_VERSION = normalizeVersion(packageMetadata.version) ?? "0.0.0-spec";
+var CLI_VERSION_RANGE = toCaretRange(CLI_VERSION);
+var DONE_ZONE_VERSION = normalizeVersion(packageMetadata.doneZoneVersion) ?? CLI_VERSION;
+var DONE_ZONE_VERSION_RANGE = toCaretRange(DONE_ZONE_VERSION);
+var DONE_CLIENT_VERSION = normalizeVersion(packageMetadata.doneClientVersion) ?? CLI_VERSION;
+var DONE_CLIENT_VERSION_RANGE = toCaretRange(DONE_CLIENT_VERSION);
 var bunRuntime = globalThis.Bun;
 if (typeof bunRuntime === "undefined") {
   const bunExecutable = process.env.BUN ?? "bun";
@@ -43112,7 +44162,7 @@ if (typeof bunRuntime === "undefined") {
 }
 var DEFAULT_TEMPLATE_REPO = "https://github.com/mccallofthewild/done-template.git";
 var program2 = new Command;
-program2.name("done").description("Done developer toolkit (spec-first stub)").version("0.0.0-spec");
+program2.name("done").description("Done developer toolkit (spec-first stub)").version(CLI_VERSION);
 program2.command("build").description("Bundle Done contracts defined in done.json").option("-j, --contracts <path>", "Path to done.json").option("-n, --name <name...>", "Filter contract names").action(async (options) => {
   try {
     await handleBuild(options);
@@ -43289,7 +44339,7 @@ class DoneDevOrchestrator {
   }
   async buildBundle(contract, initial, reason) {
     await ensureEntryExists(contract.entryPath, contract.name);
-    await fs.mkdir(path.dirname(contract.outFilePath), { recursive: true });
+    await fs2.mkdir(path.dirname(contract.outFilePath), { recursive: true });
     const startedAt = Date.now();
     const label = initial ? "Building" : "Rebuilding";
     this.logInfo(`${label} ${contract.name}${reason ? ` (${reason})` : ""}`);
@@ -43369,7 +44419,7 @@ class DoneDevOrchestrator {
   async publishContract(contract) {
     if (!this.chain || !contract.address)
       return;
-    const script = await fs.readFile(contract.outFilePath, "utf8");
+    const script = await fs2.readFile(contract.outFilePath, "utf8");
     const execResult = this.chain.execute(contract.address, {
       publish_code: {
         script,
@@ -43405,7 +44455,7 @@ class DoneDevOrchestrator {
       entries: entries.map(describeStorageEntry)
     };
     const storageDir = path.join(this.options.workspace.root, ".done", "storage");
-    await fs.mkdir(storageDir, { recursive: true });
+    await fs2.mkdir(storageDir, { recursive: true });
     const filePath = path.join(storageDir, `${contract.slug}.json`);
     await writeJson(filePath, snapshot);
   }