@dunx/http 2.4.0 → 3.0.0

package/dist/index.js

@@ -1,249 +1,92 @@
 // @bun
 import {
+  TRACEPARENT_HEADER,
+  TRACESTATE_HEADER,
+  TraceContext
+} from "./chunk-25g22350.js";
+import {
+  ApiHidden,
+  CompressionEncoding,
+  CompressionOptions,
+  Controller,
+  DEFAULT_RELAY_CHANNEL,
+  Delete,
+  ErrorFilter,
+  Get,
+  HEALTH_REPORT_SCHEMA,
+  HIDDEN,
+  HandlerKind,
+  HealthController,
+  HealthOptions,
+  HealthRegistry,
+  HiddenHealthController,
+  HttpError,
   HttpStatusCode,
+  PUBLIC,
+  Patch,
+  Post,
+  Public,
+  Put,
+  REQUEST_ID_HEADER,
+  ROLES,
+  RawBody,
+  RedisRelay,
+  RequestIds,
+  Roles,
+  StaticOptions,
+  UNMATCHED,
+  UseGuards,
+  ValidationError,
   __decorateElement,
   __decoratorMetadata,
   __decoratorStart,
-  __privateAdd,
-  __privateGet,
-  __runInitializers
-} from "./chunk-sz4pvqxy.js";
-
-// src/route/marker.ts
-var ROUTE = Symbol.for("dunx.route");
-var CONTROLLER = Symbol.for("dunx.controller");
-var resolvePath = (path) => typeof path === "function" ? path() : path;
-var markRoute = (target, meta) => {
-  Object.defineProperty(target, ROUTE, { value: meta, configurable: true });
-};
-var routeMetaOf = (value) => typeof value === "function" ? value[ROUTE] : undefined;
-var markController = (target, prefix) => {
-  Object.defineProperty(target, CONTROLLER, {
-    value: prefix,
-    configurable: true
-  });
-};
-var prefixOf = (target) => target[CONTROLLER] ?? "";
-
-// src/route/decorators.ts
-var Controller = (prefix = "") => (target) => {
-  markController(target, prefix);
-  return target;
-};
-var verb = (method) => (path = "/", options) => (value, _context) => {
-  markRoute(value, { method, path, options });
-  return value;
-};
-var Get = verb("GET");
-var Post = verb("POST");
-var Put = verb("PUT");
-var Patch = verb("PATCH");
-var Delete = verb("DELETE");
-// src/route/discover.ts
-import { markedMethods } from "@dunx/core";
-
-// src/route/metadata.ts
-var META = Symbol.for("dunx.meta");
-var GUARDS = Symbol.for("dunx.guards");
-var metaKey = (name) => ({
-  name,
-  id: Symbol(name)
-});
-var write = (target, key, value) => {
-  const record = new Map(target[META]);
-  record.set(key.id, value);
-  Object.defineProperty(target, META, { value: record, configurable: true });
-};
-var meta = (key, value) => (target) => {
-  write(target, key, value);
-  return target;
-};
-var ROLES = metaKey("roles");
-var PUBLIC = metaKey("public");
-var HIDDEN = metaKey("hidden");
-var UNMATCHED = metaKey("unmatched");
-var Roles = (...roles) => meta(ROLES, roles);
-var Public = () => meta(PUBLIC, true);
-var ApiHidden = () => meta(HIDDEN, true);
-var UseGuards = (...guards) => (target) => {
-  const existing = target[GUARDS] ?? [];
-  const merged = Object.hasOwn(target, GUARDS) ? [...guards, ...existing] : [...existing, ...guards];
-  Object.defineProperty(target, GUARDS, {
-    value: merged,
-    configurable: true
-  });
-  return target;
-};
-var guardsOf = (target) => target[GUARDS] ?? [];
-var metaOf = (target) => target[META];
-var mergeMeta = (...targets) => {
-  const merged = new Map;
-  for (const target of targets) {
-    const record = target[META];
-    if (record)
-      for (const [id, value] of record)
-        merged.set(id, value);
-  }
-  return merged;
-};
-
-// src/route/discover.ts
-var joinPath = (prefix, path) => {
-  const joined = `/${prefix}/${path}`.replace(/\/{2,}/g, "/");
-  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
-};
-var discoverRoutes = (instance) => {
-  const klass = instance.constructor;
-  const prefix = prefixOf(klass);
-  const classGuards = guardsOf(klass);
-  const members = instance;
-  return markedMethods(Object.getPrototypeOf(instance), routeMetaOf).map(({ name, meta: meta2, value: marked }) => ({
-    method: meta2.method,
-    path: joinPath(prefix, resolvePath(meta2.path)),
-    controller: klass.name,
-    handlerName: name,
-    handler: members[name].bind(instance),
-    options: meta2.options,
-    meta: mergeMeta(klass, marked),
-    classMeta: metaOf(klass),
-    guards: [...classGuards, ...guardsOf(marked)]
-  }));
-};
-// src/inspect.ts
-import {
-  collectModules,
-  dependenciesOf,
-  readControllers
-} from "@dunx/core";
-
-// src/ws/discover.ts
-import {
-  AppError,
-  classOf,
-  markedMethods as markedMethods2
-} from "@dunx/core";
-
-// src/ws/marker.ts
-var HANDLER = Symbol.for("dunx.ws.handler");
-var GATEWAY = Symbol.for("dunx.ws.gateway");
-var HandlerKind = Object.freeze({
-  UPGRADE: "upgrade",
-  OPEN: "open",
-  MESSAGE: "message",
-  CLOSE: "close",
-  DRAIN: "drain",
-  PING: "ping",
-  PONG: "pong"
-});
-var markHandler = (target, meta2) => {
-  Object.defineProperty(target, HANDLER, { value: meta2, configurable: true });
-};
-var handlerMetaOf = (value) => typeof value === "function" ? value[HANDLER] : undefined;
-var markGateway = (target, path) => {
-  Object.defineProperty(target, GATEWAY, { value: path, configurable: true });
-};
-var gatewayPathOf = (target) => target[GATEWAY] ?? "/";
-var isGateway = (target) => target[GATEWAY] !== undefined;
-
-// src/ws/discover.ts
-var normalizePath = (path) => {
-  const joined = `/${path}`.replace(/\/{2,}/g, "/");
-  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
-};
-var eachHandler = (start) => markedMethods2(start, handlerMetaOf);
-var discoverGateway = (instance) => {
-  const klass = instance.constructor;
-  const members = instance;
-  return {
-    name: klass.name,
-    path: normalizePath(gatewayPathOf(klass)),
-    handlers: eachHandler(Object.getPrototypeOf(instance)).map(({ name, meta: meta2 }) => ({
-      kind: meta2.kind,
-      event: meta2.event,
-      method: name,
-      invoke: members[name].bind(instance)
-    }))
-  };
-};
-var findHandlerMethod = (ctor) => eachHandler(ctor.prototype)[0]?.name;
-var discoverGateways = (modules, resolve) => {
-  const discovered = [];
-  for (const module of modules) {
-    for (const entry of module.options.providers ?? []) {
-      const candidate = classOf(entry);
-      if (!candidate)
-        continue;
-      if (isGateway(candidate.ctor)) {
-        discovered.push(discoverGateway(resolve(candidate.token)));
-        continue;
-      }
-      const orphan = findHandlerMethod(candidate.ctor);
-      if (orphan !== undefined) {
-        throw new AppError(`${candidate.ctor.name}.${orphan}() is a websocket handler, but ` + `${candidate.ctor.name} is not a gateway. Decorate the class with ` + "@Gateway(path), or drop the handler decorator.");
-      }
-    }
-  }
-  return discovered;
-};
-
-// src/inspect.ts
-var vendorOf = (schema) => schema?.["~standard"]?.vendor;
-var validatesIn = (options) => {
-  const body = vendorOf(options?.body);
-  const query = vendorOf(options?.query);
-  const params = vendorOf(options?.params);
-  return {
-    ...body === undefined ? {} : { body },
-    ...query === undefined ? {} : { query },
-    ...params === undefined ? {} : { params }
-  };
-};
-var rolesIn = (route) => {
-  const roles = route.meta?.get(ROLES.id);
-  if (roles === undefined || roles === null)
-    return null;
-  return (Array.isArray(roles) ? roles : [roles]).map(String);
-};
-var nodeFor = (route, module) => ({
-  method: route.method,
-  path: route.path,
-  controller: route.controller,
-  handler: route.handlerName,
-  module,
-  public: route.meta?.get(PUBLIC.id) === true,
-  roles: rolesIn(route),
-  guards: (route.guards ?? []).map((guard) => guard.name),
-  hidden: route.meta?.get(HIDDEN.id) === true,
-  validates: validatesIn(route.options),
-  status: route.options?.status ?? null,
-  responses: Object.keys(route.options?.response ?? {}).map(Number)
-});
-var routesOf = (root) => collectModules(root).flatMap((module) => readControllers(module).flatMap((controller) => {
-  const { prototype } = controller;
-  return discoverRoutes(Object.create(prototype)).map((route) => nodeFor(route, module.name));
-}));
-var gatewayFor = (ctor, module) => {
-  const { name, path, handlers } = discoverGateway(Object.create(ctor.prototype));
-  return {
-    name,
-    path,
-    module,
-    dependencies: dependenciesOf(ctor),
-    handlers: handlers.map((handler) => ({
-      kind: handler.kind,
-      event: handler.event ?? null,
-      method: handler.method
-    }))
-  };
-};
-var classOf2 = (entry) => {
-  if (typeof entry === "function")
-    return entry;
-  return entry.provider.kind === "class" ? entry.provider.ctor : undefined;
-};
-var gatewaysOf = (root) => collectModules(root).flatMap((module) => (module.options.providers ?? []).map(classOf2).filter((ctor) => ctor !== undefined).filter(isGateway).map((ctor) => gatewayFor(ctor, module.name)));
+  __runInitializers,
+  assertNoCollisions,
+  assertNoGatewayCollisions,
+  buildContext,
+  buildFallback,
+  buildGateways,
+  buildRoutes,
+  buildRuntime,
+  buildWebSocket,
+  compose,
+  composeSocket,
+  decode,
+  decodeRelay,
+  defaultErrorMapper,
+  defaultRelayError,
+  defaultRelayUrl,
+  defaultStatusFor,
+  discoverGateway,
+  discoverGateways,
+  discoverRoutes,
+  encode,
+  encodeRelay,
+  errorMapper,
+  gatewaysOf,
+  guardsOf,
+  isCompressibleType,
+  isErrorFilter,
+  isGateway,
+  joinPath,
+  markGateway,
+  markHandler,
+  mergeMeta,
+  meta,
+  metaKey,
+  metaOf,
+  negotiate,
+  normalizePath,
+  normalizePrefix,
+  observe,
+  preflight,
+  routesOf,
+  toErrorMapper,
+  withCors,
+  withUpgradeRoutes
+} from "./chunk-ywdpxbkf.js";
 // src/server/client-address.ts
