@dunx/http 3.0.0 → 3.0.1

package/dist/{chunk-ywdpxbkf.js → chunk-f6pw36av.js}

@@ -1,112 +1,13 @@
 // @bun
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __name = (target, name) => {
-  Object.defineProperty(target, "name", {
-    value: name,
-    enumerable: false,
-    configurable: true
-  });
-  return target;
-};
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
-var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
-var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name, done, metadata, fns) => ({
-  kind: __decoratorStrings[kind],
-  name,
-  metadata,
-  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
-});
-var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
-var __runInitializers = (array, flags, self, value) => {
-  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
-    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
-  return value;
-};
-var __decorateElement = (array, flags, name, decorators, target, extra) => {
-  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
-  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
-  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
-  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
-    get [name]() {
-      return __privateGet(this, extra);
-    },
-    set [name](x) {
-      __privateSet(this, extra, x);
-    }
-  }, name));
-  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
-  for (var i = decorators.length - 1;i >= 0; i--) {
-    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
-    if (k) {
-      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
-      if (k ^ 3)
-        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
-      if (k > 2)
-        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
-    }
-    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
-    done._ = 1;
-    if (k ^ 4 || it === undefined)
-      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
-    else if (typeof it !== "object" || it === null)
-      __typeError("Object expected");
-    else
-      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
-  }
-  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
-};
-
-// src/route/discover.ts
-import { markedMethods } from "@dunx/core";
-
-// src/server/status.ts
-var HttpStatusCode = Object.freeze({
-  OK: 200,
-  CREATED: 201,
-  ACCEPTED: 202,
-  NO_CONTENT: 204,
-  MOVED_PERMANENTLY: 301,
-  FOUND: 302,
-  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,
-  REQUEST_TIMEOUT: 408,
-  CONFLICT: 409,
-  GONE: 410,
-  PRECONDITION_FAILED: 412,
-  PAYLOAD_TOO_LARGE: 413,
-  URI_TOO_LONG: 414,
-  UNSUPPORTED_MEDIA_TYPE: 415,
-  IM_A_TEAPOT: 418,
-  UNPROCESSABLE_ENTITY: 422,
-  TOO_MANY_REQUESTS: 429,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504
-});
+import {
+  HttpStatusCode,
+  __decorateElement,
+  __decoratorMetadata,
+  __decoratorStart,
+  __privateAdd,
+  __privateGet,
+  __runInitializers
+} from "./chunk-sz4pvqxy.js";
 
 // src/route/marker.ts
 var ROUTE = Symbol.for("dunx.route");
@@ -125,6 +26,21 @@ var markController = (target, prefix) => {
 };
 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/metadata.ts
 var META = Symbol.for("dunx.meta");
 var GUARDS = Symbol.for("dunx.guards");
@@ -170,7 +86,59 @@ var mergeMeta = (...targets) => {
   return merged;
 };
 
