elysia 1.4.28 → 2.0.0-beta.0

package/dist/utils.js

@@ -1,697 +1,736 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: !0 });
-}, __copyProps = (to, from, except, desc) => {
-  if (from && typeof from == "object" || typeof from == "function")
-    for (let key of __getOwnPropNames(from))
-      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  return to;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_universal_constants = require('./universal/constants.js');
+const require_constants = require('./constants.js');
+const require_universal_file = require('./universal/file.js');
+
+//#region src/utils.ts
+const nullObject = () => Object.create(null);
+const mapDeriveEntry = (fn) => [fn, "mapDerive"];
+const deriveEntryFn = (entry) => Array.isArray(entry) ? entry[0] : entry;
+const isMapDeriveEntry = (entry) => Array.isArray(entry) && entry[1] === "mapDerive";
+function isEmpty(obj) {
+	for (const _ in obj) return false;
+	return true;
+}
+const isNotEmpty = (obj) => obj && !isEmpty(obj);
+const FNV_OFFSET_BASIS = 2166136261;
+const FNV_PRIME = 16777619;
+/**
+* @internal Generational cache eviction at cap, drop the oldest half.
+*
+* `map.delete(oldest)` per insert leaks ~1KB/eviction on JSC in ~1/3 of
+* processes (churned bucket cells permanently grow the heap and are never
+* reclaimed); clear + reinsert of the newest half measures clean and
+* amortizes to O(1) per insertion.
+*/
+function evictOldestHalf(cache) {
+	const keep = [...cache].slice(cache.size >> 1);
+	cache.clear();
+	for (const entry of keep) cache.set(entry[0], entry[1]);
+}
+function fnv1a(str) {
+	let hash = FNV_OFFSET_BASIS;
+	const len = str.length;
+	for (let i = 0; i < len; i++) {
+		hash ^= str.charCodeAt(i);
+		hash = Math.imul(hash, FNV_PRIME);
+	}
+	return hash >>> 0;
+}
+/**
+* Maps each lifecycle/derive function to the hash of the named plugin it was
+* first registered on. Used by `.use()` to dedup absorbed hooks: if a fn's
+* origin is already in `parent.#apps`, the parent has already absorbed that
+* named plugin via another path and should skip re-adding the fn.
+*
+* Anonymous plugins (no name) don't tag their fns - there's no hash to dedup
+* by, so their fns always propagate.
+*/
+const fnOrigin = /* @__PURE__ */ new WeakMap();
+const macroOrigin = /* @__PURE__ */ new WeakMap();
+const isLocalScope = (s) => s === "local" || s === void 0;
+const COMPACT_CHUNK_SIZE = 32;
+const emptyCompactBeforeHandlePrefix = {
+	length: 0,
+	added: []
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  ELYSIA_FORM_DATA: () => ELYSIA_FORM_DATA,
-  ELYSIA_REQUEST_ID: () => ELYSIA_REQUEST_ID,
-  InvertedStatusMap: () => InvertedStatusMap,
-  PromiseGroup: () => PromiseGroup,
-  StatusMap: () => StatusMap,
-  asHookType: () => asHookType,
-  checksum: () => checksum,
-  cloneInference: () => cloneInference,
-  deduplicateChecksum: () => deduplicateChecksum,
-  deepClone: () => deepClone,
-  emptySchema: () => emptySchema,
-  encodePath: () => encodePath,
-  filterGlobalHook: () => filterGlobalHook,
-  fnToContainer: () => fnToContainer,
-  form: () => form,
-  getLoosePath: () => getLoosePath,
-  getResponseLength: () => getResponseLength,
-  hasHeaderShorthand: () => hasHeaderShorthand,
-  hasSetImmediate: () => hasSetImmediate,
-  injectChecksum: () => injectChecksum,
-  insertStandaloneValidator: () => insertStandaloneValidator,
-  isClass: () => isClass,
-  isNotEmpty: () => isNotEmpty,
-  isNumericString: () => isNumericString,
-  lifeCycleToArray: () => lifeCycleToArray,
-  lifeCycleToFn: () => lifeCycleToFn,
-  localHookToLifeCycleStore: () => localHookToLifeCycleStore,
-  mergeCookie: () => mergeCookie,
-  mergeDeep: () => mergeDeep,
-  mergeHook: () => mergeHook,
-  mergeLifeCycle: () => mergeLifeCycle,
-  mergeObjectArray: () => mergeObjectArray,
-  mergeResponse: () => mergeResponse,
-  mergeSchemaValidator: () => mergeSchemaValidator,
-  primitiveHooks: () => primitiveHooks,
-  promoteEvent: () => promoteEvent,
-  randomId: () => randomId,
-  redirect: () => redirect,
-  replaceUrlPath: () => replaceUrlPath,
-  signCookie: () => signCookie,
-  sse: () => sse,
-  supportPerMethodInlineHandler: () => supportPerMethodInlineHandler,
-  unsignCookie: () => unsignCookie
-});
-module.exports = __toCommonJS(utils_exports);
-var import_file = require('./universal/file.js'), import_utils = require('./universal/utils.js');
-const 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)}`;
-}, isClass = (v) => typeof v == "function" && /^\s*class\s+/.test(v.toString()) || // Handle Object.create(null)
-v.toString && // Handle import * as Sentry from '@sentry/bun'
-// This also handle [object Date], [object Array]
-// and FFI value like [object Prisma]
-v.toString().startsWith("[object ") && v.toString() !== "[object Object]" || // If object prototype is not pure, then probably a class-like object
-isNotEmpty(Object.getPrototypeOf(v)), isObject = (item) => item && typeof item == "object" && !Array.isArray(item), mergeDeep = (target, source, options) => {
-  const skipKeys = options?.skipKeys, override = options?.override ?? !0, mergeArray = options?.mergeArray ?? !1, seen = options?.seen ?? /* @__PURE__ */ new WeakSet();
-  if (!isObject(target) || !isObject(source) || seen.has(source)) return target;
-  seen.add(source);
-  for (const [key, value] of Object.entries(source))
-    if (!(skipKeys?.includes(key) || ["__proto__", "constructor", "prototype"].includes(key))) {
-      if (mergeArray && Array.isArray(value)) {
-        target[key] = Array.isArray(
-          target[key]
-        ) ? [...target[key], ...value] : target[key] = value;
-        continue;
-      }
-      if (!isObject(value) || !(key in target) || isClass(value)) {
-        if ((override || !(key in target)) && !Object.isFrozen(target))
-          try {
-            target[key] = value;
-          } catch {
-          }
-        continue;
-      }
-      if (!Object.isFrozen(target[key]))
-        try {
-          target[key] = mergeDeep(
-            target[key],
-            value,
-            { skipKeys, override, mergeArray, seen }
-          );
-        } catch {
-        }
-    }
-  return seen.delete(source), target;
-}, mergeCookie = (a, b) => {
-  const v = mergeDeep(Object.assign({}, a), b, {
-    skipKeys: ["properties"],
-    mergeArray: !1
-  });
-  return v.properties && delete v.properties, v;
-}, mergeObjectArray = (a, b) => {
-  if (!b) return a;
-  const array = [], checksums = [];
-  if (a) {
-    Array.isArray(a) || (a = [a]);
-    for (const item of a)
-      array.push(item), item.checksum && checksums.push(item.checksum);
-  }
-  if (b) {
-    Array.isArray(b) || (b = [b]);
-    for (const item of b)
-      checksums.includes(item.checksum) || array.push(item);
-  }
-  return array;
-}, primitiveHooks = [
-  "start",
-  "request",
-  "parse",
-  "transform",
-  "resolve",
-  "beforeHandle",
-  "afterHandle",
-  "mapResponse",
-  "afterResponse",
-  "trace",
-  "error",
-  "stop",
-  "body",
-  "headers",
-  "params",
-  "query",
-  "response",
-  "type",
-  "detail"
-], primitiveHookMap = primitiveHooks.reduce(
-  (acc, x) => (acc[x] = !0, acc),
-  {}
-), isRecordNumber = (x) => typeof x == "object" && Object.keys(x).every((x2) => !isNaN(+x2)), mergeResponse = (a, b) => isRecordNumber(a) && isRecordNumber(b) ? Object.assign({}, a, b) : a && !isRecordNumber(a) && isRecordNumber(b) ? Object.assign({ 200: a }, b) : b ?? a, mergeSchemaValidator = (a, b) => !a && !b ? {
-  body: void 0,
-  headers: void 0,
-  params: void 0,
-  query: void 0,
-  cookie: void 0,
-  response: void 0
-} : {
-  body: b?.body ?? a?.body,
-  headers: b?.headers ?? a?.headers,
-  params: b?.params ?? a?.params,
-  query: b?.query ?? a?.query,
-  cookie: b?.cookie ?? a?.cookie,
-  // @ts-ignore ? This order is correct - SaltyAom
-  response: mergeResponse(
-    // @ts-ignore
-    a?.response,
-    // @ts-ignore
-    b?.response
-  )
-}, mergeHook = (a, b) => {
-  if (!b) return a ?? {};
-  if (!a) return b ?? {};
-  if (!Object.values(b).find((x) => x != null))
-    return { ...a };
-  const hook = {
-    ...a,
-    ...b,
-    // Merge local hook first
-    // @ts-ignore
-    body: b.body ?? a.body,
-    // @ts-ignore
-    headers: b.headers ?? a.headers,
-    // @ts-ignore
-    params: b.params ?? a.params,
-    // @ts-ignore
-    query: b.query ?? a.query,
-    // @ts-ignore
-    cookie: b.cookie ?? a.cookie,
-    // ? This order is correct - SaltyAom
-    response: mergeResponse(
-      // @ts-ignore
-      a.response,
-      // @ts-ignore
-      b.response
-    ),
-    type: a.type || b.type,
-    detail: mergeDeep(
-      // @ts-ignore
-      b.detail ?? {},
-      // @ts-ignore
-      a.detail ?? {}
-    ),
-    parse: mergeObjectArray(a.parse, b.parse),
-    transform: mergeObjectArray(a.transform, b.transform),
-    beforeHandle: mergeObjectArray(
-      mergeObjectArray(
-        // @ts-ignore
-        fnToContainer(a.resolve, "resolve"),
-        a.beforeHandle
-      ),
-      mergeObjectArray(
-        fnToContainer(b.resolve, "resolve"),
-        b.beforeHandle
-      )
-    ),
-    afterHandle: mergeObjectArray(a.afterHandle, b.afterHandle),
-    mapResponse: mergeObjectArray(a.mapResponse, b.mapResponse),
-    afterResponse: mergeObjectArray(
-      a.afterResponse,
-      b.afterResponse
-    ),
-    trace: mergeObjectArray(a.trace, b.trace),
-    error: mergeObjectArray(a.error, b.error),
-    // @ts-ignore
-    standaloneSchema: (
-      // @ts-ignore
-      a.standaloneSchema || b.standaloneSchema ? (
-        // @ts-ignore
-        a.standaloneSchema && !b.standaloneSchema ? (
-          // @ts-ignore
-          a.standaloneSchema
-        ) : (
-          // @ts-ignore
-          b.standaloneSchema && !a.standaloneSchema ? b.standaloneSchema : [
-            // @ts-ignore
-            ...a.standaloneSchema ?? [],
-            ...b.standaloneSchema ?? []
-          ]
-        )
-      ) : void 0
-    )
-  };
-  return hook.resolve && delete hook.resolve, hook;
-}, lifeCycleToArray = (a) => {
-  a.parse && !Array.isArray(a.parse) && (a.parse = [a.parse]), a.transform && !Array.isArray(a.transform) && (a.transform = [a.transform]), a.afterHandle && !Array.isArray(a.afterHandle) && (a.afterHandle = [a.afterHandle]), a.mapResponse && !Array.isArray(a.mapResponse) && (a.mapResponse = [a.mapResponse]), a.afterResponse && !Array.isArray(a.afterResponse) && (a.afterResponse = [a.afterResponse]), a.trace && !Array.isArray(a.trace) && (a.trace = [a.trace]), a.error && !Array.isArray(a.error) && (a.error = [a.error]);
-  let beforeHandle = [];
-  return a.resolve && (beforeHandle = fnToContainer(
-    // @ts-expect-error
-    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;
-}, hasHeaderShorthand = import_utils.isBun ? "toJSON" in new Headers() : !1, hasSetImmediate = typeof setImmediate == "function", checksum = (s) => {
-  let h = 9;
-  for (let i = 0; i < s.length; ) h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
-  return h = h ^ h >>> 9;
-}, injectChecksum = (checksum2, x) => {
-  if (!x) return;
-  if (!Array.isArray(x)) {
-    const fn = x;
-    return checksum2 && !fn.checksum && (fn.checksum = checksum2), fn.scope === "scoped" && (fn.scope = "local"), fn;
-  }
-  const fns = [...x];
-  for (const fn of fns)
-    checksum2 && !fn.checksum && (fn.checksum = checksum2), fn.scope === "scoped" && (fn.scope = "local");
-  return fns;
-}, mergeLifeCycle = (a, b, checksum2) => ({
-  start: mergeObjectArray(
-    a.start,
-    injectChecksum(checksum2, b?.start)
-  ),
-  request: mergeObjectArray(
-    a.request,
-    injectChecksum(checksum2, b?.request)
-  ),
-  parse: mergeObjectArray(
-    a.parse,
-    injectChecksum(checksum2, b?.parse)
-  ),
-  transform: mergeObjectArray(
-    a.transform,
-    injectChecksum(checksum2, b?.transform)
-  ),
-  beforeHandle: mergeObjectArray(
-    mergeObjectArray(
-      // @ts-ignore
-      fnToContainer(a.resolve, "resolve"),
-      a.beforeHandle
-    ),
-    injectChecksum(
-      checksum2,
-      mergeObjectArray(
-        fnToContainer(b?.resolve, "resolve"),
-        b?.beforeHandle
-      )
-    )
-  ),
-  afterHandle: mergeObjectArray(
-    a.afterHandle,
-    injectChecksum(checksum2, b?.afterHandle)
-  ),
-  mapResponse: mergeObjectArray(
-    a.mapResponse,
-    injectChecksum(checksum2, b?.mapResponse)
-  ),
-  afterResponse: mergeObjectArray(
-    a.afterResponse,
-    injectChecksum(checksum2, b?.afterResponse)
-  ),
-  // Already merged on Elysia._use, also logic is more complicated, can't directly merge
-  trace: mergeObjectArray(
-    a.trace,
-    injectChecksum(checksum2, b?.trace)
-  ),
-  error: mergeObjectArray(
-    a.error,
-    injectChecksum(checksum2, b?.error)
-  ),
-  stop: mergeObjectArray(
-    a.stop,
-    injectChecksum(checksum2, b?.stop)
-  )
-}), asHookType = (fn, inject, { skipIfHasType = !1 }) => {
-  if (!fn) return fn;
-  if (!Array.isArray(fn))
-    return skipIfHasType ? fn.scope ??= inject : fn.scope = inject, fn;
-  for (const x of fn)
-    skipIfHasType ? x.scope ??= inject : x.scope = inject;
-  return fn;
-}, filterGlobal = (fn) => {
-  if (!fn) return fn;
-  if (!Array.isArray(fn))
-    switch (fn.scope) {
-      case "global":
-      case "scoped":
-        return { ...fn };
-      default:
-        return { fn };
-    }
-  const array = [];
-  for (const x of fn)
-    switch (x.scope) {
-      case "global":
-      case "scoped":
-        array.push({
-          ...x
-        });
-        break;
-    }
-  return array;
-}, filterGlobalHook = (hook) => ({
-  // rest is validator
-  ...hook,
-  type: hook?.type,
-  detail: hook?.detail,
-  parse: filterGlobal(hook?.parse),
-  transform: filterGlobal(hook?.transform),
-  beforeHandle: filterGlobal(hook?.beforeHandle),
-  afterHandle: filterGlobal(hook?.afterHandle),
-  mapResponse: filterGlobal(hook?.mapResponse),
-  afterResponse: filterGlobal(hook?.afterResponse),
-  error: filterGlobal(hook?.error),
-  trace: filterGlobal(hook?.trace)
-}), StatusMap = {
-  Continue: 100,
-  "Switching Protocols": 101,
-  Processing: 102,
-  "Early Hints": 103,
-  OK: 200,
-  Created: 201,
-  Accepted: 202,
-  "Non-Authoritative Information": 203,
-  "No Content": 204,
-  "Reset Content": 205,
-  "Partial Content": 206,
-  "Multi-Status": 207,
-  "Already Reported": 208,
-  "Multiple Choices": 300,
-  "Moved Permanently": 301,
-  Found: 302,
-  "See Other": 303,
-  "Not Modified": 304,
-  "Temporary Redirect": 307,
-  "Permanent Redirect": 308,
-  "Bad Request": 400,
-  Unauthorized: 401,
-  "Payment Required": 402,
-  Forbidden: 403,
-  "Not Found": 404,
-  "Method Not Allowed": 405,
-  "Not Acceptable": 406,
-  "Proxy Authentication Required": 407,
-  "Request Timeout": 408,
-  Conflict: 409,
-  Gone: 410,
-  "Length Required": 411,
-  "Precondition Failed": 412,
-  "Payload Too Large": 413,
-  "URI Too Long": 414,
-  "Unsupported Media Type": 415,
-  "Range Not Satisfiable": 416,
-  "Expectation Failed": 417,
-  "I'm a teapot": 418,
-  "Enhance Your Calm": 420,
-  "Misdirected Request": 421,
-  "Unprocessable Content": 422,
-  Locked: 423,
-  "Failed Dependency": 424,
-  "Too Early": 425,
-  "Upgrade Required": 426,
-  "Precondition Required": 428,
-  "Too Many Requests": 429,
-  "Request Header Fields Too Large": 431,
-  "Unavailable For Legal Reasons": 451,
-  "Internal Server Error": 500,
-  "Not Implemented": 501,
-  "Bad Gateway": 502,
-  "Service Unavailable": 503,
-  "Gateway Timeout": 504,
-  "HTTP Version Not Supported": 505,
-  "Variant Also Negotiates": 506,
-  "Insufficient Storage": 507,
-  "Loop Detected": 508,
-  "Not Extended": 510,
-  "Network Authentication Required": 511
-}, InvertedStatusMap = Object.fromEntries(
-  Object.entries(StatusMap).map(([k, v]) => [v, k])
-);
-function removeTrailingEquals(digest) {
-  let trimmedDigest = digest;
-  for (; trimmedDigest.endsWith("="); )
-    trimmedDigest = trimmedDigest.slice(0, -1);
-  return trimmedDigest;
-}
-const encoder = new TextEncoder(), 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");
-  const secretKey = await crypto.subtle.importKey(
-    "raw",
-    encoder.encode(secret),
-    { name: "HMAC", hash: "SHA-256" },
-    !1,
-    ["sign"]
-  ), hmacBuffer = await crypto.subtle.sign(
-    "HMAC",
-    secretKey,
-    encoder.encode(val)
-  );
-  return val + "." + removeTrailingEquals(Buffer.from(hmacBuffer).toString("base64"));
-}, constantTimeEqual = typeof crypto?.timingSafeEqual == "function" ? (a, b) => {
-  const ab = Buffer.from(a, "utf8"), bb = Buffer.from(b, "utf8");
-  return ab.length !== bb.length ? !1 : crypto.timingSafeEqual(ab, bb);
-} : (a, b) => a === b, unsignCookie = async (input, secret) => {
-  if (typeof input != "string")
-    throw new TypeError("Signed cookie string must be provided.");
-  const dot = input.lastIndexOf(".");
-  if (dot === -1)
-    return secret === null ? input : !1;
-  const tentativeValue = input.slice(0, dot), expectedInput = await signCookie(tentativeValue, secret);
-  return constantTimeEqual(expectedInput, input) ? tentativeValue : !1;
-}, insertStandaloneValidator = (hook, name, value) => {
-  if (!hook.standaloneValidator?.length || !Array.isArray(hook.standaloneValidator)) {
-    hook.standaloneValidator = [
-      {
-        [name]: value
-      }
-    ];
-    return;
-  }
-  const last = hook.standaloneValidator[hook.standaloneValidator.length - 1];
-  name in last ? hook.standaloneValidator.push({
-    [name]: value
-  }) : last[name] = value;
-}, parseNumericString = (message) => {
-  if (typeof message == "number") return message;
-  if (message.length < 16) {
-    if (message.trim().length === 0) return null;
-    const length = Number(message);
-    return Number.isNaN(length) ? null : length;
-  }
-  if (message.length === 16) {
-    if (message.trim().length === 0) return null;
-    const number = Number(message);
-    return Number.isNaN(number) || number.toString() !== message ? null : number;
-  }
-  return null;
-}, isNumericString = (message) => parseNumericString(message) !== null;
-class PromiseGroup {
-  constructor(onError = console.error, onFinally = () => {
-  }) {
-    this.onError = onError;
-    this.onFinally = onFinally;
-    this.root = null;
-    this.promises = [];
-  }
-  /**
-   * The number of promises still being awaited.
-   */
-  get size() {
-    return this.promises.length;
-  }
-  /**
-   * Add a promise to the group.
-   * @returns The promise that was added.
-   */
-  add(promise) {
-    return this.promises.push(promise), this.root ||= this.drain(), this.promises.length === 1 && this.then(this.onFinally), promise;
-  }
-  async drain() {
-    for (; this.promises.length > 0; ) {
-      try {
-        await this.promises[0];
-      } catch (error) {
-        this.onError(error);
-      }
-      this.promises.shift();
-    }
-    this.root = null;
-  }
-  // Allow the group to be awaited.
-  then(onfulfilled, onrejected) {
-    return (this.root ?? Promise.resolve()).then(onfulfilled, onrejected);
-  }
-}
-const fnToContainer = (fn, subType) => {
-  if (!fn) return fn;
-  if (!Array.isArray(fn)) {
-    if (typeof fn == "function" || typeof fn == "string")
-      return subType ? { fn, subType } : { fn };
-    if ("fn" in fn) return fn;
-  }
-  const fns = [];
-  for (const x of fn)
-    typeof x == "function" || typeof x == "string" ? fns.push(subType ? { fn: x, subType } : { fn: x }) : "fn" in x && fns.push(x);
-  return fns;
-}, localHookToLifeCycleStore = (a) => (a.start && (a.start = fnToContainer(a.start)), a.request && (a.request = fnToContainer(a.request)), a.parse && (a.parse = fnToContainer(a.parse)), a.transform && (a.transform = fnToContainer(a.transform)), a.beforeHandle && (a.beforeHandle = fnToContainer(a.beforeHandle)), a.afterHandle && (a.afterHandle = fnToContainer(a.afterHandle)), a.mapResponse && (a.mapResponse = fnToContainer(a.mapResponse)), a.afterResponse && (a.afterResponse = fnToContainer(a.afterResponse)), a.trace && (a.trace = fnToContainer(a.trace)), a.error && (a.error = fnToContainer(a.error)), a.stop && (a.stop = fnToContainer(a.stop)), a), lifeCycleToFn = (a) => {
-  const lifecycle = /* @__PURE__ */ Object.create(null);
-  return a.start?.map && (lifecycle.start = a.start.map((x) => x.fn)), a.request?.map && (lifecycle.request = a.request.map((x) => x.fn)), a.parse?.map && (lifecycle.parse = a.parse.map((x) => x.fn)), a.transform?.map && (lifecycle.transform = a.transform.map((x) => x.fn)), a.beforeHandle?.map && (lifecycle.beforeHandle = a.beforeHandle.map((x) => x.fn)), a.afterHandle?.map && (lifecycle.afterHandle = a.afterHandle.map((x) => x.fn)), a.mapResponse?.map && (lifecycle.mapResponse = a.mapResponse.map((x) => x.fn)), a.afterResponse?.map && (lifecycle.afterResponse = a.afterResponse.map((x) => x.fn)), a.error?.map && (lifecycle.error = a.error.map((x) => x.fn)), a.stop?.map && (lifecycle.stop = a.stop.map((x) => x.fn)), a.trace?.map ? lifecycle.trace = a.trace.map((x) => x.fn) : lifecycle.trace = [], lifecycle;
-}, cloneInference = (inference) => ({
-  body: inference.body,
-  cookie: inference.cookie,
-  headers: inference.headers,
-  query: inference.query,
-  set: inference.set,
-  server: inference.server,
-  path: inference.path,
-  route: inference.route,
-  url: inference.url
-}), redirect = (url, status = 302) => Response.redirect(url, status), ELYSIA_FORM_DATA = Symbol("ElysiaFormData"), ELYSIA_REQUEST_ID = Symbol("ElysiaRequestId"), form = (items) => {
-  const formData = new FormData();
-  if (formData[ELYSIA_FORM_DATA] = {}, items)
-    for (const [key, value] of Object.entries(items)) {
-      if (Array.isArray(value)) {
-        formData[ELYSIA_FORM_DATA][key] = [];
-        for (const v of value)
-          value instanceof File ? formData.append(key, value, value.name) : value instanceof import_file.ElysiaFile ? formData.append(key, value.value, value.value?.name) : formData.append(key, value), formData[ELYSIA_FORM_DATA][key].push(value);
-        continue;
-      }
-      value instanceof File ? formData.append(key, value, value.name) : value instanceof import_file.ElysiaFile ? formData.append(key, value.value, value.value?.name) : formData.append(key, value), formData[ELYSIA_FORM_DATA][key] = value;
-    }
-  return formData;
-}, randomId = typeof crypto > "u" || (0, import_utils.isCloudflareWorker)() ? () => {
-  let result = "";
-  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  for (let i = 0; i < 16; i++)
-    result += characters.charAt(
-      // 62 is characters.length
-      Math.floor(Math.random() * 62)
-    );
-  return result;
-} : () => {
-  const uuid = crypto.randomUUID();
-  return uuid.slice(0, 8) + uuid.slice(24, 32);
-}, deduplicateChecksum = (array) => {
-  if (!array.length) return [];
-  const hashes = [];
-  for (let i = 0; i < array.length; i++) {
-    const item = array[i];
-    item.checksum && (hashes.includes(item.checksum) && (array.splice(i, 1), i--), hashes.push(item.checksum));
-  }
-  return array;
-}, promoteEvent = (events, as = "scoped") => {
-  if (events) {
-    if (as === "scoped") {
-      for (const event of events)
-        "scope" in event && event.scope === "local" && (event.scope = "scoped");
-      return;
-    }
-    for (const event of events) "scope" in event && (event.scope = "global");
-  }
-}, getLoosePath = (path) => path.charCodeAt(path.length - 1) === 47 ? path.slice(0, path.length - 1) : path + "/", isNotEmpty = (obj) => {
-  if (!obj) return !1;
-  for (const _ in obj) return !0;
-  return !1;
-}, encodePath = (path, { dynamic = !1 } = {}) => {
-  let encoded = encodeURIComponent(path).replace(/%2F/g, "/");
-  return dynamic && (encoded = encoded.replace(/%3A/g, ":").replace(/%3F/g, "?")), encoded;
-}, supportPerMethodInlineHandler = !!(typeof Bun > "u" || Bun.semver?.satisfies?.(Bun.version, ">=1.2.14")), sse = (_payload) => {
-  if (_payload instanceof ReadableStream)
-    return _payload.sse = !0, _payload;
-  const payload = typeof _payload == "string" ? { data: _payload } : _payload;
-  return payload.sse = !0, payload.toSSE = () => {
-    let payloadString = "";
-    return payload.id !== void 0 && payload.id !== null && (payloadString += `id: ${payload.id}
-`), payload.event && (payloadString += `event: ${payload.event}
-`), payload.retry !== void 0 && (payloadString += `retry: ${payload.retry}
-`), payload.data === null ? payloadString += `data: null
-` : typeof payload.data == "string" ? payloadString += `data: ${payload.data}
-` : typeof payload.data == "object" && (payloadString += `data: ${JSON.stringify(payload.data)}
-`), payloadString && (payloadString += `
-`), payloadString;
-  }, payload;
+const compactBeforeHandleMemos = /* @__PURE__ */ new WeakMap();
+const compactBeforeHandleFunctions = /* @__PURE__ */ new WeakSet();
+const compactBeforeHandleValues = (hook) => {
+	if (!hook) return [];
+	for (const key in hook) if (key !== "beforeHandle") return false;
+	const value = hook.beforeHandle;
+	if (value === void 0) return [];
+	if (typeof value === "function") return [value];
+	if (!Array.isArray(value)) return false;
+	for (let i = 0; i < value.length; i++) if (typeof value[i] !== "function") return false;
+	return value.slice();
 };
-async function getResponseLength(response) {
-  if (response.bodyUsed || !response.body) return 0;
-  let length = 0;
-  const reader = response.body.getReader();
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    length += value.byteLength;
-  }
-  return length;
-}
-const emptySchema = {
-  headers: !0,
-  cookie: !0,
-  query: !0,
-  params: !0,
-  body: !0,
-  response: !0
+const isCompactBeforeHandleOnly = (hook) => compactBeforeHandleValues(hook) !== false;
+function compactBeforeHandleConflicts(hook) {
+	const values = compactBeforeHandleValues(hook);
+	if (values === false) return true;
+	for (let i = 0; i < values.length; i++) if (compactBeforeHandleFunctions.has(values[i])) return true;
+	return false;
+}
+function appendCompactBeforeHandle(previous, added) {
+	if (!added.length) return previous;
+	let tail = previous.tail;
+	let length = previous.length;
+	for (let i = 0; i < added.length; i++) {
+		const fn = added[i];
+		compactBeforeHandleFunctions.add(fn);
+		if (tail && tail.values.length < COMPACT_CHUNK_SIZE) tail = {
+			parent: tail.parent,
+			values: [...tail.values, fn]
+		};
+		else tail = {
+			parent: tail,
+			values: [fn]
+		};
+		length++;
+	}
+	return {
+		tail,
+		length,
+		previous: previous.length ? previous : void 0,
+		added
+	};
+}
+function compactBeforeHandlePrefix(start) {
+	if (!start) return;
+	const pending = [];
+	let node = start;
+	let prefix = emptyCompactBeforeHandlePrefix;
+	while (node) {
+		const cached = compactBeforeHandleMemos.get(node);
+		if (cached !== void 0) {
+			if (cached === false) {
+				for (let i = 0; i < pending.length; i++) compactBeforeHandleMemos.set(pending[i].node, false);
+				return;
+			}
+			prefix = cached;
+			break;
+		}
+		if ("combine" in node) {
+			compactBeforeHandleMemos.set(node, false);
+			for (let i = 0; i < pending.length; i++) compactBeforeHandleMemos.set(pending[i].node, false);
+			return;
+		}
+		const values = compactBeforeHandleValues(node.added);
+		if (values === false) {
+			compactBeforeHandleMemos.set(node, false);
+			for (let i = 0; i < pending.length; i++) compactBeforeHandleMemos.set(pending[i].node, false);
+			return;
+		}
+		pending.push({
+			node,
+			values
+		});
+		node = node.parent;
+	}
+	for (let i = pending.length - 1; i >= 0; i--) {
+		const item = pending[i];
+		prefix = appendCompactBeforeHandle(prefix, item.values);
+		compactBeforeHandleMemos.set(item.node, prefix);
+	}
+	return prefix.length ? prefix : void 0;
+}
+const flattenNodeStack = [];
+const flattenPhaseStack = [];
+/**
+* Walk the chain tail-first into a fresh `Partial<AppHook>`
+*
+* Explicit-stack walk (no recursion) so it works uniformly for linear
+* chains and combine nodes without risking stack overflow on deep chains
+*/
+function flattenChain(start, keep, stopAt, resolveAdded) {
+	if (!start || start === stopAt) return;
+	const result = nullObject();
+	const nodes = flattenNodeStack;
+	const phases = flattenPhaseStack;
+	nodes.length = 0;
+	phases.length = 0;
+	nodes.push(start);
+	phases.push(0);
+	while (nodes.length) {
+		const node = nodes.pop();
+		if (phases.pop() === 1) {
+			const added = resolveAdded ? resolveAdded(node) : node.added;
+			if (added) appendInto(result, added, keep, node.scope);
+			continue;
+		}
+		if (stopAt && node === stopAt) continue;
+		if ("combine" in node) {
+			nodes.push(node.combine);
+			phases.push(0);
+			if (node.over) {
+				nodes.push(node.over);
+				phases.push(0);
+			}
+		} else {
+			nodes.push(node);
+			phases.push(1);
+			if (node.parent && node.parent !== stopAt) {
+				nodes.push(node.parent);
+				phases.push(0);
+			}
+		}
+	}
+	if (isNotEmpty(result)) return result;
+}
+/**
+* whenever any macro table mutates (`.macro()` / `#use` merge)
+* every macro-resolution memo flattens, localHook/chainNode memos
+* validates against the current epoch
+*
+* @see `compile/handler`
+*/
+let macroTableEpoch = 0;
+const macroEpoch = () => macroTableEpoch;
+const invalidateMacroEpoch = () => {
+	macroTableEpoch++;
 };