-import { AppError as AppError2 } from "@dunx/core";
+import { AppError } from "@dunx/core";
 var trustedHops = (setting) => {
   if (setting === true)
     return 1;
@@ -257,7 +100,7 @@ class ClientAddress {
   of(req) {
     const source = sources.get(this);
     if (!source) {
-      throw new AppError2("ClientAddress has no server yet. The address comes from the live Bun " + "server, so it is only available once listen() has run.");
+      throw new AppError("ClientAddress has no server yet. The address comes from the live Bun " + "server, so it is only available once listen() has run.");
     }
     const hops = trustedHops(source.trustProxy);
     if (hops > 0) {
@@ -272,432 +115,17 @@ class ClientAddress {
 var attachAddressSource = (target, source) => {
   sources.set(target, source);
 };
-// src/server/context.ts
-var EMPTY = new Map;
-var buildContext = (route) => {
-  const record = route.meta ?? EMPTY;
-  return Object.freeze({
-    controller: route.controller,
-    handler: route.handlerName,
-    method: route.method,
-    path: route.path,
-    parsesBody: route.options?.body !== undefined,
-    get: (key) => record.get(key.id)
-  });
-};
-// src/server/cors.ts
-var ORIGIN = "access-control-allow-origin";
-var allowedOrigin = (options, requested) => {
-  const origin = options.origin ?? "*";
-  if (typeof origin === "string") {
-    if (origin !== "*")
-      return origin === requested ? origin : undefined;
-    if (!options.credentials)
-      return "*";
-    return requested ?? undefined;
-  }
-  if (requested === null)
-    return;
-  const allowed = typeof origin === "function" ? origin(requested) : origin.includes(requested);
-  return allowed ? requested : undefined;
-};
-var applyCors = (options, req, response) => {
-  const origin = allowedOrigin(options, req.headers.get("origin"));
-  if (origin === undefined)
-    return response;
-  response.headers.set(ORIGIN, origin);
-  if (origin !== "*")
-    response.headers.append("vary", "Origin");
-  if (options.credentials) {
-    response.headers.set("access-control-allow-credentials", "true");
-  }
-  if (options.exposedHeaders?.length) {
-    response.headers.set("access-control-expose-headers", options.exposedHeaders.join(", "));
-  }
-  return response;
-};
-var withCors = (options, handler) => {
-  return async (req) => applyCors(options, req, await handler(req));
-};
-var preflight = (options, methods) => {
-  const allowMethods = (options.methods ?? methods).join(", ");
-  return async (req) => {
-    const response = applyCors(options, req, new Response(null, { status: HttpStatusCode.NO_CONTENT }));
-    if (!response.headers.has(ORIGIN))
-      return response;
-    response.headers.set("access-control-allow-methods", allowMethods);
-    const allowHeaders = options.allowedHeaders ?? (req.headers.get("access-control-request-headers") ?? "").split(",").map((header) => header.trim()).filter((header) => header.length > 0);
-    if (allowHeaders.length > 0) {
-      response.headers.set("access-control-allow-headers", allowHeaders.join(", "));
-    }
-    if (options.maxAge !== undefined) {
-      response.headers.set("access-control-max-age", String(options.maxAge));
-    }
-    return response;
-  };
-};
-// src/server/errors.ts
-import { AppError as AppError3, ConsoleLogger } from "@dunx/core";
-class HttpError extends AppError3 {
-  status;
-  name = "HttpError";
-  headers;
-  constructor(status, message, options) {
-    super(message, options);
-    this.status = status;
-    this.headers = options?.headers;
-  }
-}
-Object.defineProperty(HttpError, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "readonly status: number" }, { unresolved: "message: string" }, { unresolved: "options?: HttpErrorOptions" }]
-});
-
-class ValidationError extends HttpError {
-  source;
-  issues;
-  name = "ValidationError";
-  constructor(source, issues) {
-    super(HttpStatusCode.BAD_REQUEST, `Invalid ${source}`);
-    this.source = source;
-    this.issues = issues;
-  }
-}
-Object.defineProperty(ValidationError, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "readonly source: InputSource" }, { unresolved: "readonly issues: readonly ValidationIssue[]" }]
-});
-
-class ErrorFilter {
-}
-var isErrorFilter = (handler) => typeof handler === "function" && typeof handler.prototype?.catch === "function";
-var toErrorMapper = (handler, resolve) => isErrorFilter(handler) ? (error, req) => resolve(handler).catch(error, req) : handler;
-var errorMapper = (logger) => (error) => {
-  if (error instanceof ValidationError) {
-    return Response.json({ error: error.message, status: error.status, issues: error.issues }, {
-      status: error.status,
-      ...error.headers && { headers: error.headers }
-    });
-  }
-  if (error instanceof HttpError) {
-    return Response.json({ error: error.message, status: error.status }, {
-      status: error.status,
-      ...error.headers && { headers: error.headers }
-    });
-  }
-  logger.error("Unhandled error", error);
-  return Response.json({
-    error: "Internal Server Error",
-    status: HttpStatusCode.INTERNAL_SERVER_ERROR
-  }, { status: HttpStatusCode.INTERNAL_SERVER_ERROR });
-};
-var defaultErrorMapper = errorMapper(new ConsoleLogger);
 // src/server/factory.ts
 import {
-  collectModules as collectModules2,
-  AppError as AppError8,
+  collectModules,
+  AppError as AppError4,
   AppFactory,
   Logger as Logger4,
   provide,
-  readControllers as readControllers2,
+  readControllers,
   RequestContext as RequestContext3
 } from "@dunx/core";
 