+// src/server/errors.ts
+import { AppError, ConsoleLogger } from "@dunx/core";
+class HttpError extends AppError {
+  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/route/discover.ts
+import { markedMethods } from "@dunx/core";
 var joinPath = (prefix, path) => {
   const joined = `/${prefix}/${path}`.replace(/\/{2,}/g, "/");
   return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
@@ -192,19 +160,23 @@ var discoverRoutes = (instance) => {
     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/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/marker.ts
 var HANDLER = Symbol.for("dunx.ws.handler");
@@ -228,607 +200,345 @@ var markGateway = (target, path) => {
 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(/\/$/, "") : "/";
+// 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;
 };
-var eachHandler = (start) => markedMethods2(start, handlerMetaOf);
-var discoverGateway = (instance) => {
-  const klass = instance.constructor;
-  const members = instance;
+
+// src/ws/runtime.ts
+import { AppError as AppError2 } 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 AppError2(`${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 AppError2(`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: 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)
-    }))
+    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 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.");
-      }
+var buildGateways = (discovered) => {
+  const byPath = new Map;
+  for (const gateway of discovered) {
+    const existing = byPath.get(gateway.path);
+    if (existing) {
+      throw new AppError2(`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 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 }
-  };
+  return byPath;
 };
-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 someHandler = (gateways, pick) => {
+  for (const gateway of gateways)
+    if (pick(gateway) !== undefined)
+      return true;
+  return false;
 };
-var classOf2 = (entry) => {
-  if (typeof entry === "function")
-    return entry;
-  return entry.provider.kind === "class" ? entry.provider.ctor : undefined;
+
+// 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 gatewaysOf = (root) => collectModules(root).flatMap((module) => (module.options.providers ?? []).map(classOf2).filter((ctor) => ctor !== undefined).filter(isGateway).map((ctor) => gatewayFor(ctor, module.name)));
-// 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)
-  });
+var reportedByMiddleware = () => {
+  return;
 };
-// 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)
+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;
-  const allowed = typeof origin === "function" ? origin(requested) : origin.includes(requested);
-  return allowed ? requested : undefined;
+  socket.send(typeof value === "string" || isBinary(value) ? value : JSON.stringify(value));
 };
-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(", "));
+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;
   }
-  return response;
+  if (then)
+    then(result);
 };
-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 AppError2, ConsoleLogger } from "@dunx/core";
-class HttpError extends AppError2 {
-  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 }
+var framing = (kind) => {
+  if (kind === HandlerKind.CLOSE) {
+    return (args) => ({
+      socket: args[0],
+      data: { code: args[1], reason: args[2] }
     });
   }
-  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/middleware.ts
-var compose = (middleware, ctx, handler) => middleware.reduceRight((next, current) => (req) => current.handle(req, ctx, () => next(req)), handler);
-// src/server/routes.ts
-import { AppError as AppError3 } 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];
+  if (kind === HandlerKind.OPEN || kind === HandlerKind.DRAIN) {
+    return (args) => ({ socket: args[0], data: undefined });
   }
-}
-
-// 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;
+  return (args) => ({ socket: args[1], data: args[0] });
 };
-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;
+var NOTHING = () => {
   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 parse = parserFor(media);
-  if (parse === 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 = parse === asJson && RawBody.wanted(draft.req) ? draft.req.text().then((text) => {
-    RawBody.record(draft.req, text);
-    return JSON.parse(text);
-  }) : parse(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/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/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 ?? defaultStatusFor(route.method);
-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 AppError3(`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 AppError3(`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);
-    }
+var through = (gateway, middleware, kind, event, invoke) => {
+  const ctx = {
+    gateway: gateway.name,
+    path: gateway.path,
+    kind,
+    event
   };
-  return cors ? withCors(cors, run) : run;
+  const dispatch = composeSocket(middleware, ctx);
+  const frameOf = framing(kind);
+  const run = invoke ?? NOTHING;
+  return (...args) => dispatch(frameOf(args), () => run(...args));
 };
-var directOr = (guarded, route, read, status, onError, noMiddleware) => {
-  if (!noMiddleware)
-    return guarded;
-  const settle = (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) => settle(resolved, req), (error) => onError(error, req)) : settle(value, req);
-    } catch (error) {
-      return onError(error, req);
-    }
+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)
+    ]))
   };
-  return (req) => {
+};
+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 {
-      const input = read(req);
-      return input instanceof Promise ? input.then((resolved) => invoke(resolved, req), (error) => onError(error, req)) : invoke(input, req);
+      settle(invoke(...args), ws, onError, then);
     } catch (error) {
-      return onError(error, req);
+      onError(error, ws);
     }
   };
-};
-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) => {
+  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 {
-        return await chained(req);
+        settle(unclaimed2({ socket: ws, data: message }, event), ws, onError, undefined);
       } catch (error) {
-        return RequestIds.stamp(onError(error, req), req);
+        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 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;
-};
-// 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/compression/negotiate.ts
-var quality = (params) => {
-  for (const param of params) {
-    const [key, value] = param.split("=");
-    if (key?.trim().toLowerCase() !== "q")
-      continue;
-    const q = Number.parseFloat(value ?? "");
-    return Number.isFinite(q) && q >= 0 && q <= 1 ? q : 1;
-  }
-  return 1;
-};
-var negotiate = (header, offered) => {
-  if (header === null)
-    return;
-  const accepted = new Map;
-  for (const element of header.split(",")) {
-    const [name, ...params] = element.split(";");
-    const token = name?.trim().toLowerCase();
-    if (token === undefined || token === "")
-      continue;
-    accepted.set(token, quality(params));
-  }
-  const wildcard = accepted.get("*");
-  let best;
-  let bestQuality = 0;
-  for (const encoding of offered) {
-    const q = accepted.get(encoding) ?? wildcard ?? 0;
-    if (q > bestQuality) {
-      best = encoding;
-      bestQuality = q;
+  };
+  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 best;
+    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/compression/options.ts
-var CompressionEncoding = Object.freeze({
-  ZSTD: "zstd",
-  GZIP: "gzip"
-});
-var COMPRESSIBLE = new Set([
-  "application/graphql",
-  "application/graphql-response+json",
-  "application/javascript",
-  "application/json",
-  "application/manifest+json",
-  "application/wasm",
-  "application/x-javascript",
-  "application/x-ndjson",
-  "application/xml",
-  "image/svg+xml"
-]);
-var isCompressibleType = (contentType) => {
-  if (contentType === null)
-    return false;
-  const type = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
-  if (type.startsWith("text/"))
-    return true;
-  if (type.endsWith("+json") || type.endsWith("+xml"))
-    return true;
-  return COMPRESSIBLE.has(type);
+
+// src/ws/discover.ts
+import {
+  AppError as AppError3,
+  classOf,
+  markedMethods as markedMethods2
+} from "@dunx/core";
+var normalizePath = (path) => {
+  const joined = `/${path}`.replace(/\/{2,}/g, "/");
+  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
 };
-var encodable = (encoding) => {
-  const sync = encoding === CompressionEncoding.ZSTD ? Bun.zstdCompressSync : Bun.gzipSync;
-  if (typeof sync !== "function")
-    return false;
-  try {
-    new CompressionStream(encoding);
-    return true;
-  } catch {
-    return false;
-  }
+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)
+    }))
+  };
 };
-
-class CompressionOptions {
-  encodings;
-  threshold;
-  filter;
-  constructor(init = {}) {
-    this.encodings = init.encodings ?? [
-      CompressionEncoding.ZSTD,
-      CompressionEncoding.GZIP
-    ];
-    const missing = this.encodings.filter((encoding) => !encodable(encoding));
-    if (missing.length > 0) {
-      throw new Error(`Bun ${Bun.version} cannot encode ${missing.join(", ")}. ` + "Pass `encodings` without it, or upgrade Bun.");
+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 AppError3(`${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.");
+      }
     }
-    this.threshold = init.threshold ?? 1024;
-    this.filter = init.filter ?? isCompressibleType;
   }
-}
-Object.defineProperty(CompressionOptions, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "init: CompressionOptionsInit = {}", optional: true }] });
-// src/ws/envelope.ts
-var encode = (event, data) => JSON.stringify({ event, data });
-var decode = (message) => {
-  if (typeof message !== "string")
-    return;
+  return discovered;
+};
+
+// 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);
@@ -837,289 +547,469 @@ var decode = (message) => {
   }
   if (typeof parsed !== "object" || parsed === null)
     return;
