@dunx/http 3.2.0 → 3.3.0

package/dist/chunk-y85wcdhw.js

@@ -1,1297 +0,0 @@
-// @bun
-import {
-  HttpStatusCode,
-  TraceContext,
-  __decorateElement,
-  __decoratorMetadata,
-  __decoratorStart,
-  __privateAdd,
-  __privateGet,
-  __runInitializers
-} from "./chunk-9x3evk19.js";
-
-// 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/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");
-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/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: "override 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 }
-    });
-  }
-  if (error instanceof AppError && isStatus(error.status)) {
-    if (error.status >= HttpStatusCode.INTERNAL_SERVER_ERROR) {
-      logger.error("Unhandled error", error);
-    }
-    return Response.json({ error: error.message, status: error.status }, { status: error.status });
-  }
-  logger.error("Unhandled error", error);
-  return Response.json({
-    error: "Internal Server Error",
-    status: HttpStatusCode.INTERNAL_SERVER_ERROR
-  }, { status: HttpStatusCode.INTERNAL_SERVER_ERROR });
-};
-var isStatus = (value) => value !== undefined && Number.isInteger(value) && value >= 200 && value <= 599;
-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(/\/$/, "") : "/";
-};
-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/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");
-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/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 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: 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 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 byPath;
-};
-var someHandler = (gateways, pick) => {
-  for (const gateway of gateways)
-    if (pick(gateway) !== undefined)
-      return true;
-  return false;
-};
-
-// src/ws/adapter.ts
-var RUNTIME = Symbol.for("dunx.ws.runtime");
-var UNCLAIMED = Symbol.for("dunx.ws.unclaimed");
-var defaultOnError = (error, socket) => {
-  console.error(`[dunx/http] ${socket.data.path} handler failed:`, error);
-};
-var reportedByMiddleware = () => {
-  return;
-};
-var unreported = (middleware) => "Socket middleware is installed and none of it sets reportsErrors, so a " + "throwing gateway handler is reported nowhere: the console fallback is off " + "whenever middleware wraps the handler. Set reportsErrors on the one that " + "records a failure, or pass websocket.onError. Installed: " + `${middleware.map((entry) => entry.constructor.name).join(", ")}.`;
-var runtimeOf = (socket) => socket.data[RUNTIME];
-var isBinary = (value) => value instanceof ArrayBuffer || ArrayBuffer.isView(value);
-var replyRaw = (socket, value) => {
-  if (value === undefined)
-    return;
-  socket.send(typeof value === "string" || isBinary(value) ? value : JSON.stringify(value));
-};
-var settle = (result, socket, onError, then) => {
-  if (result instanceof Promise) {
-    result.then((value) => {
-      if (!then)
-        return;
-      try {
-        then(value);
-      } catch (error) {
-        onError(error, socket);
-      }
-    }, (error) => onError(error, socket));
-    return;
-  }
-  if (then)
-    then(result);
-};
-var framing = (kind) => {
-  if (kind === HandlerKind.CLOSE) {
-    return (args) => ({
-      socket: args[0],
-      data: { code: args[1], reason: args[2] }
-    });
-  }
-  if (kind === HandlerKind.OPEN || kind === HandlerKind.DRAIN) {
-    return (args) => ({ socket: args[0], data: undefined });
-  }
-  return (args) => ({ socket: args[1], data: args[0] });
-};
-var NOTHING = () => {
-  return;
-};
-var through = (gateway, middleware, kind, event, invoke) => {
-  const ctx = {
-    gateway: gateway.name,
-    path: gateway.path,
-    kind,
-    event
-  };
-  const dispatch = composeSocket(middleware, ctx);
-  const frameOf = framing(kind);
-  const run = invoke ?? NOTHING;
-  return (...args) => dispatch(frameOf(args), () => run(...args));
-};
-var withMiddleware = (gateway, middleware) => {
-  const wrap = (kind, event, invoke) => through(gateway, middleware, kind, event, invoke);
-  const optional = (kind, invoke) => invoke === undefined ? undefined : wrap(kind, undefined, invoke);
-  return {
-    ...gateway,
-    open: wrap(HandlerKind.OPEN, undefined, gateway.open),
-    close: wrap(HandlerKind.CLOSE, undefined, gateway.close),
-    drain: optional(HandlerKind.DRAIN, gateway.drain),
-    ping: optional(HandlerKind.PING, gateway.ping),
-    pong: optional(HandlerKind.PONG, gateway.pong),
-    raw: optional(HandlerKind.MESSAGE, gateway.raw),
-    events: new Map([...gateway.events].map(([event, invoke]) => [
-      event,
-      wrap(HandlerKind.MESSAGE, event, invoke)
-    ]))
-  };
-};
-var unclaimedDispatch = (gateway, middleware) => (frame, event) => composeSocket(middleware, {
-  gateway: gateway.name,
-  path: gateway.path,
-  kind: HandlerKind.MESSAGE,
-  event
-})(frame, () => {
-  return;
-});
-var buildWebSocket = (discovered, options = {}, middleware = []) => {
-  const byPath = buildGateways(discovered);
-  const wrapped = middleware.length === 0 ? byPath : new Map([...byPath].map(([path, gateway]) => [
-    path,
-    withMiddleware(gateway, middleware)
-  ]));
-  const gateways = [...wrapped.values()];
-  const onError = options.onError ?? (middleware.length === 0 ? defaultOnError : reportedByMiddleware);
-  const reports = options.onError !== undefined || middleware.some((entry) => entry.reportsErrors === true);
-  const { onError: _onError, ...socketOptions } = options;
-  const run = (invoke, args, ws, then) => {
-    try {
-      settle(invoke(...args), ws, onError, then);
-    } catch (error) {
-      onError(error, ws);
-    }
-  };
-  const websocket = {
-    ...socketOptions,
-    message(ws, message) {
-      const gateway = runtimeOf(ws);
-      let event;
-      if (gateway.events.size > 0) {
-        const envelope = decode(message);
-        const handler = envelope && gateway.events.get(envelope.event);
-        if (envelope && handler) {
-          run(handler, [envelope.data, ws], ws, (value) => {
-            if (value !== undefined)
-              ws.send(encode(envelope.event, value));
-          });
-          return;
-        }
-        event = envelope?.event;
-      }
-      if (gateway.raw) {
-        run(gateway.raw, [message, ws], ws, (value) => replyRaw(ws, value));
-        return;
-      }
-      const unclaimed2 = ws.data[UNCLAIMED];
-      if (!unclaimed2)
-        return;
-      try {
-        settle(unclaimed2({ socket: ws, data: message }, event), ws, onError, undefined);
-      } catch (error) {
-        onError(error, ws);
-      }
-    },
-    ...someHandler(gateways, (g) => g.open) && {
-      open(ws) {
-        const { open } = runtimeOf(ws);
-        if (open)
-          run(open, [ws], ws, undefined);
-      }
-    },
-    ...someHandler(gateways, (g) => g.close) && {
-      close(ws, code, reason) {
-        const { close } = runtimeOf(ws);
-        if (close)
-          run(close, [ws, code, reason], ws, undefined);
-      }
-    },
-    ...someHandler(gateways, (g) => g.drain) && {
-      drain(ws) {
-        const { drain } = runtimeOf(ws);
-        if (drain)
-          run(drain, [ws], ws, undefined);
-      }
-    },
-    ...someHandler(gateways, (g) => g.ping) && {
-      ping(ws, data) {
-        const { ping } = runtimeOf(ws);
-        if (ping)
-          run(ping, [data, ws], ws, undefined);
-      }
-    },
-    ...someHandler(gateways, (g) => g.pong) && {
-      pong(ws, data) {
-        const { pong } = runtimeOf(ws);
-        if (pong)
-          run(pong, [data, ws], ws, undefined);
-      }
-    }
-  };
-  const unclaimed = new Map(middleware.length === 0 ? [] : gateways.map((gateway) => [
-    gateway,
-    unclaimedDispatch(gateway, middleware)
-  ]));
-  const accept = (req, server, gateway, context) => {
-    const fallback = unclaimed.get(gateway);
-    const data = {
-      path: gateway.path,
-      context,
-      id: crypto.randomUUID(),
-      [RUNTIME]: gateway,
-      ...fallback === undefined ? {} : { [UNCLAIMED]: fallback }
-    };
-    return server.upgrade(req, { data }) ? undefined : new Response("Expected a WebSocket upgrade", { status: 426 });
-  };
-  const upgradeHandler = (gateway) => (req, server) => {
-    if (!gateway.upgrade)
-      return accept(req, server, gateway, undefined);
-    const result = gateway.upgrade(req);
-    if (result instanceof Promise) {
-      return result.then((value) => value instanceof Response ? value : accept(req, server, gateway, value));
-    }
-    return result instanceof Response ? result : accept(req, server, gateway, result);
-  };
-  return {
-    websocket,
-    routes: new Map(gateways.map((gateway) => [gateway.path, upgradeHandler(gateway)])),
-    paths: [...byPath.keys()],
-    warnings: middleware.length > 0 && !reports ? [unreported(middleware)] : [],
-    gateways: gateways.map((gateway) => ({
-      name: gateway.name,
-      path: gateway.path,
-      events: [...gateway.events.keys()]
-    }))
-  };
-};
-
-// src/ws/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 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 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.");
-      }
-    }
-  }
-  return discovered;
-};
-
-// src/ws/relay.ts
-import { AppError as AppError4 } from "@dunx/core";
-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 };
-};
-
-class WsRelay {
-  constructor() {
-    if (new.target === WsRelay) {
-      throw new AppError4("WsRelay is a contract, not an implementation. Bind one with " + "WsRelayModule.forRoot() for Redis or WsRelayModule.forPostgres() " + "for Postgres, or extend it with a relay of your own.");
-    }
-  }
-}
-
-// 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 AppError5 } 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/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 AppError5(`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 AppError5(`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 TraceContext.stamp(onError(error, req), req);
-    }
-  };
-  return cors ? withCors(cors, run) : run;
-};
-var directOr = (guarded, route, read, status, onError, noMiddleware) => {
-  if (!noMiddleware)
-    return guarded;
-  const settle2 = (value, req) => {
-    try {
-      return toResponse(value, status);
-    } catch (error) {
-      return onError(error, req);
-    }
-  };
-  const invoke = (input, req) => {
-    try {
-      const value = route.handler(input);
-      return value instanceof Promise ? value.then((resolved) => settle2(resolved, req), (error) => onError(error, req)) : settle2(value, req);
-    } catch (error) {
-      return onError(error, req);
-    }
-  };
-  return (req) => {
-    try {
-      const input = read(req);
-      return input instanceof Promise ? input.then((resolved) => invoke(resolved, req), (error) => onError(error, req)) : invoke(input, req);
-    } catch (error) {
-      return onError(error, req);
-    }
-  };
-};
-var buildRoutes = (discovered, middleware = [], onError = defaultErrorMapper, cors, resolve = construct) => {
-  assertNoCollisions(discovered);
-  const routes = {};
-  const instances = new Map;
-  const guardOf = (guard, from) => {
-    const existing = instances.get(guard);
-    if (existing)
-      return existing;
-    const created = resolve(guard, from);
-    instances.set(guard, created);
-    return created;
-  };
-  for (const route of discovered) {
-    const read = buildInputReader(route.options);
-    const status = statusFor(route);
-    const chain = [
-      ...middleware,
-      ...(route.moduleMiddleware ?? []).map((entry) => guardOf(entry, route.module)),
-      ...(route.guards ?? []).map((guard) => guardOf(guard, route.module))
-    ];
-    const chained = compose(chain, buildContext(route), async (req) => toResponse(await route.handler(await read(req)), status));
-    const guarded = async (req) => {
-      try {
-        return await chained(req);
-      } catch (error) {
-        return TraceContext.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 AppError6 } 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 AppError6(`${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 AppError6(`Unsupported protocol ${JSON.stringify(parsed.protocol)} in ` + `${JSON.stringify(url)}. Expected one of ${PROTOCOLS.join(", ")}.`);
-  }
-  return url;
-};
-
-class RedisRelay extends WsRelay {
-  #url;
-  #options;
-  #pub;
-  #sub;
-  #channel;
-  constructor(options = {}) {
-    super();
-    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/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
-import { inject } from "@dunx/core";
-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;
-
-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, WsRelay, RawBody, buildContext, withCors, preflight, compose, assertNoCollisions, assertNoGatewayCollisions, withUpgradeRoutes, buildFallback, buildRoutes, StaticOptions, normalizePrefix, negotiate, CompressionEncoding, isCompressibleType, CompressionOptions, defaultRelayUrl, RedisRelay, HEALTH_REPORT_SCHEMA, HealthOptions, HealthRegistry, HealthController, HiddenHealthController };