-// src/ws/envelope.ts
-var encode = (event, data) => JSON.stringify({ event, data });
-var decode = (message) => {
-  if (typeof message !== "string")
-    return;
-  let parsed;
-  try {
-    parsed = JSON.parse(message);
-  } catch {
-    return;
-  }
-  if (typeof parsed !== "object" || parsed === null)
-    return;
-  const { event, data } = parsed;
-  return typeof event === "string" ? { event, data } : undefined;
-};
-
-// src/ws/middleware.ts
-var composeSocket = (middleware, ctx) => middleware.reduceRight((next, current) => (frame, run) => current.handle(frame, ctx, () => next(frame, run)), (_frame, run) => run());
-var observe = (next, done) => {
-  let result;
-  try {
-    result = next();
-  } catch (error) {
-    done(error, undefined);
-    throw error;
-  }
-  if (result instanceof Promise) {
-    return result.then((value) => {
-      done(undefined, value);
-      return value;
-    }, (error) => {
-      done(error, undefined);
-      throw error;
-    });
-  }
-  done(undefined, result);
-  return result;
-};
-
-// src/ws/runtime.ts
-import { AppError as AppError4 } from "@dunx/core";
-var slotOf = (handler) => handler.kind === HandlerKind.MESSAGE && handler.event !== undefined ? `message ${JSON.stringify(handler.event)}` : handler.kind;
-var buildRuntime = (gateway) => {
-  if (gateway.handlers.length === 0) {
-    throw new AppError4(`${gateway.name} is registered as a gateway but declares no handlers. ` + "Add an @OnMessage/@OnOpen/... method, or drop the @Gateway decorator.");
-  }
-  const owners = new Map;
-  const events = new Map;
-  for (const handler of gateway.handlers) {
-    const slot = slotOf(handler);
-    const existing = owners.get(slot);
-    if (existing) {
-      throw new AppError4(`Handler collision in ${gateway.name}: ${slot} is claimed by ` + `${existing.method}() and by ${handler.method}(). One handler per event.`);
-    }
-    owners.set(slot, handler);
-    if (handler.kind === HandlerKind.MESSAGE && handler.event !== undefined) {
-      events.set(handler.event, handler.invoke);
-    }
-  }
-  const at = (slot) => owners.get(slot)?.invoke;
-  return {
-    name: gateway.name,
-    path: gateway.path,
-    upgrade: at(HandlerKind.UPGRADE),
-    open: at(HandlerKind.OPEN),
-    close: at(HandlerKind.CLOSE),
-    drain: at(HandlerKind.DRAIN),
-    ping: at(HandlerKind.PING),
-    pong: at(HandlerKind.PONG),
-    raw: at(HandlerKind.MESSAGE),
-    events
-  };
-};
-var buildGateways = (discovered) => {
-  const byPath = new Map;
-  for (const gateway of discovered) {
-    const existing = byPath.get(gateway.path);
-    if (existing) {
-      throw new AppError4(`Gateway path collision: ${gateway.path} is served by ${existing.name} ` + `and by ${gateway.name}. One gateway per path.`);
-    }
-    byPath.set(gateway.path, buildRuntime(gateway));
-  }
-  return byPath;
-};
-var someHandler = (gateways, pick) => {
-  for (const gateway of gateways)
-    if (pick(gateway) !== undefined)
-      return true;
-  return false;
-};
-
-// src/ws/adapter.ts
-var RUNTIME = Symbol.for("dunx.ws.runtime");
-var UNCLAIMED = Symbol.for("dunx.ws.unclaimed");
-var defaultOnError = (error, socket) => {
-  console.error(`[dunx/http] ${socket.data.path} handler failed:`, error);
-};
-var reportedByMiddleware = () => {
-  return;
-};
-var unreported = (middleware) => "Socket middleware is installed and none of it sets reportsErrors, so a " + "throwing gateway handler is reported nowhere: the console fallback is off " + "whenever middleware wraps the handler. Set reportsErrors on the one that " + "records a failure, or pass websocket.onError. Installed: " + `${middleware.map((entry) => entry.constructor.name).join(", ")}.`;
-var runtimeOf = (socket) => socket.data[RUNTIME];
-var isBinary = (value) => value instanceof ArrayBuffer || ArrayBuffer.isView(value);
-var replyRaw = (socket, value) => {
-  if (value === undefined)
-    return;
-  socket.send(typeof value === "string" || isBinary(value) ? value : JSON.stringify(value));
-};
-var settle = (result, socket, onError, then) => {
-  if (result instanceof Promise) {
-    result.then((value) => {
-      if (!then)
-        return;
-      try {
-        then(value);
-      } catch (error) {
-        onError(error, socket);
-      }
-    }, (error) => onError(error, socket));
-    return;
-  }
-  if (then)
-    then(result);
-};
-var framing = (kind) => {
-  if (kind === HandlerKind.CLOSE) {
-    return (args) => ({
-      socket: args[0],
-      data: { code: args[1], reason: args[2] }
-    });
-  }
-  if (kind === HandlerKind.OPEN || kind === HandlerKind.DRAIN) {
-    return (args) => ({ socket: args[0], data: undefined });
-  }
-  return (args) => ({ socket: args[1], data: args[0] });
-};
-var NOTHING = () => {
-  return;
-};
-var through = (gateway, middleware, kind, event, invoke) => {
-  const ctx = {
-    gateway: gateway.name,
-    path: gateway.path,
-    kind,
-    event
-  };
-  const dispatch = composeSocket(middleware, ctx);
-  const frameOf = framing(kind);
-  const run = invoke ?? NOTHING;
-  return (...args) => dispatch(frameOf(args), () => run(...args));
-};
-var withMiddleware = (gateway, middleware) => {
-  const wrap = (kind, event, invoke) => through(gateway, middleware, kind, event, invoke);
-  const optional = (kind, invoke) => invoke === undefined ? undefined : wrap(kind, undefined, invoke);
-  return {
-    ...gateway,
-    open: wrap(HandlerKind.OPEN, undefined, gateway.open),
-    close: wrap(HandlerKind.CLOSE, undefined, gateway.close),
-    drain: optional(HandlerKind.DRAIN, gateway.drain),
-    ping: optional(HandlerKind.PING, gateway.ping),
-    pong: optional(HandlerKind.PONG, gateway.pong),
-    raw: optional(HandlerKind.MESSAGE, gateway.raw),
-    events: new Map([...gateway.events].map(([event, invoke]) => [
-      event,
-      wrap(HandlerKind.MESSAGE, event, invoke)
-    ]))
-  };
-};
-var unclaimedDispatch = (gateway, middleware) => (frame, event) => composeSocket(middleware, {
-  gateway: gateway.name,
-  path: gateway.path,
-  kind: HandlerKind.MESSAGE,
-  event
-})(frame, () => {
-  return;
-});
-var buildWebSocket = (discovered, options = {}, middleware = []) => {
-  const byPath = buildGateways(discovered);
-  const wrapped = middleware.length === 0 ? byPath : new Map([...byPath].map(([path, gateway]) => [
-    path,
-    withMiddleware(gateway, middleware)
-  ]));
-  const gateways = [...wrapped.values()];
-  const onError = options.onError ?? (middleware.length === 0 ? defaultOnError : reportedByMiddleware);
-  const reports = options.onError !== undefined || middleware.some((entry) => entry.reportsErrors === true);
-  const { onError: _onError, ...socketOptions } = options;
-  const run = (invoke, args, ws, then) => {
-    try {
-      settle(invoke(...args), ws, onError, then);
-    } catch (error) {
-      onError(error, ws);
-    }
-  };
-  const websocket = {
-    ...socketOptions,
-    message(ws, message) {
-      const gateway = runtimeOf(ws);
-      let event;
-      if (gateway.events.size > 0) {
-        const envelope = decode(message);
-        const handler = envelope && gateway.events.get(envelope.event);
-        if (envelope && handler) {
-          run(handler, [envelope.data, ws], ws, (value) => {
-            if (value !== undefined)
-              ws.send(encode(envelope.event, value));
-          });
-          return;
-        }
-        event = envelope?.event;
-      }
-      if (gateway.raw) {
-        run(gateway.raw, [message, ws], ws, (value) => replyRaw(ws, value));
-        return;
-      }
-      const unclaimed2 = ws.data[UNCLAIMED];
-      if (!unclaimed2)
-        return;
-      try {
-        settle(unclaimed2({ socket: ws, data: message }, event), ws, onError, undefined);
-      } catch (error) {
-        onError(error, ws);
-      }
-    },
-    ...someHandler(gateways, (g) => g.open) && {
-      open(ws) {
-        const { open } = runtimeOf(ws);
-        if (open)
-          run(open, [ws], ws, undefined);
-      }
-    },
-    ...someHandler(gateways, (g) => g.close) && {
-      close(ws, code, reason) {
-        const { close } = runtimeOf(ws);
-        if (close)
-          run(close, [ws, code, reason], ws, undefined);
-      }
-    },
-    ...someHandler(gateways, (g) => g.drain) && {
-      drain(ws) {
-        const { drain } = runtimeOf(ws);
-        if (drain)
-          run(drain, [ws], ws, undefined);
-      }
-    },
-    ...someHandler(gateways, (g) => g.ping) && {
-      ping(ws, data) {
-        const { ping } = runtimeOf(ws);
-        if (ping)
-          run(ping, [data, ws], ws, undefined);
-      }
-    },
-    ...someHandler(gateways, (g) => g.pong) && {
-      pong(ws, data) {
-        const { pong } = runtimeOf(ws);
-        if (pong)
-          run(pong, [data, ws], ws, undefined);
-      }
-    }
-  };
-  const unclaimed = new Map(middleware.length === 0 ? [] : gateways.map((gateway) => [
-    gateway,
-    unclaimedDispatch(gateway, middleware)
-  ]));
-  const accept = (req, server, gateway, context) => {
-    const fallback = unclaimed.get(gateway);
-    const data = {
-      path: gateway.path,
-      context,
-      id: crypto.randomUUID(),
-      [RUNTIME]: gateway,
-      ...fallback === undefined ? {} : { [UNCLAIMED]: fallback }
-    };
-    return server.upgrade(req, { data }) ? undefined : new Response("Expected a WebSocket upgrade", { status: 426 });
-  };
-  const upgradeHandler = (gateway) => (req, server) => {
-    if (!gateway.upgrade)
-      return accept(req, server, gateway, undefined);
-    const result = gateway.upgrade(req);
-    if (result instanceof Promise) {
-      return result.then((value) => value instanceof Response ? value : accept(req, server, gateway, value));
-    }
-    return result instanceof Response ? result : accept(req, server, gateway, result);
-  };
-  return {
-    websocket,
-    routes: new Map(gateways.map((gateway) => [gateway.path, upgradeHandler(gateway)])),
-    paths: [...byPath.keys()],
-    warnings: middleware.length > 0 && !reports ? [unreported(middleware)] : [],
-    gateways: gateways.map((gateway) => ({
-      name: gateway.name,
-      path: gateway.path,
-      events: [...gateway.events.keys()]
-    }))
-  };
-};
-
 // src/ws/logging.ts
 import { Logger, LogLevel, RequestContext } from "@dunx/core";
 var LIFECYCLE_LABEL = {
@@ -742,7 +170,7 @@ class SocketLoggingMiddleware {
     const label = ctx.event ?? LIFECYCLE_LABEL[ctx.kind] ?? ctx.kind;
     const connectionId = frame.socket.data.id;
     const started = Bun.nanoseconds();
-    const write2 = (error, value) => {
+    const write = (error, value) => {
       const entry = {
         gateway: ctx.gateway,
         path: ctx.path,
@@ -756,8 +184,8 @@ class SocketLoggingMiddleware {
       this.#emit(error === undefined ? level : this.#errorLevel, line, entry);
     };
     if (!this.#correlate)
-      return observe(next, write2);
-    return this.context.runWithContext({ connectionId, event: label, flow: "ws", context: ctx.gateway }, () => observe(next, write2));
+      return observe(next, write);
+    return this.context.runWithContext({ connectionId, event: label, flow: "ws", context: ctx.gateway }, () => observe(next, write));
   }
   #emit(level, line, entry) {
     switch (level) {
@@ -793,42 +221,10 @@ class SocketLoggingMiddleware {
     return text.length > this.#limit ? `[${text.length} chars]` : data;
   }
 }
-Object.defineProperty(SocketLoggingMiddleware, Symbol.for("dunx.deps"), {
-  value: () => [Logger, RequestContext, { unresolved: "options: SocketLoggingOptions = {}" }]
-});
-
-// src/ws/pubsub.ts
-import { AppError as AppError5 } from "@dunx/core";
-
-// src/ws/relay.ts
-var DEFAULT_RELAY_CHANNEL = "dunx:ws";
-var defaultRelayError = (error, phase) => {
-  console.warn(`[dunx/http] the websocket relay could not ${phase}. Fan-out is local to ` + "this process until it recovers:", error);
-};
-var toBytes = (data) => ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
-var encodeRelay = (origin, topic, data) => typeof data === "string" ? JSON.stringify({ o: origin, t: topic, d: data }) : JSON.stringify({
-  o: origin,
-  t: topic,
-  d: Buffer.from(toBytes(data)).toString("base64"),
-  b: 1
-});
-var decodeRelay = (message) => {
-  let parsed;
-  try {
-    parsed = JSON.parse(message);
-  } catch {
-    return;
-  }
-  if (typeof parsed !== "object" || parsed === null)
-    return;
-  const { o, t, d, b } = parsed;
-  if (typeof o !== "string" || typeof t !== "string" || typeof d !== "string") {
-    return;
-  }
-  return { origin: o, topic: t, data: b ? Buffer.from(d, "base64") : d };
-};
+Object.defineProperty(SocketLoggingMiddleware, Symbol.for("dunx.deps"), { value: () => [Logger, RequestContext, { unresolved: "options: SocketLoggingOptions = {}", optional: true }] });
 
 // src/ws/pubsub.ts
+import { AppError as AppError2 } from "@dunx/core";
 class PubSub {
   #origin = Bun.randomUUIDv7();
   #server;
@@ -853,7 +249,7 @@ class PubSub {
   }
   async relayThrough(relay, options = {}) {
     if (this.#relay) {
-      throw new AppError5("PubSub already relays. Two subscriptions on one channel would deliver " + "every relayed message twice - pass HttpOptions.relay or call " + "relayThrough(), not both.");
+      throw new AppError2("PubSub already relays. Two subscriptions on one channel would deliver " + "every relayed message twice - pass HttpOptions.relay or call " + "relayThrough(), not both.");
     }
     this.#relay = relay;
     this.#channel = options.channel ?? DEFAULT_RELAY_CHANNEL;
@@ -949,7 +345,7 @@ class PubSub {
   }
   #live() {
     if (!this.#server) {
-      throw new AppError5("PubSub has no server yet. Publish once the server is listening: " + "HttpApp.listen() is what attaches it.");
+      throw new AppError2("PubSub has no server yet. Publish once the server is listening: " + "HttpApp.listen() is what attaches it.");
     }
     return this.#server;
   }
@@ -957,7 +353,7 @@ class PubSub {
 
 // src/server/application.ts
 import {
-  AppError as AppError7,
+  AppError as AppError3,
   Logger as Logger3,
   runtimeInfo,
   ShutdownHooks,
@@ -970,47 +366,6 @@ import {
   Logger as Logger2,
   RequestContext as RequestContext2
 } from "@dunx/core";
-
-// src/server/raw-body.ts
-var WANTED = Symbol.for("dunx.http.rawBody.wanted");
-var TEXT = Symbol.for("dunx.http.rawBody.text");
-
-class RawBody {
-  static want(req) {
-    req[WANTED] = true;
-  }
-  static wanted(req) {
-    return req[WANTED] === true;
-  }
-  static record(req, text) {
-    req[TEXT] = text;
-  }
-  static read(req) {
-    return req[TEXT];
-  }
-}
-
-// src/server/request-id.ts
-var REQUEST_ID_HEADER = "x-request-id";
-var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var traceId = (inbound) => inbound !== null && inbound.length === 36 && UUID.test(inbound) ? inbound : crypto.randomUUID();
-var ID = Symbol.for("dunx.http.requestId");
-
-class RequestIds {
-  static assign(req) {
-    const id = traceId(req.headers.get(REQUEST_ID_HEADER));
-    req[ID] = id;
-    return id;
-  }
-  static stamp(response, req) {
-    const id = req[ID];
-    if (id !== undefined)
-      response.headers.set(REQUEST_ID_HEADER, id);
-    return response;
-  }
-}
-
-// src/server/request-logging.ts
 var parse = (text, limit) => {
   if (limit === 0)
     return;
@@ -1036,6 +391,7 @@ class RequestLoggingMiddleware {
   #ignorePrefix;
   #correlateIgnored;
   #correlate;
+  #trace;
   constructor(logger, context, options = {}) {
     this.logger = logger;
     this.context = context;
@@ -1046,6 +402,7 @@ class RequestLoggingMiddleware {
     this.#ignorePrefix = options.ignorePrefix ?? [];
     this.#correlateIgnored = options.correlateIgnored ?? false;
     this.#correlate = options.correlate ?? true;
+    this.#trace = options.trace ?? false;
   }
   #ignored(path) {
     if (this.#ignore.size > 0 && this.#ignore.has(path))
@@ -1071,6 +428,14 @@ class RequestLoggingMiddleware {
       flow: "http",
       context: `${ctx.controller}.${ctx.handler}`
     };
+    if (this.#trace) {
+      const trace = TraceContext.adopt(req, requestId);
+      scope.traceId = trace.traceId;
+      scope.spanId = trace.spanId;
+      if (trace.parentSpanId !== undefined) {
+        scope.parentSpanId = trace.parentSpanId;
+      }
+    }
     return this.#correlate ? this.context.runWithContext(scope, () => this.#begin(req, ctx, url, mark, path, requestId, started, next, undefined)) : this.#begin(req, ctx, url, mark, path, requestId, started, next, scope);
   }
   #begin(req, ctx, url, mark, path, requestId, started, next, scope) {
@@ -1196,248 +561,7 @@ class RequestLoggingMiddleware {
     return response.clone().text().then((text) => parse(text, this.#limit));
   }
 }
-Object.defineProperty(RequestLoggingMiddleware, Symbol.for("dunx.deps"), {
-  value: () => [Logger2, RequestContext2, { unresolved: "options: RequestLoggingOptions = {}" }]
-});
-
-// src/server/routes.ts
-import { AppError as AppError6 } from "@dunx/core";
-
-// src/server/input.ts
-var grouped = (entries) => {
-  const collected = {};
-  entries.forEach((value, key) => {
-    const existing = collected[key];
-    if (existing === undefined)
-      collected[key] = value;
-    else if (Array.isArray(existing))
-      existing.push(value);
-    else
-      collected[key] = [existing, value];
-  });
-  return collected;
-};
-var asJson = (req) => req.json();
-var asUrlEncoded = async (req) => grouped(new URLSearchParams(await req.text()));
-var asMultipart = async (req) => grouped(await req.formData());
-var asText = (req) => req.text();
-var parserFor = (media) => {
-  if (media === "application/json" || media.endsWith("+json"))
-    return asJson;
-  if (media === "application/x-www-form-urlencoded")
-    return asUrlEncoded;
-  if (media === "multipart/form-data")
-    return asMultipart;
-  if (media.startsWith("text/"))
-    return asText;
-  return;
-};
-var JSON_MEDIA = "application/json";
-var mediaTypeOf = (req) => {
-  const header = req.headers.get("content-type");
-  if (header === JSON_MEDIA || header === null)
-    return JSON_MEDIA;
-  const end = header.indexOf(";");
-  const media = (end === -1 ? header : header.slice(0, end)).trim();
-  return media === "" ? JSON_MEDIA : media.toLowerCase();
-};
-var flatten = (issue) => {
-  const path = issue.path?.map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
-  return path === undefined || path === "" ? { message: issue.message } : { message: issue.message, path };
-};
-var accept = (source, result) => {
-  if (result.issues !== undefined) {
-    throw new ValidationError(source, result.issues.map(flatten));
-  }
-  return result.value;
-};
-var fillWith = (draft, source, schema, value) => {
-  const result = schema["~standard"].validate(value);
-  if (result instanceof Promise) {
-    return result.then((settled) => {
-      draft[source] = accept(source, settled);
-      return draft;
-    });
-  }
-  draft[source] = accept(source, result);
-  return draft;
-};
-var bodyFill = (schema) => (draft) => {
-  const media = mediaTypeOf(draft.req);
-  const parse2 = parserFor(media);
-  if (parse2 === undefined) {
-    throw new HttpError(HttpStatusCode.UNSUPPORTED_MEDIA_TYPE, `Unsupported content type "${media}". Declared bodies accept ` + "application/json, application/x-www-form-urlencoded, multipart/form-data or text/*.");
-  }
-  const read = parse2 === asJson && RawBody.wanted(draft.req) ? draft.req.text().then((text) => {
-    RawBody.record(draft.req, text);
-    return JSON.parse(text);
-  }) : parse2(draft.req);
-  return read.then((value) => fillWith(draft, "body", schema, value), (error) => {
-    throw new HttpError(HttpStatusCode.BAD_REQUEST, `Malformed ${media} body`, { cause: error });
-  });
-};
-var searchOf = (url) => {
-  const start = url.indexOf("?");
-  if (start === -1)
-    return "";
-  const end = url.indexOf("#", start + 1);
-  return end === -1 ? url.slice(start + 1) : url.slice(start + 1, end);
-};
-var queryFill = (schema) => (draft) => {
-  const params = new URLSearchParams(searchOf(draft.req.url));
-  return fillWith(draft, "query", schema, grouped(params));
-};
-var paramsFill = (schema) => (draft) => fillWith(draft, "params", schema, draft.req.params);
-var then = (first, second) => (draft) => {
-  const started = first(draft);
-  return started instanceof Promise ? started.then(second) : second(started);
-};
-var buildInputReader = (options) => {
-  const fills = [];
-  if (options?.body !== undefined)
-    fills.push(bodyFill(options.body));
-  if (options?.query !== undefined)
-    fills.push(queryFill(options.query));
-  if (options?.params !== undefined)
-    fills.push(paramsFill(options.params));
-  if (fills.length === 0)
-    return (req) => ({ req });
-  const fill = fills.reduce(then);
-  return (req) => fill({ req });
-};
-
-// src/server/middleware.ts
-var compose = (middleware, ctx, handler) => middleware.reduceRight((next, current) => (req) => current.handle(req, ctx, () => next(req)), handler);
-
-// src/server/routes.ts
-var construct = (guard) => new guard;
-var toResponse = (value, status) => {
-  if (value instanceof Response)
-    return value;
-  if (value === undefined || value === null) {
-    return new Response(null, { status: HttpStatusCode.NO_CONTENT });
-  }
-  return Response.json(value, { status });
-};
-var statusFor = (route) => route.options?.status ?? (route.method === "POST" ? HttpStatusCode.CREATED : HttpStatusCode.OK);
-var assertNoCollisions = (discovered) => {
-  const owners = new Map;
-  for (const route of discovered) {
-    const key = `${route.method} ${route.path}`;
-    const owner = `${route.controller}.${route.handlerName}`;
-    const existing = owners.get(key);
-    if (existing !== undefined) {
-      throw new AppError6(`Route collision: ${key} is declared by ${existing} and by ${owner}. ` + "Bun would keep only one of them.");
-    }
-    owners.set(key, owner);
-  }
-};
-var assertNoGatewayCollisions = (discovered, gatewayPaths) => {
-  const gateways = new Set(gatewayPaths);
-  for (const route of discovered) {
-    if (gateways.has(route.path)) {
-      throw new AppError6(`Gateway path collision: ${route.path} is served by a gateway and by ` + `${route.controller}.${route.handlerName}(). The upgrade is a route too, ` + "so one of them would be dropped.");
-    }
-  }
-};
-var withUpgradeRoutes = (routes, gateways) => {
-  const merged = { ...routes };
-  for (const [path, upgrade] of gateways)
-    merged[path] = { GET: upgrade };
-  return merged;
-};
-var unmatchedContext = (req, isPublic) => Object.freeze({
-  controller: "(unmatched)",
-  handler: "(none)",
-  method: req.method,
-  path: new URL(req.url).pathname,
-  parsesBody: false,
-  get: (key) => {
-    if (key.id === UNMATCHED.id)
-      return true;
-    if (key.id === PUBLIC.id && isPublic)
-      return true;
-    return;
-  }
-});
-var buildFallback = (middleware = [], onError = defaultErrorMapper, cors, notFound = "guarded") => {
-  const miss = () => {
-    throw new HttpError(HttpStatusCode.NOT_FOUND, "NOT_FOUND");
-  };
-  const run = async (req) => {
-    try {
-      return await compose(middleware, unmatchedContext(req, notFound === "public"), miss)(req);
-    } catch (error) {
-      return RequestIds.stamp(onError(error, req), req);
-    }
-  };
-  return cors ? withCors(cors, run) : run;
-};
-var directOr = (guarded, route, read, status, onError, noMiddleware) => {
-  if (!noMiddleware)
-    return guarded;
-  const settle2 = (value, req) => {
-    try {
-      return toResponse(value, status);
-    } catch (error) {
-      return onError(error, req);
-    }
-  };
-  const invoke = (input, req) => {
-    try {
-      const value = route.handler(input);
-      return value instanceof Promise ? value.then((resolved) => settle2(resolved, req), (error) => onError(error, req)) : settle2(value, req);
-    } catch (error) {
-      return onError(error, req);
-    }
-  };
-  return (req) => {
-    try {
-      const input = read(req);
-      return input instanceof Promise ? input.then((resolved) => invoke(resolved, req), (error) => onError(error, req)) : invoke(input, req);
-    } catch (error) {
-      return onError(error, req);
-    }
-  };
-};
-var buildRoutes = (discovered, middleware = [], onError = defaultErrorMapper, cors, resolve = construct) => {
-  assertNoCollisions(discovered);
-  const routes = {};
-  const instances = new Map;
-  const guardOf = (guard, from) => {
-    const existing = instances.get(guard);
-    if (existing)
-      return existing;
-    const created = resolve(guard, from);
-    instances.set(guard, created);
-    return created;
-  };
-  for (const route of discovered) {
-    const read = buildInputReader(route.options);
-    const status = statusFor(route);
-    const chain = [
-      ...middleware,
-      ...(route.moduleMiddleware ?? []).map((entry) => guardOf(entry, route.module)),
-      ...(route.guards ?? []).map((guard) => guardOf(guard, route.module))
-    ];
-    const chained = compose(chain, buildContext(route), async (req) => toResponse(await route.handler(await read(req)), status));
-    const guarded = async (req) => {
-      try {
-        return await chained(req);
-      } catch (error) {
-        return RequestIds.stamp(onError(error, req), req);
-      }
-    };
-    const byMethod = routes[route.path] ??= {};
-    byMethod[route.method] = cors ? withCors(cors, guarded) : directOr(guarded, route, read, status, onError, chain.length === 0);
-  }
-  if (cors) {
-    for (const byMethod of Object.values(routes)) {
-      byMethod.OPTIONS = preflight(cors, Object.keys(byMethod));
-    }
-  }
-  return routes;
-};
+Object.defineProperty(RequestLoggingMiddleware, Symbol.for("dunx.deps"), { value: () => [Logger2, RequestContext2, { unresolved: "options: RequestLoggingOptions = {}", optional: true }] });
 
 // src/server/settings.ts
 var defaultSettings = () => ({ "trust proxy": false });
@@ -1620,12 +744,10 @@ class HttpApplication {
   #assertNotStarted(hook) {
     if (!this.#started)
       return;
-    throw new AppError7(`${hook} must be called before listen(). The route table and the middleware ` + "chain are folded into one closure per route when the server binds, so " + "this call could not take effect.");
+    throw new AppError3(`${hook} must be called before listen(). The route table and the middleware ` + "chain are folded into one closure per route when the server binds, so " + "this call could not take effect.");
   }
 }
-Object.defineProperty(HttpApplication, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "app: App", typeOnly: "App" }, { unresolved: "discovered: readonly DiscoveredRoute[]" }, { unresolved: "options: HttpOptions" }, { unresolved: "root: ModuleRef", typeOnly: "ModuleRef" }, { unresolved: "websocket?: WebSocketRuntime", typeOnly: "WebSocketRuntime" }]
-});
+Object.defineProperty(HttpApplication, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "app: App", typeOnly: "App" }, { unresolved: "discovered: readonly DiscoveredRoute[]" }, { unresolved: "options: HttpOptions" }, { unresolved: "root: ModuleRef", typeOnly: "ModuleRef" }, { unresolved: "websocket?: WebSocketRuntime", typeOnly: "WebSocketRuntime" }] });
 
 // src/server/factory.ts
 class HttpModule {
@@ -1655,14 +777,14 @@ class HttpFactory {
       exports: providers.map((entry) => typeof entry === "function" ? entry : entry.token)
     };
     const app = await AppFactory.create(scope, options.overrides ? { overrides: options.overrides } : {});
-    const modules = collectModules2(scope);
+    const modules = collectModules(scope);
     const discovered = [];
     for (const module of modules) {
       const moduleMiddleware = module.options.middleware ?? [];
-      for (const controller of readControllers2(module)) {
+      for (const controller of readControllers(module)) {
         const routes = discoverRoutes(app.get(controller, module.ref));
         if (routes.length === 0) {
-          throw new AppError8(`${controller.name} is registered as a controller but declares no routes. ` + "Add a @Get/@Post/... method, or move it to providers.");
+          throw new AppError4(`${controller.name} is registered as a controller but declares no routes. ` + "Add a @Get/@Post/... method, or move it to providers.");
         }
         discovered.push(...routes.map((route) => ({
           ...route,
@@ -1689,29 +811,6 @@ class HttpFactory {
 }
 // src/static/files.ts
 import { join, normalize, resolve } from "path";
-
-// src/static/options.ts
-class StaticOptions {
-  root;
-  path;
-  maxAge;
-  immutable;
-  constructor(init) {
-    this.root = init.root;
-    this.path = normalizePrefix(init.path ?? "/");
-    this.maxAge = init.maxAge ?? 60;
-    this.immutable = init.immutable ?? (() => false);
-  }
-}
-Object.defineProperty(StaticOptions, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "init: StaticOptionsInit" }]
-});
-var normalizePrefix = (path) => {
-  const trimmed = path.split("/").filter(Boolean).join("/");
-  return trimmed === "" ? "/" : `/${trimmed}`;
-};
-
-// src/static/files.ts
 class StaticFiles {
   #options;
   #root;
@@ -1763,9 +862,7 @@ class StaticFiles {
     });
   }
 }
-Object.defineProperty(StaticFiles, Symbol.for("dunx.deps"), {
-  value: () => [StaticOptions]
-});
+Object.defineProperty(StaticFiles, Symbol.for("dunx.deps"), { value: () => [StaticOptions] });
 // src/static/module.ts
 import {
   Module,
@@ -1810,6 +907,177 @@ StaticModule = __decorateElement(_init, 0, "StaticModule", _dec, StaticModule);
 __runInitializers(_init, 1, StaticModule);
 __decoratorMetadata(_init, StaticModule);
 let _StaticModule = StaticModule;
+// src/compression/compression.ts
+var BODYLESS = new Set([204, 205, 304]);
+var BUFFER_LIMIT = 1024 * 1024;
+var buffer = async (body, limit) => {
+  const reader = body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+    size += value.byteLength;
+    if (size > limit) {
+      return {
+        rest: new ReadableStream({
+          start: (controller) => {
+            for (const chunk of chunks)
+              controller.enqueue(chunk);
+          },
+          pull: async (controller) => {
+            const next = await reader.read();
+            if (next.done)
+              controller.close();
+            else
+              controller.enqueue(next.value);
+          },
+          cancel: (reason) => reader.cancel(reason)
+        })
+      };
+    }
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { bytes };
+};
+var declaredLength = (headers) => {
+  const raw = headers.get("content-length");
+  if (raw === null)
+    return;
+  const length = Number.parseInt(raw, 10);
+  return Number.isFinite(length) ? length : undefined;
+};
+var weakenETag = (headers) => {
+  const etag = headers.get("etag");
+  if (etag !== null && !etag.startsWith("W/"))
+    headers.set("etag", `W/${etag}`);
+};
+var varyOnEncoding = (headers) => {
+  const existing = headers.get("vary");
+  if (existing === null) {
+    headers.set("vary", "accept-encoding");
+    return;
+  }
+  if (existing.trim() === "*")
+    return;
+  const listed = existing.split(",").some((field) => field.trim().toLowerCase() === "accept-encoding");
+  if (!listed)
+    headers.set("vary", `${existing}, accept-encoding`);
+};
+var encodeSync = (encoding, data) => {
+  switch (encoding) {
+    case CompressionEncoding.ZSTD:
+      return Bun.zstdCompressSync(data);
+    case CompressionEncoding.GZIP:
+      return Bun.gzipSync(data);
+  }
+};
+
+class Compression {
+  #options;
+  constructor(options) {
+    this.#options = options;
+  }
+  #considers(res) {
+    if (BODYLESS.has(res.status) || res.status === 206)
+      return false;
+    if (res.headers.has("content-encoding"))
+      return false;
+    if (res.headers.get("cache-control")?.includes("no-transform") === true) {
+      return false;
+    }
+    return this.#options.filter(res.headers.get("content-type"));
+  }
+  async handle(req, _ctx, next) {
+    const res = await next();
+    const body = res.body;
+    if (body === null || !this.#considers(res))
+      return res;
+    varyOnEncoding(res.headers);
+    const encoding = negotiate(req.headers.get("accept-encoding"), this.#options.encodings);
+    if (encoding === undefined)
+      return res;
+    const declared = declaredLength(res.headers);
+    if (declared !== undefined && declared < this.#options.threshold)
+      return res;
+    const headers = new Headers(res.headers);
+    headers.set("content-encoding", encoding);
+    weakenETag(headers);
+    const source = declared !== undefined && declared > BUFFER_LIMIT ? { rest: body } : await buffer(body, BUFFER_LIMIT);
+    if ("rest" in source) {
+      headers.delete("content-length");
+      return new Response(source.rest.pipeThrough(new CompressionStream(encoding)), { status: res.status, statusText: res.statusText, headers });
+    }
+    if (source.bytes.byteLength < this.#options.threshold) {
+      const passthrough = new Headers(res.headers);
+      passthrough.set("content-length", String(source.bytes.byteLength));
+      return new Response(source.bytes, {
+        status: res.status,
+        statusText: res.statusText,
+        headers: passthrough
+      });
+    }
+    const encoded = encodeSync(encoding, source.bytes);
+    headers.set("content-length", String(encoded.byteLength));
+    return new Response(encoded, {
+      status: res.status,
+      statusText: res.statusText,
+      headers
+    });
+  }
+}
+Object.defineProperty(Compression, Symbol.for("dunx.deps"), { value: () => [CompressionOptions] });
+// src/compression/module.ts
+import {
+  Module as Module2,
+  provide as provide3
+} from "@dunx/core";
+var middleware = () => provide3(Compression, {
+  useFactory: (options) => new Compression(options),
+  inject: [CompressionOptions]
+});
+var _dec = [
+  Module2({})
+];
+var _init = __decoratorStart(undefined);
+
+class CompressionModule {
+  static forRoot(init = {}) {
+    return {
+      module: CompressionModule,
+      exports: [CompressionOptions, Compression],
+      providers: [
+        provide3(CompressionOptions, { useValue: new CompressionOptions(init) }),
+        middleware()
+      ]
+    };
+  }
+  static forRootAsync(config) {
+    return {
+      module: CompressionModule,
+      ...config.imports && { imports: config.imports },
+      exports: [CompressionOptions, Compression],
+      providers: [
+        provide3(CompressionOptions, {
+          useFactory: async (...deps) => new CompressionOptions(await config.useFactory(...deps)),
+          inject: config.inject ?? []
+        }),
+        middleware()
+      ]
+    };
+  }
+}
+CompressionModule = __decorateElement(_init, 0, "CompressionModule", _dec, CompressionModule);
+__runInitializers(_init, 1, CompressionModule);
+__decoratorMetadata(_init, CompressionModule);
+let _CompressionModule = CompressionModule;
 // src/throttle/decorators.ts
 var THROTTLE = metaKey("throttle");
 var SKIP_THROTTLE = metaKey("skip-throttle");
@@ -1819,7 +1087,7 @@ var SkipThrottle = () => meta(SKIP_THROTTLE, true);
 import { Logger as Logger5 } from "@dunx/core";
 
 // src/throttle/options.ts
-import { AppError as AppError9 } from "@dunx/core";
+import { AppError as AppError5 } from "@dunx/core";
 
 class ThrottleOptions {
   limit;
@@ -1830,13 +1098,13 @@ class ThrottleOptions {
   store;
   constructor(init) {
     if (init.prefix.trim() === "") {
-      throw new AppError9("ThrottleModule needs a prefix naming this application, and it has no " + "default: two apps sharing one Redis with one throttle namespace each " + "spend the other's budget. Pass something like { prefix: 'orders-api' }.");
+      throw new AppError5("ThrottleModule needs a prefix naming this application, and it has no " + "default: two apps sharing one Redis with one throttle namespace each " + "spend the other's budget. Pass something like { prefix: 'orders-api' }.");
     }
     if (!Number.isInteger(init.limit) || init.limit < 1) {
-      throw new AppError9(`ThrottleModule needs a limit of at least 1; got ${init.limit}.`);
+      throw new AppError5(`ThrottleModule needs a limit of at least 1; got ${init.limit}.`);
     }
     if (!Number.isInteger(init.windowSeconds) || init.windowSeconds < 1) {
-      throw new AppError9("ThrottleModule needs a windowSeconds of at least 1; got " + `${init.windowSeconds}.`);
+      throw new AppError5("ThrottleModule needs a windowSeconds of at least 1; got " + `${init.windowSeconds}.`);
     }
     this.limit = init.limit;
     this.windowSeconds = init.windowSeconds;
@@ -1846,17 +1114,15 @@ class ThrottleOptions {
     this.store = init.store;
   }
 }
-Object.defineProperty(ThrottleOptions, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "init: ThrottleOptionsInit" }]
-});
+Object.defineProperty(ThrottleOptions, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "init: ThrottleOptionsInit" }] });
 
 // src/throttle/store.ts
-import { AppError as AppError10 } from "@dunx/core";
+import { AppError as AppError6 } from "@dunx/core";
 
 class ThrottleStore {
   constructor() {
     if (new.target === ThrottleStore) {
-      throw new AppError10("ThrottleStore is a contract, not an implementation. Bind one with " + "ThrottleModule.forRoot({ store: new RedisThrottleStore(redis) }), or " + "leave it out for the in-process MemoryThrottleStore.");
+      throw new AppError6("ThrottleStore is a contract, not an implementation. Bind one with " + "ThrottleModule.forRoot({ store: new RedisThrottleStore(redis) }), or " + "leave it out for the in-process MemoryThrottleStore.");
     }
   }
 }
@@ -1878,9 +1144,7 @@ class RedisThrottleStore extends ThrottleStore {
     return left > 0 ? left : undefined;
   }
 }
-Object.defineProperty(RedisThrottleStore, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "private readonly redis: ThrottleRedis" }]
-});
+Object.defineProperty(RedisThrottleStore, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "private readonly redis: ThrottleRedis" }] });
 
 class MemoryThrottleStore extends ThrottleStore {
   #windows = new Map;
@@ -1917,9 +1181,7 @@ class MemoryThrottleStore extends ThrottleStore {
       this.#windows.clear();
   }
 }
-Object.defineProperty(MemoryThrottleStore, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "maxKeys = 10_000" }]
-});
+Object.defineProperty(MemoryThrottleStore, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "maxKeys = 10_000", optional: true }] });
 
 // src/throttle/guard.ts
 class ThrottleGuard {
@@ -1989,26 +1251,24 @@ class ThrottleGuard {
     this.logger.warn("The rate limiter is unreachable, so requests are not being counted.", { reason: error.message });
   }
 }