-  const { event, data } = parsed;
-  return typeof event === "string" ? { event, data } : undefined;
+  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 };
 };
 
-// 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;
+// 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/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/middleware.ts
+var compose = (middleware, ctx, handler) => middleware.reduceRight((next, current) => (req) => current.handle(req, ctx, () => next(req)), handler);
+
+// src/server/routes.ts
+import { AppError as AppError4 } 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/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((value) => {
-      done(undefined, value);
-      return value;
-    }, (error) => {
-      done(error, undefined);
-      throw error;
+    return result.then((settled) => {
+      draft[source] = accept(source, settled);
+      return draft;
     });
   }
-  done(undefined, result);
-  return result;
+  draft[source] = accept(source, result);
+  return draft;
+};
+var bodyFill = (schema) => (draft) => {
+  const media = mediaTypeOf(draft.req);
+  const parse = parserFor(media);
+  if (parse === 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 = parse === asJson && RawBody.wanted(draft.req) ? draft.req.text().then((text) => {
+    RawBody.record(draft.req, text);
+    return JSON.parse(text);
+  }) : parse(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/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.");
+// 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 ?? defaultStatusFor(route.method);
+var assertNoCollisions = (discovered) => {
   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);
+  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 AppError4(`Route collision: ${key} is declared by ${existing} and by ${owner}. ` + "Bun would keep only one of them.");
     }
+    owners.set(key, owner);
   }
-  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.`);
+var assertNoGatewayCollisions = (discovered, gatewayPaths) => {
+  const gateways = new Set(gatewayPaths);
+  for (const route of discovered) {
+    if (gateways.has(route.path)) {
+      throw new AppError4(`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.");
     }
-    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 withUpgradeRoutes = (routes, gateways) => {
+  const merged = { ...routes };
+  for (const [path, upgrade] of gateways)
+    merged[path] = { GET: upgrade };
+  return merged;
 };