-function deepClone(source, weak = /* @__PURE__ */ new WeakMap()) {
-  if (source === null || typeof source != "object" || typeof source == "function")
-    return source;
-  if (weak.has(source)) return weak.get(source);
-  if (Array.isArray(source)) {
-    const copy = new Array(source.length);
-    weak.set(source, copy);
-    for (let i = 0; i < source.length; i++)
-      copy[i] = deepClone(source[i], weak);
-    return copy;
-  }
-  if (typeof source == "object") {
-    const keys = Object.keys(source).concat(
-      Object.getOwnPropertySymbols(source)
-    ), cloned = {};
-    weak.set(source, cloned);
-    for (const key of keys)
-      cloned[key] = deepClone(source[key], weak);
-    return cloned;
-  }
-  return source;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ELYSIA_FORM_DATA,
-  ELYSIA_REQUEST_ID,
-  InvertedStatusMap,
-  PromiseGroup,
-  StatusMap,
-  asHookType,
-  checksum,
-  cloneInference,
-  deduplicateChecksum,
-  deepClone,
-  emptySchema,
-  encodePath,
-  filterGlobalHook,
-  fnToContainer,
-  form,
-  getLoosePath,
-  getResponseLength,
-  hasHeaderShorthand,
-  hasSetImmediate,
-  injectChecksum,
-  insertStandaloneValidator,
-  isClass,
-  isNotEmpty,
-  isNumericString,
-  lifeCycleToArray,
-  lifeCycleToFn,
-  localHookToLifeCycleStore,
-  mergeCookie,
-  mergeDeep,
-  mergeHook,
-  mergeLifeCycle,
-  mergeObjectArray,
-  mergeResponse,
-  mergeSchemaValidator,
-  primitiveHooks,
-  promoteEvent,
-  randomId,
-  redirect,
-  replaceUrlPath,
-  signCookie,
-  sse,
-  supportPerMethodInlineHandler,
-  unsignCookie
+const flattenChainMemos = /* @__PURE__ */ new WeakMap();
+/** Drop this root's flattened-chain memo. Recomputable on next compile. */
+function clearFlattenChainMemo(root) {
+	flattenChainMemos.delete(root);
+}
+const emptyFlatten = Object.freeze(nullObject());
+function flattenChainCached(root, start, resolveAdded) {
+	let bucket = flattenChainMemos.get(root);
+	if (!bucket || bucket.e !== macroTableEpoch) {
+		bucket = {
+			e: macroTableEpoch,
+			per: /* @__PURE__ */ new WeakMap()
+		};
+		flattenChainMemos.set(root, bucket);
+	}
+	const perRoot = bucket.per;
+	let cached = perRoot.get(start);
+	if (cached === void 0) {
+		cached = flattenChain(start, void 0, void 0, resolveAdded) ?? emptyFlatten;
+		perRoot.set(start, cached);
+	}
+	if (cached === emptyFlatten) return;
+	return cached;
+}
+function flattenChainMemo(root, start, resolveAdded) {
+	if (!start) return;
+	const cached = flattenChainCached(root, start, resolveAdded);
+	if (cached === void 0) return;
+	return cloneHook(cached);
+}
+function flattenChainMemoReadonly(root, start, resolveAdded) {
+	if (!start) return;
+	return flattenChainCached(root, start, resolveAdded);
+}
+function appendInto(target, src, keep, nodeScope) {
+	if (keep && !keep(nodeScope)) return;
+	for (const key in src) {
+		const v = src[key];
+		if (v === void 0 || v === null) continue;
+		if (eventProperties.has(key) || key === "schemas" || key === "~deriveEntries") {
+			const existing = target[key];
+			if (Array.isArray(v)) if (existing) {
+				const arr = existing;
+				for (let i = 0; i < v.length; i++) arr.push(v[i]);
+			} else target[key] = v.slice();
+			else if (existing) existing.push(v);
+			else target[key] = [v];
+		} else target[key] = v;
+	}
+}
+const notLatin = /[^\x00-\xFF]/;
+/**
+*
+* @param url URL to redirect to
+* @param HTTP status code to send,
+*/
+const redirect = (url, status = 302) => new Response(null, {
+	status,
+	headers: { location: notLatin.test(url) ? encodeURI(url) : url }
+});
+function appendFormField(formData, key, value) {
+	if (value === void 0 || value === null) return;
+	if (value instanceof Blob) formData.append(key, value);
+	else if (value instanceof require_universal_file.ElysiaFile) formData.append(key, value.value);
+	else if (typeof value === "object") formData.append(key, JSON.stringify(value));
+	else formData.append(key, "" + value);
+}
+/**
+* Build `FormData` from a `form()` object, skipping the internal `~ely-form`
+* marker that flags the object as a form.
+*/
+function formToFormData(value) {
+	const formData = new FormData();
+	for (const key in value) {
+		if (key === "~ely-form") continue;
+		const field = value[key];
+		if (Array.isArray(field)) for (const item of field) appendFormField(formData, key, item);
+		else appendFormField(formData, key, field);
+	}
+	return formData;
+}
+/**
+* Return a `multipart/form-data` response.
+*
+* @example
+* ```ts
+* import { Elysia, form, file } from 'elysia'
+*
+* new Elysia().get('/', () =>
+* 	form({
+* 		name: 'Tea Party',
+* 		images: [file('1.webp'), file('2.webp')]
+* 	})
+* )
+* ```
+*/
+const form = (value) => ({
+	...value,
+	"~ely-form": 1
 });
+const getLoosePath = (path) => path.charCodeAt(path.length - 1) === 47 ? path.slice(0, -1) : path + "/";
+const byteStreams = /* @__PURE__ */ new WeakSet();
+/**
+* Certify a byte stream for direct Response body pass-through.
+*
+* The returned Response owns this exact stream. Cancel it through the response
+* body reader; preserving identity means Elysia does not install a second
+* request-signal reader after the body is locked.
+*/
+function bytes(stream) {
+	byteStreams.add(stream);
+	return stream;
+}
+const isByteStream = (value) => typeof value === "object" && value !== null && byteStreams.has(value);
+const sseLineBreak = /\r\n|\r|\n/g;
+const sseField = (name, value) => `${name}: ${(value + "").replace(sseLineBreak, "")}\n`;
+const sseData = (value) => {
+	if (value.indexOf("\n") === -1 && value.indexOf("\r") === -1) return "data: " + value + "\n";
+	return value.split(sseLineBreak).map((line) => `data: ${line}\n`).join("");
+};
+const sse = (_payload) => {
+	if (_payload instanceof ReadableStream) {
+		_payload.sse = true;
+		return _payload;
+	}
+	const payload = typeof _payload === "string" ? { data: _payload } : _payload;
+	payload.sse = true;
+	payload.toSSE = () => {
+		let s = "";
+		if (payload.id !== void 0 && payload.id !== null) s += sseField("id", payload.id);
+		if (payload.event) s += sseField("event", payload.event);
+		if (typeof payload.retry === "number" && Number.isFinite(payload.retry) && payload.retry >= 0) s += `retry: ${Math.trunc(payload.retry)}\n`;
+		if (payload.data === null) s += "data: null\n";
+		else if (typeof payload.data === "string") s += sseData(payload.data);
+		else if (typeof payload.data === "object") s += `data: ${JSON.stringify(payload.data)}\n`;
+		if (s) s += "\n";
+		return s;
+	};
+	return payload;
+};
+const _enc = new TextEncoder();
+let _constantTimeEqual;
+const _resolveConstantTimeEqual = () => {
+	let native;
+	try {
+		const _crypto = globalThis.process?.getBuiltinModule?.("node:crypto");
+		if (typeof _crypto?.timingSafeEqual === "function") native = _crypto.timingSafeEqual;
+	} catch {}
+	if (!native && typeof crypto?.timingSafeEqual === "function") native = (a, b) => crypto.timingSafeEqual(a, b);
+	if (!native) return (a, b) => {
+		if (a.length !== b.length) return false;
+		let mismatch = 0;
+		for (let i = 0; i < a.length; i++) mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
+		return mismatch === 0;
+	};
+	const compare = native;
+	return (a, b) => {
+		const ab = _enc.encode(a);
+		const bb = _enc.encode(b);
+		return ab.length !== bb.length ? false : compare(ab, bb);
+	};
+};
+const constantTimeEqual = (a, b) => (_constantTimeEqual ??= _resolveConstantTimeEqual())(a, b);
+const isRecordNumber = (x) => {
+	if (typeof x !== "object") return false;
+	const keys = Object.keys(x);
+	return keys.length > 0 && keys.every((k) => !isNaN(+k));
+};
+function mergeResponse(a, b) {
+	const aRecord = isRecordNumber(a);
+	const bRecord = isRecordNumber(b);
+	if (aRecord && bRecord) return Object.assign({}, a, b);
+	if (aRecord && b) return Object.assign({}, a, { 200: b });
+	if (a && bRecord) return Object.assign({ 200: a }, b);
+	return b ?? a;
+}
+/**
+* a is mutable, b is immutable
+*
+* If both are arrays, mutates a by pushing/appending b
+*/
+function mergeArray(a, b, reverse = false) {
+	if (!a) return b;
+	if (!b) return a;
+	const aIsArray = Array.isArray(a);
+	const bIsArray = Array.isArray(b);
+	if (reverse) {
+		if (aIsArray && bIsArray) {
+			if (b.length === 1) {
+				a.unshift(b[0]);
+				return a;
+			}
+			return b.concat(a);
+		}
+		if (aIsArray) {
+			a.unshift(b);
+			return a;
+		}
+		if (bIsArray) {
+			const out = new Array(b.length + 1);
+			for (let i = 0; i < b.length; i++) out[i] = b[i];
+			out[b.length] = a;
+			return out;
+		}
+		return [b, a];
+	}
+	if (aIsArray && bIsArray) {
+		for (let i = 0; i < b.length; i++) a.push(b[i]);
+		return a;
+	}
+	if (aIsArray) {
+		a.push(b);
+		return a;
+	}
+	if (bIsArray) {
+		const out = new Array(b.length + 1);
+		out[0] = a;
+		for (let i = 0; i < b.length; i++) out[i + 1] = b[i];
+		return out;
+	}
+	return [a, b];
+}
+/**
+* Like {@link mergeArray} but drops entries from `a` that already appear in
+* `b` by reference. Always allocates fresh arrays - never mutates inputs.
+*
+* Used at the compile-time merge of a route's snapshotted `appHook` with the
+* root's current `rootHook`: the same fn can sit on both sides because
+* `.use()` propagates global/plugin-scoped hooks into the parent, while the
+* route's `appHook` was captured on the child and still holds the original.
+* The fn must run once, in `b`'s position.
+*/
+function dedupedMergeArray(a, b, reverse = false) {
+	if (!a) return Array.isArray(b) ? b.slice() : b;
+	if (!b) return Array.isArray(a) ? a.slice() : a;
+	const aArr = Array.isArray(a) ? a : [a];
+	const bArr = Array.isArray(b) ? b : [b];
+	const seen = new Set(bArr);
+	const filtered = [];
+	for (let i = 0; i < aArr.length; i++) if (!seen.has(aArr[i])) filtered.push(aArr[i]);
+	return reverse ? bArr.concat(filtered) : filtered.concat(bArr);
+}
+const schemaProperties = new Set([
+	"body",
+	"headers",
+	"params",
+	"query",
+	"cookie",
+	"response"
+]);
+const eventProperties = new Set([
+	"start",
+	"stop",
+	"trace",
+	"request",
+	"parse",
+	"transform",
+	"beforeHandle",
+	"afterHandle",
+	"mapResponse",
+	"afterResponse",
+	"error"
+]);
+function hookToGuard(a) {
+	if (a.schema !== "merge") return a;
+	if (a.body || a.headers || a.params || a.query || a.cookie || a.response) {
+		a.schemas ??= [];
+		const schema = Object.create(null);
+		if (a.body) {
+			schema.body = a.body;
+			a.body = void 0;
+		}
+		if (a.headers) {
+			schema.headers = a.headers;
+			a.headers = void 0;
+		}
+		if (a.params) {
+			schema.params = a.params;
+			a.params = void 0;
+		}
+		if (a.query) {
+			schema.query = a.query;
+			a.query = void 0;
+		}
+		if (a.cookie) {
+			schema.cookie = a.cookie;
+			a.cookie = void 0;
+		}
+		if (a.response) {
+			schema.response = a.response;
+			a.response = void 0;
+		}
+		a.schemas.push(schema);
+	}
+	return a;
+}
+function coalesceSchemas(existing, incoming) {
+	for (const entry of incoming) {
+		if (!entry || typeof entry !== "object") continue;
+		let merged = false;
+		for (let i = 0; i < existing.length; i++) {
+			const e = existing[i];
+			let canMerge = true;
+			for (const k in entry) if (k in e && e[k] !== entry[k]) {
+				canMerge = false;
+				break;
+			}
+			if (canMerge) {
+				existing[i] = Object.assign(nullObject(), e, entry);
+				merged = true;
+				break;
+			}
+		}
+		if (!merged) existing.push(entry);
+	}
+}
+function mergeHook(a, b, reverse = false, dedup = false) {
+	if (!b) return a;
+	if (!a) return b;
+	const merge = dedup ? dedupedMergeArray : mergeArray;
+	if (!a.body && b.body) a.body = b.body;
+	if (!a.headers && b.headers) a.headers = b.headers;
+	if (!a.params && b.params) a.params = b.params;
+	if (!a.query && b.query) a.query = b.query;
+	if (!a.cookie && b.cookie) a.cookie = b.cookie;
+	if (!a.response && b.response) a.response = b.response;
+	else if (a.response && b.response) a.response = mergeResponse(b.response, a.response);
+	if (a.parse || b.parse) a.parse = merge(a.parse, b.parse, reverse);
+	if (a.transform || b.transform) a.transform = merge(a.transform, b.transform, reverse);
+	if (a.derive || b.derive) a.derive = merge(a.derive, b.derive, reverse);
+	if (a.beforeHandle || b.beforeHandle) a.beforeHandle = merge(a.beforeHandle, b.beforeHandle, reverse);
+	if (a.afterHandle || b.afterHandle) a.afterHandle = merge(a.afterHandle, b.afterHandle, reverse);
+	if (a.mapResponse || b.mapResponse) a.mapResponse = merge(a.mapResponse, b.mapResponse, reverse);
+	if (a.afterResponse || b.afterResponse) a.afterResponse = merge(a.afterResponse, b.afterResponse, reverse);
+	if (a.error || b.error) a.error = merge(a.error, b.error, reverse);
+	if (a.trace || b.trace) a.trace = merge(a.trace, b.trace, reverse);
+	if (a.schemas || b.schemas) a.schemas = mergeArray(a.schemas, b.schemas, reverse);
+	const aDerive = a["~deriveEntries"];
+	const bDerive = b["~deriveEntries"];
+	if (aDerive || bDerive) a["~deriveEntries"] = mergeArray(aDerive, bDerive, reverse);
+	return a;
+}
+const createErrorEventHandler = (fn, error) => (context) => {
+	if (context.error instanceof error) return fn(context);
+};
+const isObject = (item) => item && typeof item === "object" && !Array.isArray(item);
+const isClassRegex = /^\s*class\s+/;
+const isClass = (v) => typeof v === "function" && isClassRegex.test(v.toString()) || v.toString && v.toString().startsWith("[object ") && v.toString() !== "[object Object]" || isNotEmpty(Object.getPrototypeOf(v));
+function mergeDeep(target, source, skipKeys, override = true, mergeArray = false, seen, cloneAdopt) {
+	if (!isObject(target) || !isObject(source)) return target;
+	if (seen?.has(source)) return target;
+	const keys = Object.keys(source);
+	const targetFrozen = Object.isFrozen(target);
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		const value = source[key];
+		if (skipKeys?.includes(key) || require_constants.dangerousKeys.has(key)) continue;
+		if (mergeArray && Array.isArray(value)) {
+			const existing = target[key];
+			target[key] = Array.isArray(existing) ? existing.concat(value) : value;
+			continue;
+		}
+		const valueIsObject = isObject(value);
+		if (!valueIsObject || !(key in target) || isClass(value)) {
+			if ((override || !(key in target)) && !targetFrozen) try {
+				target[key] = valueIsObject && cloneAdopt !== void 0 && isPlainObject(value) ? clonePlainDecorators(value, cloneAdopt.map ??= /* @__PURE__ */ new WeakMap()) : value;
+			} catch {}
+			continue;
+		}
+		if (!Object.isFrozen(target[key])) {
+			seen ??= /* @__PURE__ */ new WeakSet();
+			seen.add(source);
+			try {
+				target[key] = mergeDeep(target[key], value, skipKeys, override, mergeArray, seen, cloneAdopt);
+			} catch {}
+		}
+	}
+	seen?.delete(source);
+	return target;
+}
+const isBlob = (value) => value instanceof Blob || value instanceof require_universal_file.ElysiaFile;
+function cloneHook(src) {
+	const out = nullObject();
+	for (const key in src) {
+		const value = src[key];
+		out[key] = Array.isArray(value) ? value.slice() : value;
+	}
+	return out;
+}
+function clonePlainDeep(value, seen) {
+	if (Array.isArray(value)) {
+		seen ??= /* @__PURE__ */ new WeakMap();
+		const hit = seen.get(value);
+		if (hit) return hit;
+		const out = [];
+		seen.set(value, out);
+		for (let i = 0; i < value.length; i++) out[i] = clonePlainDeep(value[i], seen);
+		return out;
+	}
+	if (isPlainObject(value)) {
+		seen ??= /* @__PURE__ */ new WeakMap();
+		const hit = seen.get(value);
+		if (hit) return hit;
+		const out = nullObject();
+		seen.set(value, out);
+		for (const key in value) out[key] = clonePlainDeep(value[key], seen);
+		return out;
+	}
+	return value;
+}
+function guardNonPlainLeaves(target, source) {
+	for (const key in source) {
+		if (!Object.hasOwn(source, key)) continue;
+		const sv = source[key];
+		if (!isObject(sv) || isClass(sv)) continue;
+		const tv = target[key];
+		if (tv === void 0 || !isObject(tv)) continue;
+		if (isPlainObject(tv)) {
+			guardNonPlainLeaves(tv, sv);
+			continue;
+		}
+		target[key] = clonePlainDeep(sv);
+	}
+}
+function joinPath(base, path) {
+	if (!path) return base;
+	const baseEndsWithSlash = base.charCodeAt(base.length - 1) === 47;
+	const pathStartsWithSlash = path.charCodeAt(0) === 47;
+	if (baseEndsWithSlash && pathStartsWithSlash) return base + path.slice(1);
+	if (!baseEndsWithSlash && !pathStartsWithSlash) return base + "/" + path;
+	return base + path;
+}
+function pushField(target, key, item, defaultArray = false) {
+	const v = target[key];
+	if (v) if (Array.isArray(v)) target[key].push(item);
+	else target[key] = [v, item];
+	else target[key] = defaultArray ? [item] : item;
+}
+const requestId = require_universal_constants.isBun ? Bun.randomUUIDv7 : crypto.randomUUIDv7?.bind(crypto) ?? crypto.randomUUID?.bind(crypto);
+function replaceUrlPath(url, path) {
+	const i = url.indexOf("/", 11);
+	const qs = url.indexOf("?", i);
+	return `${url.slice(0, i)}${path.charCodeAt(0) === 47 ? "" : "/"}${path}${qs === -1 ? "" : url.slice(qs)}`;
+}
+function isPlainObject(v) {
+	if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+	const proto = Object.getPrototypeOf(v);
+	return proto === Object.prototype || proto === null;
+}
+function clonePlainDecorators(source, seen) {
+	if (seen !== void 0) {
+		const existing = seen.get(source);
+		if (existing) return existing;
+	}
+	const out = nullObject();
+	if (seen !== void 0) seen.set(source, out);
+	for (const key in source) {
+		const value = source[key];
+		if (isPlainObject(value)) {
+			if (seen === void 0) (seen = /* @__PURE__ */ new WeakMap()).set(source, out);
+			out[key] = clonePlainDecorators(value, seen);
+		} else out[key] = value;
+	}
+	return out;
+}
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+function prefix(prefix, models) {
+	const prefixed = nullObject();
+	for (const key in models) prefixed[`${prefix}.${key}`] = models[key];
+	return prefixed;
+}
+prefix.capitalize = function prefixModelsCapitalize(prefix, models) {
+	const prefixed = nullObject();
+	for (const key in models) prefixed[`${prefix}.${capitalize(key)}`] = models[key];
+	return prefixed;
+};
+const macroSeedRefIds = /* @__PURE__ */ new WeakMap();
+let macroSeedRefCounter = 0;
+function macroSeedRefId(ref) {
+	let id = macroSeedRefIds.get(ref);
+	if (id === void 0) macroSeedRefIds.set(ref, id = ++macroSeedRefCounter);
+	return id;
+}
+function serializeMacroSeed(_key, value) {
+	switch (typeof value) {
+		case "function": return "\0fn:" + macroSeedRefId(value);
+		case "bigint": return "\0bigint:" + value.toString();
+		case "symbol": return "\0sym:" + String(value);
+		case "undefined": return "\0undefined";
+		default: return value;
+	}
+}
+
+//#endregion
+exports.bytes = bytes;
+exports.clearFlattenChainMemo = clearFlattenChainMemo;
+exports.cloneHook = cloneHook;
+exports.clonePlainDecorators = clonePlainDecorators;
+exports.clonePlainDeep = clonePlainDeep;
+exports.coalesceSchemas = coalesceSchemas;
+exports.compactBeforeHandleConflicts = compactBeforeHandleConflicts;
+exports.compactBeforeHandlePrefix = compactBeforeHandlePrefix;
+exports.constantTimeEqual = constantTimeEqual;
+exports.createErrorEventHandler = createErrorEventHandler;
+exports.deriveEntryFn = deriveEntryFn;
+exports.eventProperties = eventProperties;
+exports.evictOldestHalf = evictOldestHalf;
+exports.flattenChain = flattenChain;
+exports.flattenChainMemo = flattenChainMemo;
+exports.flattenChainMemoReadonly = flattenChainMemoReadonly;
+exports.fnOrigin = fnOrigin;
+exports.fnv1a = fnv1a;
+exports.form = form;
+exports.formToFormData = formToFormData;
+exports.getLoosePath = getLoosePath;
+exports.guardNonPlainLeaves = guardNonPlainLeaves;
+exports.hookToGuard = hookToGuard;
+exports.invalidateMacroEpoch = invalidateMacroEpoch;
+exports.isBlob = isBlob;
+exports.isByteStream = isByteStream;
+exports.isCompactBeforeHandleOnly = isCompactBeforeHandleOnly;
+exports.isEmpty = isEmpty;
+exports.isLocalScope = isLocalScope;
+exports.isMapDeriveEntry = isMapDeriveEntry;
+exports.isNotEmpty = isNotEmpty;
+exports.isRecordNumber = isRecordNumber;
+exports.joinPath = joinPath;
+exports.macroEpoch = macroEpoch;
+exports.macroOrigin = macroOrigin;
+exports.mapDeriveEntry = mapDeriveEntry;
+exports.mergeArray = mergeArray;
+exports.mergeDeep = mergeDeep;
+exports.mergeHook = mergeHook;
+exports.mergeResponse = mergeResponse;
+exports.nullObject = nullObject;
+exports.prefix = prefix;
+exports.pushField = pushField;
+exports.redirect = redirect;
+exports.replaceUrlPath = replaceUrlPath;
+exports.requestId = requestId;
+exports.schemaProperties = schemaProperties;
+exports.serializeMacroSeed = serializeMacroSeed;
+exports.sse = sse;