-Object.defineProperty(ThrottleGuard, Symbol.for("dunx.deps"), {
-  value: () => [ThrottleOptions, ThrottleStore, ClientAddress, Logger5]
-});
+Object.defineProperty(ThrottleGuard, Symbol.for("dunx.deps"), { value: () => [ThrottleOptions, ThrottleStore, ClientAddress, Logger5] });
 // src/throttle/module.ts
 import {
   Logger as Logger6,
-  Module as Module2,
-  provide as provide3
+  Module as Module3,
+  provide as provide4
 } from "@dunx/core";
 var EXPORTS = [ThrottleOptions, ThrottleStore, ThrottleGuard];
-var guard = () => provide3(ThrottleGuard, {
+var guard = () => provide4(ThrottleGuard, {
   useFactory: (options, store, address, logger) => new ThrottleGuard(options, store, address, logger),
   inject: [ThrottleOptions, ThrottleStore, ClientAddress, Logger6]
 });
-var store = () => provide3(ThrottleStore, {
+var store = () => provide4(ThrottleStore, {
   useFactory: (options) => options.store ?? new MemoryThrottleStore,
   inject: [ThrottleOptions]
 });
 var _dec = [
-  Module2({})
+  Module3({})
 ];
 var _init = __decoratorStart(undefined);
 
@@ -2019,7 +1279,7 @@ class ThrottleModule {
       global: true,
       exports: EXPORTS,
       providers: [
-        provide3(ThrottleOptions, { useValue: new ThrottleOptions(init) }),
+        provide4(ThrottleOptions, { useValue: new ThrottleOptions(init) }),
         store(),
         guard()
       ]
@@ -2032,7 +1292,7 @@ class ThrottleModule {
       ...config.imports && { imports: config.imports },
       exports: EXPORTS,
       providers: [
-        provide3(ThrottleOptions, {
+        provide4(ThrottleOptions, {
           useFactory: async (...deps) => new ThrottleOptions(await config.useFactory(...deps)),
           inject: config.inject ?? []
         }),
@@ -2065,99 +1325,6 @@ var OnMessage = (event) => (value) => {
   markHandler(value, { kind: HandlerKind.MESSAGE, event });
   return value;
 };
-// src/ws/redis-relay.ts
-import { AppError as AppError11 } from "@dunx/core";
-var PROTOCOLS = [
-  "redis:",
-  "rediss:",
-  "valkey:",
-  "valkeys:",
-  "redis+tls:",
-  "redis+unix:",
-  "redis+tls+unix:"
-];
-var defaultRelayUrl = () => process.env["VALKEY_URL"] ?? process.env["REDIS_URL"] ?? "redis://localhost:6379";
-var assertUrl = (url) => {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new AppError11(`${JSON.stringify(url)} is not a valid URL for the websocket relay. ` + "Expected something like redis://localhost:6379.");
-  }
-  if (!PROTOCOLS.includes(parsed.protocol)) {
-    throw new AppError11(`Unsupported protocol ${JSON.stringify(parsed.protocol)} in ` + `${JSON.stringify(url)}. Expected one of ${PROTOCOLS.join(", ")}.`);
-  }
-  return url;
-};
-
-class RedisRelay {
-  #url;
-  #options;
-  #pub;
-  #sub;
-  #channel;
-  constructor(options = {}) {
-    this.#url = assertUrl(options.url ?? defaultRelayUrl());
-    this.#options = {
-      maxRetries: options.maxRetries ?? 0,
-      ...options.connectionTimeout !== undefined && {
-        connectionTimeout: options.connectionTimeout
-      },
-      ...options.tls !== undefined && { tls: options.tls }
-    };
-  }
-  get url() {
-    const parsed = new URL(this.#url);
-    if (parsed.password)
-      parsed.password = "***";
-    return parsed.toString();
-  }
-  async publish(channel, message) {
-    const client = this.#pub ??= new Bun.RedisClient(this.#url, this.#options);
-    try {
-      return await client.publish(channel, message);
-    } catch (error) {
-      if (this.#pub === client) {
-        this.#pub = undefined;
-        client.close();
-      }
-      throw error;
-    }
-  }
-  async subscribe(channel, listener) {
-    const client = this.#sub ??= new Bun.RedisClient(this.#url, this.#options);
-    try {
-      await client.connect();
-      await client.subscribe(channel, listener);
-      this.#channel = channel;
-    } catch (error) {
-      if (this.#sub === client) {
-        this.#sub = undefined;
-        client.close();
-      }
-      throw error;
-    }
-  }
-  async close() {
-    const sub = this.#sub;
-    const channel = this.#channel;
-    this.#pub?.close();
-    this.#pub = undefined;
-    this.#sub = undefined;
-    this.#channel = undefined;
-    if (!sub)
-      return;
-    if (channel !== undefined) {
-      try {
-        await sub.unsubscribe(channel);
-      } catch {}
-    }
-    sub.close();
-  }
-}
-Object.defineProperty(RedisRelay, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "options: RedisRelayOptions = {}" }]
-});
 // src/health/contracts.ts
 class HealthIndicator {
   critical = true;
@@ -2168,205 +1335,6 @@ class PingProbe {
 
 class QueryProbe {
 }
-// src/health/controller.ts
-import { inject } from "@dunx/core";
-
-// src/health/report-schema.ts
-var state = {
-  type: "string",
-  enum: ["up", "down", "unknown"],
-  description: "`unknown` is not `down`: a probe that timed out has told you nothing."
-};
-var HEALTH_REPORT_SCHEMA = Object.freeze({
-  $id: "HealthReport",
-  type: "object",
-  description: "What the probe found. `up` answers 200 and anything else answers 503.",
-  properties: {
-    status: state,
-    draining: {
-      type: "boolean",
-      description: "The process is shutting down, or something holds it out."
-    },
-    uptimeMs: {
-      type: "integer",
-      description: "Measured on a monotonic clock, so it never goes backwards."
-    },
-    checks: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-          state,
-          critical: {
-            type: "boolean",
-            description: "A failure here sheds traffic. Memory and disk do not."
-          },
-          ms: { type: "integer", description: "How long the check took." },
-          detail: {
-            type: "string",
-            description: "A latency, a version, or a failure message."
-          }
-        },
-        required: ["name", "state", "critical", "ms"]
-      }
-    }
-  },
-  required: ["status", "draining", "uptimeMs", "checks"]
-});
-
-// src/health/registry.ts
-var bounded = async (indicator, timeoutMs) => {
-  let timer;
-  const timeout = new Promise((resolve2) => {
-    timer = setTimeout(() => resolve2({ state: "unknown", detail: `no answer in ${timeoutMs} ms` }), timeoutMs);
-    timer.unref?.();
-  });
-  try {
-    return await Promise.race([
-      Promise.resolve().then(() => indicator.check()).catch((error) => ({
-        state: "down",
-        detail: error instanceof Error ? error.message : String(error)
-      })),
-      timeout
-    ]);
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-  }
-};
-var worst = (checks) => {
-  const critical = checks.filter((check) => check.critical);
-  if (critical.some((check) => check.state === "down"))
-    return "down";
-  if (critical.some((check) => check.state === "unknown"))
-    return "unknown";
-  return "up";
-};
-
-class HealthOptions {
-  liveness;
-  readiness;
-  timeoutMs;
-  routes;
-  documented;
-  drainDelayMs;
-  constructor(init = {}) {
-    this.liveness = init.liveness ?? [];
-    this.readiness = init.readiness ?? [];
-    this.timeoutMs = init.timeoutMs ?? 2000;
-    this.routes = init.routes ?? true;
-    this.documented = init.documented ?? true;
-    this.drainDelayMs = Math.max(0, init.drainDelayMs ?? 0);
-  }
-}
-Object.defineProperty(HealthOptions, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "init: HealthOptionsInit = {}" }]
-});
-
-class HealthRegistry {
-  options;
-  readiness_;
-  #startedAt = performance.now();
-  constructor(options, readiness_) {
-    this.options = options;
-    this.readiness_ = readiness_;
-  }
-  async report(indicators) {
-    const checks = await Promise.all(indicators.map(async (indicator) => {
-      const started = performance.now();
-      const result = await bounded(indicator, this.options.timeoutMs);
-      return {
-        name: indicator.name,
-        state: result.state,
-        critical: indicator.critical,
-        ms: Math.round(performance.now() - started),
-        ...result.detail === undefined ? {} : { detail: result.detail }
-      };
-    }));
-    return {
-      status: worst(checks),
-      draining: this.readiness_.draining,
-      uptimeMs: Math.round(performance.now() - this.#startedAt),
-      checks
-    };
-  }
-  liveness() {
-    return this.report(this.options.liveness);
-  }
-  async readiness() {
-    const report = await this.report(this.options.readiness);
-    if (!this.readiness_.draining)
-      return report;
-    return {
-      ...report,
-      status: "down",
-      checks: [
-        {
-          name: "readiness",
-          state: "down",
-          critical: true,
-          ms: 0,
-          detail: this.readiness_.reason ?? "not accepting traffic"
-        },
-        ...report.checks
-      ]
-    };
-  }
-}
-Object.defineProperty(HealthRegistry, Symbol.for("dunx.deps"), {
-  value: () => [HealthOptions, { unresolved: "private readonly readiness_: Readiness", typeOnly: "Readiness" }]
-});
-
-// src/health/controller.ts
-var probeResponses = {
-  response: { 200: HEALTH_REPORT_SCHEMA, 503: HEALTH_REPORT_SCHEMA }
-};
-var answer = (report) => Response.json(report, { status: report.status === "up" ? 200 : 503 });
-var _dec = [
-  Controller("health")
-];
-var _dec2 = [
-  Public(),
-  Get("/live", probeResponses)
-];
-var _dec3 = [
-  Public(),
-  Get("/ready", probeResponses)
-];
-var _health = new WeakMap;
-var _init = __decoratorStart(undefined);
-
-class HealthController {
-  constructor() {
-    __privateAdd(this, _health, inject(HealthRegistry));
-    __runInitializers(_init, 5, this);
-  }
-  async live() {
-    return answer(await __privateGet(this, _health).liveness());
-  }
-  async ready() {
-    return answer(await __privateGet(this, _health).readiness());
-  }
-}
-__decorateElement(_init, 1, "live", _dec2, HealthController);
-__decorateElement(_init, 1, "ready", _dec3, HealthController);
-HealthController = __decorateElement(_init, 0, "HealthController", _dec, HealthController);
-__runInitializers(_init, 1, HealthController);
-__decoratorMetadata(_init, HealthController);
-let _HealthController = HealthController;
-var _dec = [
-  ApiHidden()
-];
-var _base = HealthController;
-var _init = __decoratorStart(_base);
-
-class HiddenHealthController extends _base {
-}
-HiddenHealthController = __decorateElement(_init, 0, "HiddenHealthController", _dec, HiddenHealthController);
-__runInitializers(_init, 1, HiddenHealthController);
-__decoratorMetadata(_init, HiddenHealthController);
-let _HiddenHealthController = HiddenHealthController;
 // src/health/indicators.ts
 import { statfs } from "fs/promises";
 var ms = (started) => Math.round(performance.now() - started);
@@ -2384,9 +1352,7 @@ class RedisIndicator extends HealthIndicator {
     return { state: "up", detail: `${ms(started)} ms` };
   }
 }
-Object.defineProperty(RedisIndicator, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "private readonly redis: PingProbe", typeOnly: "PingProbe" }]
-});
+Object.defineProperty(RedisIndicator, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "private readonly redis: PingProbe", typeOnly: "PingProbe" }] });
 
 class DatabaseIndicator extends HealthIndicator {
   db;
@@ -2401,9 +1367,7 @@ class DatabaseIndicator extends HealthIndicator {
     return { state: "up", detail: `${ms(started)} ms` };
   }
 }