-var settle = (result, socket, onError, then2) => {
-  if (result instanceof Promise) {
-    result.then((value) => {
-      if (!then2)
-        return;
-      try {
-        then2(value);
-      } catch (error) {
-        onError(error, socket);
-      }
-    }, (error) => onError(error, socket));
+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;
   }
-  if (then2)
-    then2(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
+});
+var buildFallback = (middleware = [], onError = defaultErrorMapper, cors, notFound = "guarded") => {
+  const miss = () => {
+    throw new HttpError(HttpStatusCode.NOT_FOUND, "NOT_FOUND");
   };
-  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)
-    ]))
+  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 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, then2) => {
+var directOr = (guarded, route, read, status, onError, noMiddleware) => {
+  if (!noMiddleware)
+    return guarded;
+  const settle2 = (value, req) => {
     try {
-      settle(invoke(...args), ws, onError, then2);
+      return toResponse(value, status);
     } catch (error) {
-      onError(error, ws);
+      return onError(error, req);
     }
   };
-  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 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);
     }
   };
-  const unclaimed = new Map(middleware.length === 0 ? [] : gateways.map((gateway) => [
-    gateway,
-    unclaimedDispatch(gateway, middleware)
-  ]));
-  const accept2 = (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 accept2(req, server, gateway, undefined);
-    const result = gateway.upgrade(req);
-    if (result instanceof Promise) {
-      return result.then((value) => value instanceof Response ? value : accept2(req, server, gateway, value));
+  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);
     }
-    return result instanceof Response ? result : accept2(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()]
-    }))
+};
+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;
+};
+
+// 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/compression/negotiate.ts
+var quality = (params) => {
+  for (const param of params) {
+    const [key, value] = param.split("=");
+    if (key?.trim().toLowerCase() !== "q")
+      continue;
+    const q = Number.parseFloat(value ?? "");
+    return Number.isFinite(q) && q >= 0 && q <= 1 ? q : 1;
+  }
+  return 1;
+};
+var negotiate = (header, offered) => {
+  if (header === null)
+    return;
+  const accepted = new Map;
+  for (const element of header.split(",")) {
+    const [name, ...params] = element.split(";");
+    const token = name?.trim().toLowerCase();
+    if (token === undefined || token === "")
+      continue;
+    accepted.set(token, quality(params));
+  }
+  const wildcard = accepted.get("*");
+  let best;
+  let bestQuality = 0;
+  for (const encoding of offered) {
+    const q = accepted.get(encoding) ?? wildcard ?? 0;
+    if (q > bestQuality) {
+      best = encoding;
+      bestQuality = q;
+    }
+  }
+  return best;
+};
+
+// src/compression/options.ts
+var CompressionEncoding = Object.freeze({
+  ZSTD: "zstd",
+  GZIP: "gzip"
+});
+var COMPRESSIBLE = new Set([
+  "application/graphql",
+  "application/graphql-response+json",
+  "application/javascript",
+  "application/json",
+  "application/manifest+json",
+  "application/wasm",
+  "application/x-javascript",
+  "application/x-ndjson",
+  "application/xml",
+  "image/svg+xml"
+]);
+var isCompressibleType = (contentType) => {
+  if (contentType === null)
+    return false;
+  const type = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  if (type.startsWith("text/"))
+    return true;
+  if (type.endsWith("+json") || type.endsWith("+xml"))
+    return true;
+  return COMPRESSIBLE.has(type);
+};
+var encodable = (encoding) => {
+  const sync = encoding === CompressionEncoding.ZSTD ? Bun.zstdCompressSync : Bun.gzipSync;
+  if (typeof sync !== "function")
+    return false;
+  try {
+    new CompressionStream(encoding);
+    return true;
+  } catch {
+    return false;
+  }
 };
+
+class CompressionOptions {
+  encodings;
+  threshold;
+  filter;
+  constructor(init = {}) {
+    this.encodings = init.encodings ?? [
+      CompressionEncoding.ZSTD,
+      CompressionEncoding.GZIP
+    ];
+    const missing = this.encodings.filter((encoding) => !encodable(encoding));
+    if (missing.length > 0) {
+      throw new Error(`Bun ${Bun.version} cannot encode ${missing.join(", ")}. ` + "Pass `encodings` without it, or upgrade Bun.");
+    }
+    this.threshold = init.threshold ?? 1024;
+    this.filter = init.filter ?? isCompressibleType;
+  }
+}
+Object.defineProperty(CompressionOptions, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "init: CompressionOptionsInit = {}", optional: true }] });
+
 // src/ws/redis-relay.ts
 import { AppError as AppError5 } from "@dunx/core";
 var PROTOCOLS = [
@@ -1211,50 +1101,6 @@ class RedisRelay {
   }
 }
 Object.defineProperty(RedisRelay, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "options: RedisRelayOptions = {}", optional: true }] });
