@dunx/http 2.4.0 → 3.0.0

package/dist/chunk-ywdpxbkf.js

@@ -0,0 +1,1573 @@
+// @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
+});
+
+// src/route/marker.ts
+var ROUTE = Symbol.for("dunx.route");
+var CONTROLLER = Symbol.for("dunx.controller");
+var defaultStatusFor = (method) => method === "POST" ? HttpStatusCode.CREATED : HttpStatusCode.OK;
+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/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)));
+// 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 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 }
+    });
+  }
+  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];
+  }
+}
+
+// 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 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);
+    }
+  };
+  return cors ? withCors(cors, run) : run;
+};
+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);
+    }
+  };
+  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;
+};
+// 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/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, then2) => {
+  if (result instanceof Promise) {
+    result.then((value) => {
+      if (!then2)
+        return;
+      try {
+        then2(value);
+      } catch (error) {
+        onError(error, socket);
+      }
+    }, (error) => onError(error, socket));
+    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
+  };
+  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, then2) => {
+    try {
+      settle(invoke(...args), ws, onError, then2);
+    } 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 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 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()]
+    }))
+  };
+};
+// src/ws/redis-relay.ts
+import { AppError as AppError5 } 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 AppError5(`${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 AppError5(`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 = {}", 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 = {
+  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((resolve) => {
+    timer = setTimeout(() => resolve({ 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 = {}", optional: true }] });
+
+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/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 };