-Object.defineProperty(DatabaseIndicator, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "private readonly db: QueryProbe", typeOnly: "QueryProbe" }]
-});
+Object.defineProperty(DatabaseIndicator, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "private readonly db: QueryProbe", typeOnly: "QueryProbe" }] });
 
 class MemoryOptions {
   maxRssBytes;
@@ -2411,9 +1375,7 @@ class MemoryOptions {
     this.maxRssBytes = init.maxRssBytes;
   }
 }
-Object.defineProperty(MemoryOptions, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "init: MemoryOptionsInit" }]
-});
+Object.defineProperty(MemoryOptions, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "init: MemoryOptionsInit" }] });
 var MIB = 1024 * 1024;
 var mib = (bytes) => `${Math.round(bytes / MIB)} MiB`;
 
@@ -2431,9 +1393,7 @@ class MemoryIndicator extends HealthIndicator {
     return rss > this.options.maxRssBytes ? { state: "down", detail } : { state: "up", detail };
   }
 }
-Object.defineProperty(MemoryIndicator, Symbol.for("dunx.deps"), {
-  value: () => [MemoryOptions]
-});
+Object.defineProperty(MemoryIndicator, Symbol.for("dunx.deps"), { value: () => [MemoryOptions] });
 
 class DiskOptions {
   path;
@@ -2443,9 +1403,7 @@ class DiskOptions {
     this.maxUsedFraction = init.maxUsedFraction;
   }
 }