-// 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 };
-};
-// src/health/controller.ts
-import { inject } from "@dunx/core";
-
-// 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/health/report-schema.ts
 var state = {
@@ -1400,6 +1246,7 @@ class HealthRegistry {
 Object.defineProperty(HealthRegistry, Symbol.for("dunx.deps"), { value: () => [HealthOptions, { unresolved: "private readonly readiness_: Readiness", typeOnly: "Readiness" }] });
 
 // src/health/controller.ts
+import { inject } from "@dunx/core";
 var probeResponses = {
   response: { 200: HEALTH_REPORT_SCHEMA, 503: HEALTH_REPORT_SCHEMA }
 };
@@ -1448,126 +1295,5 @@ HiddenHealthController = __decorateElement(_init, 0, "HiddenHealthController", _
 __runInitializers(_init, 1, HiddenHealthController);
 __decoratorMetadata(_init, HiddenHealthController);
 let _HiddenHealthController = HiddenHealthController;
-// src/client/errors.ts
-import { AppError as AppError6 } from "@dunx/core";
-
-class FetchError extends AppError6 {
-  status;
-  statusText;
-  body;
-  response;
-  name = "FetchError";
-  constructor(status, statusText, body, response) {
-    super(`HTTP ${status} ${statusText} from ${response.method} ${response.url}`);
-    this.status = status;
-    this.statusText = statusText;
-    this.body = body;
-    this.response = response;
-  }
-}
-Object.defineProperty(FetchError, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "readonly status: number" }, { unresolved: "readonly statusText: string" }, { unresolved: "readonly body: unknown" }, { unresolved: `readonly response: {
-      readonly method: string;
-      readonly url: string;
-      readonly headers: Headers;
-    }` }] });
-
-class FetchTransportError extends AppError6 {
-  response;
-  aborted;
-  name = "FetchTransportError";
-  constructor(response, aborted, options) {
-    super(`${response.method} ${response.url} failed: ${aborted ? "aborted" : "transport error"}`, options);
-    this.response = response;
-    this.aborted = aborted;
-  }
-}
-Object.defineProperty(FetchTransportError, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "readonly response: { readonly method: string; readonly url: string }" }, { unresolved: "readonly aborted: boolean" }, ErrorOptions] });
 