-Object.defineProperty(DiskOptions, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "init: DiskOptionsInit" }]
-});
+Object.defineProperty(DiskOptions, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "init: DiskOptionsInit" }] });
 
 class DiskIndicator extends HealthIndicator {
   options;
@@ -2466,13 +1424,11 @@ class DiskIndicator extends HealthIndicator {
     return used > this.options.maxUsedFraction ? { state: "down", detail } : { state: "up", detail };
   }
 }
-Object.defineProperty(DiskIndicator, Symbol.for("dunx.deps"), {
-  value: () => [DiskOptions]
-});
+Object.defineProperty(DiskIndicator, Symbol.for("dunx.deps"), { value: () => [DiskOptions] });
 // src/health/module.ts
 import {
-  Module as Module3,
-  provide as provide4
+  Module as Module4,
+  provide as provide5
 } from "@dunx/core";
 
 // src/health/readiness.ts
@@ -2482,9 +1438,7 @@ class ReadinessOptions {
     this.drainDelayMs = Math.max(0, init.drainDelayMs ?? 0);
   }
 }
-Object.defineProperty(ReadinessOptions, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "init: ReadinessOptionsInit = {}" }]
-});
+Object.defineProperty(ReadinessOptions, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "init: ReadinessOptionsInit = {}", optional: true }] });
 
 class Readiness {
   options;
@@ -2512,22 +1466,20 @@ class Readiness {
     }
   }
 }
-Object.defineProperty(Readiness, Symbol.for("dunx.deps"), {
-  value: () => [ReadinessOptions]
-});
+Object.defineProperty(Readiness, Symbol.for("dunx.deps"), { value: () => [ReadinessOptions] });
 
 // src/health/module.ts
 var wiring = (options) => [
   ...options,
-  provide4(ReadinessOptions, {
+  provide5(ReadinessOptions, {
     useFactory: (opts) => new ReadinessOptions({ drainDelayMs: opts.drainDelayMs }),
     inject: [HealthOptions]
   }),
-  provide4(Readiness, {
+  provide5(Readiness, {
     useFactory: (opts) => new Readiness(opts),
     inject: [ReadinessOptions]
   }),
-  provide4(HealthRegistry, {
+  provide5(HealthRegistry, {
     useFactory: (opts, readiness) => new HealthRegistry(opts, readiness),
     inject: [HealthOptions, Readiness]
   })
@@ -2535,7 +1487,7 @@ var wiring = (options) => [
 var surface = [HealthOptions, HealthRegistry, Readiness];
 var controllerFor = (documented) => documented ? HealthController : HiddenHealthController;
 var _dec = [
-  Module3({})
+  Module4({})
 ];
 var _init = __decoratorStart(undefined);
 
@@ -2546,7 +1498,7 @@ class HealthModule {
       module: HealthModule,
       ...options.routes ? { controllers: [controllerFor(options.documented)] } : {},
       exports: surface,
-      providers: wiring([provide4(HealthOptions, { useValue: options })])
+      providers: wiring([provide5(HealthOptions, { useValue: options })])
     };
   }
   static forRootAsync(config) {
@@ -2556,7 +1508,7 @@ class HealthModule {
       ...config.routes ?? true ? { controllers: [controllerFor(config.documented ?? true)] } : {},
       exports: surface,
       providers: wiring([
-        provide4(HealthOptions, {
+        provide5(HealthOptions, {
           useFactory: async (...deps) => new HealthOptions(await config.useFactory(...deps)),
           inject: config.inject ?? []
         })
@@ -2571,6 +1523,10 @@ let _HealthModule = HealthModule;
 export {
   ApiHidden,
   ClientAddress,
+  Compression,
+  CompressionEncoding,
+  CompressionModule,
+  CompressionOptions,
   Controller,
   DEFAULT_RELAY_CHANNEL,
   DatabaseIndicator,
@@ -2626,11 +1582,14 @@ export {
   StaticModule,
   StaticOptions,
   THROTTLE,
+  TRACEPARENT_HEADER,
+  TRACESTATE_HEADER,
   Throttle,
   ThrottleGuard,
   ThrottleModule,
   ThrottleOptions,
   ThrottleStore,
+  TraceContext,
   UNMATCHED,
   UseGuards,
   ValidationError,
@@ -2647,6 +1606,7 @@ export {
   decodeRelay,
   defaultErrorMapper,
   defaultRelayUrl,
+  defaultStatusFor,
   discoverGateway,
   discoverGateways,
   discoverRoutes,
@@ -2655,6 +1615,7 @@ export {
   errorMapper,
   gatewaysOf,
   guardsOf,
+  isCompressibleType,
   isErrorFilter,
   isGateway,
   joinPath,
@@ -2662,6 +1623,7 @@ export {
   meta,
   metaKey,
   metaOf,
+  negotiate,
   normalizePath,
   normalizePrefix,
   observe,
@@ -2671,6 +1633,3 @@ export {
   withCors,
   withUpgradeRoutes
 };
-
-//# debugId=1A8278039B82BC0664756E2164756E21
-//# sourceMappingURL=index.js.map