-// src/client/retry.ts
-var uniform = () => {
-  const buffer = new Uint32Array(1);
-  crypto.getRandomValues(buffer);
-  return (buffer[0] ?? 0) / 2 ** 32;
-};
-var backoffDelay = (attempt, { baseMs, power = 2, jitterMs = 1000, maxMs = 30000 }) => Math.min(baseMs * power ** attempt + uniform() * jitterMs, maxMs);
-var retryAfterMs = (headers, now = Date.now()) => {
-  const header = headers.get("retry-after");
-  if (header === null)
-    return;
-  const seconds = Number(header);
-  if (Number.isFinite(seconds))
-    return Math.max(0, seconds * 1000);
-  const at = Date.parse(header);
-  return Number.isNaN(at) ? undefined : Math.max(0, at - now);
-};
-var isRetryableStatus = (status) => status >= HttpStatusCode.INTERNAL_SERVER_ERROR || status === HttpStatusCode.REQUEST_TIMEOUT || status === HttpStatusCode.TOO_MANY_REQUESTS;
-var decide = (error, attempt, options) => {
-  const {
-    retryDelayMs = 1000,
-    backoff,
-    shouldRetryOnStatus = isRetryableStatus,
-    respectRetryAfter = true
-  } = options;
-  const computed = backoffDelay(attempt, { baseMs: retryDelayMs, ...backoff });
-  if (error instanceof FetchTransportError) {
-    return { retry: !error.aborted, delayMs: computed };
-  }
-  if (error instanceof FetchError) {
-    if (!shouldRetryOnStatus(error.status))
-      return { retry: false, delayMs: 0 };
-    const asked = respectRetryAfter ? retryAfterMs(error.response.headers) : undefined;
-    const maxMs = backoff?.maxMs ?? 30000;
-    return {
-      retry: true,
-      delayMs: asked === undefined ? computed : Math.min(asked, maxMs)
-    };
-  }
-  return { retry: true, delayMs: computed };
-};
-var executeWithRetry = async (operation, options = {}) => {
-  const { maxRetries = 3, onAttempt, onError, onSuccess } = options;
-  let lastError;
-  for (let attempt = 0;attempt <= maxRetries; attempt += 1) {
-    onAttempt?.(attempt + 1, attempt > 0);
-    try {
-      const result = await operation();
-      onSuccess?.(result, attempt + 1);
-      return result;
-    } catch (error) {
-      lastError = error;
-      const { retry, delayMs } = decide(error, attempt, options);
-      const willRetry = retry && attempt < maxRetries;
-      onError?.(error, attempt + 1, willRetry);
-      if (!willRetry)
-        throw error;
-      await Bun.sleep(delayMs);
-    }
-  }
-  throw lastError;
-};
-// src/client/json.ts
-var safeStringify = (value) => {
-  const seen = new WeakSet;
-  return JSON.stringify(value, (_key, entry) => {
-    if (typeof entry === "object" && entry !== null) {
-      if (seen.has(entry))
-        return "[Circular]";
-      seen.add(entry);
-    }
-    return entry;
-  });
-};
-var isPlainObject = (value) => {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-};
-var isJsonBody = (payload) => {
-  if (payload === null || payload === undefined)
-    return false;
-  if (typeof payload !== "object")
-    return typeof payload !== "string";
-  return !(payload instanceof FormData || payload instanceof URLSearchParams || payload instanceof Blob || payload instanceof ArrayBuffer || payload instanceof ReadableStream || ArrayBuffer.isView(payload));
-};
-export { __decoratorStart, __decoratorMetadata, __runInitializers, __decorateElement, HttpStatusCode, defaultStatusFor, Controller, Get, Post, Put, Patch, Delete, metaKey, meta, ROLES, PUBLIC, HIDDEN, UNMATCHED, Roles, Public, ApiHidden, UseGuards, guardsOf, metaOf, mergeMeta, HttpError, ValidationError, ErrorFilter, isErrorFilter, toErrorMapper, errorMapper, defaultErrorMapper, joinPath, discoverRoutes, encode, decode, HandlerKind, markHandler, markGateway, isGateway, composeSocket, observe, buildRuntime, buildGateways, buildWebSocket, normalizePath, discoverGateway, discoverGateways, DEFAULT_RELAY_CHANNEL, defaultRelayError, encodeRelay, decodeRelay, RawBody, REQUEST_ID_HEADER, RequestIds, buildContext, withCors, preflight, compose, assertNoCollisions, assertNoGatewayCollisions, withUpgradeRoutes, buildFallback, buildRoutes, StaticOptions, normalizePrefix, negotiate, CompressionEncoding, isCompressibleType, CompressionOptions, defaultRelayUrl, RedisRelay, HEALTH_REPORT_SCHEMA, HealthOptions, HealthRegistry, HealthController, HiddenHealthController, routesOf, gatewaysOf, FetchError, FetchTransportError, backoffDelay, retryAfterMs, isRetryableStatus, executeWithRetry, safeStringify, isPlainObject, isJsonBody };
+export { defaultStatusFor, Controller, Get, Post, Put, Patch, Delete, metaKey, meta, ROLES, PUBLIC, HIDDEN, UNMATCHED, Roles, Public, ApiHidden, UseGuards, guardsOf, metaOf, mergeMeta, HttpError, ValidationError, ErrorFilter, isErrorFilter, toErrorMapper, errorMapper, defaultErrorMapper, joinPath, discoverRoutes, encode, decode, HandlerKind, markHandler, markGateway, isGateway, composeSocket, observe, buildRuntime, buildGateways, buildWebSocket, normalizePath, discoverGateway, discoverGateways, DEFAULT_RELAY_CHANNEL, defaultRelayError, encodeRelay, decodeRelay, RawBody, REQUEST_ID_HEADER, RequestIds, buildContext, withCors, preflight, compose, assertNoCollisions, assertNoGatewayCollisions, withUpgradeRoutes, buildFallback, buildRoutes, StaticOptions, normalizePrefix, negotiate, CompressionEncoding, isCompressibleType, CompressionOptions, defaultRelayUrl, RedisRelay, HEALTH_REPORT_SCHEMA, HealthOptions, HealthRegistry, HealthController, HiddenHealthController };