@dunx/http 2.5.0 → 3.0.1

package/dist/internal.d.ts

@@ -0,0 +1,36 @@
+/**
+ * What the framework calls on itself, and the only place it is exported from.
+ *
+ * The barrel was a semver promise 173 symbols wide, which is more than this
+ * package meant to make. What stays public there is the surface an app writes
+ * against:
+ * decorators, options, contracts, errors, modules and the metadata helpers a
+ * user's own guard reads. What is here is route-table construction, the
+ * middleware fold, the relay codec and the discovery readers - things
+ * `@dunx/dashboard`, `@dunx/mcp` and `@dunx/openapi` need and an app does not.
+ *
+ * No stability promise attaches to this subpath.
+ */
+export { discoverRoutes, joinPath, type DiscoveredRoute, } from './route/discover.js';
+export { defaultStatusFor, type DefaultStatus, type RouteMeta, } from './route/marker.js';
+export { guardsOf } from './route/metadata.js';
+export { gatewaysOf, routesOf, type GatewayHandler, type GatewayNode, type RouteInputs, type RouteNode, } from './inspect.js';
+export { buildContext } from './server/context.js';
+export { preflight, withCors } from './server/cors.js';
+export { isErrorFilter, toErrorMapper } from './server/errors.js';
+export { compose } from './server/middleware.js';
+export { assertNoCollisions, assertNoGatewayCollisions, buildRoutes, withUpgradeRoutes, type BunRoutes, type GuardResolver, type RouteMethod, type ServeRoutes, } from './server/routes.js';
+export { normalizePrefix } from './static/options.js';
+export { negotiate } from './compression/negotiate.js';
+export { isCompressibleType } from './compression/options.js';
+export { buildWebSocket, type UpgradeHandler, type WebSocketRuntime, } from './ws/adapter.js';
+export { discoverGateway, discoverGateways, normalizePath, type DiscoveredGateway, type DiscoveredHandler, type Invoke, } from './ws/discover.js';
+export { decode, encode } from './ws/envelope.js';
+export { composeSocket, observe } from './ws/middleware.js';
+export { HandlerKind, isGateway, type HandlerMeta } from './ws/marker.js';
+export { defaultRelayUrl } from './ws/redis-relay.js';
+export { decodeRelay, encodeRelay, type RelayFrame, type RelayPhase, } from './ws/relay.js';
+export { buildGateways, buildRuntime, type GatewayRuntime, } from './ws/runtime.js';
+export { HiddenHealthController } from './health/controller.js';
+export { backoffDelay, executeWithRetry, isRetryableStatus, retryAfterMs, } from './client/retry.js';
+export { isJsonBody, isPlainObject, safeStringify } from './client/json.js';

package/dist/internal.js

@@ -0,0 +1,154 @@
+// @bun
+import {
+  HIDDEN,
+  HandlerKind,
+  HiddenHealthController,
+  PUBLIC,
+  ROLES,
+  assertNoCollisions,
+  assertNoGatewayCollisions,
+  buildContext,
+  buildGateways,
+  buildRoutes,
+  buildRuntime,
+  buildWebSocket,
+  compose,
+  composeSocket,
+  decode,
+  decodeRelay,
+  defaultRelayUrl,
+  defaultStatusFor,
+  discoverGateway,
+  discoverGateways,
+  discoverRoutes,
+  encode,
+  encodeRelay,
+  guardsOf,
+  isCompressibleType,
+  isErrorFilter,
+  isGateway,
+  joinPath,
+  negotiate,
+  normalizePath,
+  normalizePrefix,
+  observe,
+  preflight,
+  toErrorMapper,
+  withCors,
+  withUpgradeRoutes
+} from "./chunk-f6pw36av.js";
+import {
+  backoffDelay,
+  executeWithRetry,
+  isJsonBody,
+  isPlainObject,
+  isRetryableStatus,
+  retryAfterMs,
+  safeStringify
+} from "./chunk-b699cfes.js";
+import"./chunk-sz4pvqxy.js";
+// src/inspect.ts
+import {
+  collectModules,
+  dependenciesOf,
+  readControllers
+} from "@dunx/core";
+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 classOf = (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(classOf).filter((ctor) => ctor !== undefined).filter(isGateway).map((ctor) => gatewayFor(ctor, module.name)));
+export {
+  HandlerKind,
+  HiddenHealthController,
+  assertNoCollisions,
+  assertNoGatewayCollisions,
+  backoffDelay,
+  buildContext,
+  buildGateways,
+  buildRoutes,
+  buildRuntime,
+  buildWebSocket,
+  compose,
+  composeSocket,
+  decode,
+  decodeRelay,
+  defaultRelayUrl,
+  defaultStatusFor,
+  discoverGateway,
+  discoverGateways,
+  discoverRoutes,
+  encode,
+  encodeRelay,
+  executeWithRetry,
+  gatewaysOf,
+  guardsOf,
+  isCompressibleType,
+  isErrorFilter,
+  isGateway,
+  isJsonBody,
+  isPlainObject,
+  isRetryableStatus,
+  joinPath,
+  negotiate,
+  normalizePath,
+  normalizePrefix,
+  observe,
+  preflight,
+  retryAfterMs,
+  routesOf,
+  safeStringify,
+  toErrorMapper,
+  withCors,
+  withUpgradeRoutes
+};

package/dist/route/metadata.d.ts

@@ -31,17 +31,14 @@ export declare const UNMATCHED: MetaKey<boolean>;
 export declare const Roles: (...roles: readonly string[]) => <F extends object>(target: F) => F;
 export declare const Public: () => <F extends object>(target: F) => F;
 /**
- * Route, but not documented. Valid on a method or on a class.
+ * Route, but not documented. Valid on a method or a class.
  *
- * The motivating case is a handler mounted on a wildcard: `@dunx/auth` routes
- * `<basePath>/*` to Better Auth's own handler, which is real and has to be
- * routed, but `*` is not an OpenAPI path template - so documenting it produced an
- * invalid entry named after an internal class, next to the 45 paths
- * `betterAuthDocument` describes properly.
+ * The motivating case is a wildcard mount: `@dunx/auth` routes `<basePath>/*` to
+ * better-auth's handler, and `*` is not an OpenAPI path template, so documenting
+ * it produced an invalid entry named after an internal class.
  *
- * It lives here rather than in `@dunx/openapi` because `@dunx/auth` must not
- * depend on the documentation package to say a route is undocumented, and this is
- * where the rest of the route metadata already is.
+ * Here rather than in `@dunx/openapi` so `@dunx/auth` need not depend on the
+ * documentation package to say a route is undocumented.
  */
 export declare const ApiHidden: () => <F extends object>(target: F) => F;
 /**

package/dist/route/schema.d.ts

@@ -1,11 +1,9 @@
 import type { BunRequest } from 'bun';
 import type { DefaultStatus, HttpMethod } from './marker.js';
 /**
- * Standard Schema v1, restated rather than depended on. The spec is an
- * *interface*, not a runtime: `@standard-schema/spec` ships nothing but these
- * declarations, so restating them costs one file and keeps `@dunx/http` at zero
- * dependencies. Zod 4, Valibot and ArkType already satisfy this shape, so any of
- * them drops straight into a route's options.
+ * Standard Schema v1, restated rather than depended on: the spec is an interface,
+ * so restating it keeps `@dunx/http` at zero dependencies. Zod 4, Valibot and
+ * ArkType all satisfy this shape already.
  */
 export interface StandardSchemaV1<In = unknown, Out = In> {
     readonly '~standard': {
@@ -35,11 +33,8 @@ export interface StandardSchemaIssue {
 /** The validated output of a schema - `InferOutput<typeof CreateNote>` is `Note`. */
 export type InferOutput<S> = S extends StandardSchemaV1<unknown, infer Out> ? Out : never;
 /**
- * A JSON Schema, as JSON. OpenAPI 3.1 embeds draft 2020-12 verbatim.
- *
- * Declared here rather than in `@dunx/openapi` because {@link RouteSchemas} names
- * it and that package depends on this one, so this is the lowest common owner.
- * `@dunx/openapi` re-exports it.
+ * A JSON Schema, as JSON. Declared here rather than in `@dunx/openapi` because
+ * {@link RouteSchemas} names it and that package depends on this one.
  */
 export type JsonSchema = Readonly<Record<string, unknown>>;
 /**
@@ -55,9 +50,7 @@ export interface RouteSchemas {
     readonly status?: number;
     /**
      * What the route answers with, keyed by status code, in the same Standard
-     * Schema the request side takes - so a response schema with a `.meta({ id })`
-     * hoists into `components/schemas` exactly as a request body does, and there is
-     * one contract for both directions.
+     * Schema the request side takes.
      *
      * ```ts
      * const one = {
@@ -66,19 +59,9 @@ export interface RouteSchemas {
      * } as const satisfies RouteSchemas;
      * ```
      *
-     * **Never validated at runtime, checked at compile time.** Running a validation
-     * pass over every response body would be a per-request cost paid for a
-     * documentation feature. The handler's own return type carries the check
-     * instead: the verb decorators constrain it against the entry for the success
-     * status, so a handler answering with a different shape is a `TS1241` naming
-     * the mismatched property. See {@link Returns}. Nothing in the request path
-     * reads this key.
-     *
-     * A plain {@link JsonSchema} is accepted here too, and only here: a JSON Schema
-     * needs no conversion, so documenting a response costs no validator. `$id` names
-     * it, hoisting it into `components/schemas` the way `.meta({ id })` does for a
-     * zod schema. `body`, `query` and `params` still take a Standard Schema, because
-     * those are parsed.
+     * Never validated at runtime, checked at compile time against the success
+     * status. A plain {@link JsonSchema} is accepted here and only here, and `$id`
+     * hoists it into `components/schemas`.
      *
      * ```ts
      * response: {
@@ -92,10 +75,8 @@ export interface RouteSchemas {
 export type ResponseMap = Readonly<Record<number, StandardSchemaV1 | JsonSchema>>;
 /**
  * The handler's parameter type, derived from its own options object. It has to be
- * written out - a standard method decorator can *check* a parameter's type but
- * cannot contextually type an unannotated one
- * (docs/architecture/constraints.md) - but every field type still comes from the schemas, so nothing
- * is declared twice:
+ * written out: a standard method decorator can check a parameter's type but not
+ * contextually type an unannotated one (docs/architecture/constraints.md).
  *
  * ```ts
  * const createNote = { body: CreateNote, status: HttpStatusCode.CREATED } as const;
@@ -125,8 +106,8 @@ export type Input<O extends RouteSchemas> = {
 } : unknown);
 /**
  * The status a handler's return type is held to: an explicit `options.status`,
- * else the verb's default. Widened to `number` without `as const`, which is what
- * turns the check off rather than misapplying it.
+ * else the verb's default. Widened to `number` without `as const`, which turns
+ * the check off rather than misapplying it.
  */
 type SuccessStatus<O extends RouteSchemas, M extends HttpMethod> = O extends {
     status: infer S extends number;
@@ -138,39 +119,30 @@ type SuccessStatus<O extends RouteSchemas, M extends HttpMethod> = O extends {
  */
 type Declared<S> = [InferOutput<S>] extends [never] ? unknown : Serialised<InferOutput<S>>;
 /**
- * The declared shape as JSON will present it, which is the same shape with every
- * array made readonly.
+ * The declared shape as JSON will present it: the same shape with every array made
+ * readonly. `z.array()` infers a mutable `T[]`, so a method correctly returning
+ * `readonly User[]` would fail against a document it satisfies, and mutability
+ * does not survive `Response.json` anyway.
  *
- * `z.array()` infers a mutable `T[]`, and `readonly T[]` is not assignable to it -
- * so a repository method returning `readonly User[]`, the correct signature for
- * something that must not be mutated, would fail against a document it satisfies.
- * Mutability does not survive `Response.json`, so it is not part of the contract.
- *
- * Only arrays need the rewrite; TypeScript already ignores a property's `readonly`
- * modifier when checking assignability. The object branch is how nested arrays are
- * reached, and functions are returned untouched because mapping over one would
- * discard its call signature.
+ * Only arrays need it. The object branch reaches nested ones; functions are
+ * returned untouched, since mapping over one discards its call signature.
  */
 type Serialised<T> = T extends readonly (infer E)[] ? readonly Serialised<E>[] : T extends (...args: never[]) => unknown ? T : T extends object ? {
     readonly [K in keyof T]: Serialised<T[K]>;
 } : T;
 /**
- * What a handler may return, given its own options object and its verb.
- *
- * A route decorator can *check* a handler's type but cannot *infer* it
- * (docs/architecture/constraints.md), and that cuts both ways: this is the return
- * half of the same guarantee `Input<O>` gives the parameter. Declaring
- * `response: { 200: User }` stops being documentation a handler can contradict.
+ * What a handler may return, given its options object and its verb. The return
+ * half of the guarantee `Input<O>` gives the parameter, so `response: { 200: User }`
+ * stops being documentation a handler can contradict.
  *
- * `Response` is always allowed - it is the escape hatch `buildRoutes` passes
- * through untouched. So is a promise of either. Nothing is checked when the
- * success status has no `response` entry.
+ * `Response` is always allowed, and so is a promise of either. Nothing is checked
+ * when the success status has no `response` entry.
  */
 export type Returns<O extends RouteSchemas, M extends HttpMethod> = SuccessBody<O, M> | Response | Promise<SuccessBody<O, M> | Response>;
 /**
- * `infer R extends ResponseMap` is load bearing: without the constraint the
- * narrowed `O` inside the branch is `{ response: R } & O`, whose `response` no
- * longer satisfies `RouteSchemas`, and `SuccessStatus<O, M>` fails with `TS2344`.
+ * `infer R extends ResponseMap` is required: without it the narrowed `O` is
+ * `{ response: R } & O`, whose `response` no longer satisfies `RouteSchemas`, and
+ * `SuccessStatus<O, M>` fails with `TS2344`.
  */
 type SuccessBody<O extends RouteSchemas, M extends HttpMethod> = O extends {
     response: infer R extends ResponseMap;

package/dist/server/application.d.ts

@@ -16,111 +16,62 @@ export interface HttpOptions extends AppOptions {
     /** Resolved from the container, so middleware can inject(). */
     readonly middleware?: readonly Ctor<Middleware>[];
     /**
-     * Replaces the default mapper.
-     *
-     * A bare `ErrorMapper` function, or an `ErrorFilter` **class** - which is the one
-     * to prefer, because a class is resolved from the container and can therefore
-     * inject the `Logger` or the config a real filter needs. A mapper cannot; dunx's
-     * own default has to be curried over its logger for exactly that reason.
-     *
-     * A filter with dependencies needs them bindable, the same rule `middleware`
-     * entries follow; one with none self-binds and needs no `providers` entry.
+     * Replaces the default mapper. Prefer an `ErrorFilter` class over a bare
+     * `ErrorMapper`: a class is resolved from the container and can inject.
      */
     readonly onError?: ErrorHandler;
     /**
-     * One structured entry per request, on by default. `false` removes it; an
-     * options object tunes what it records. See {@link RequestLoggingMiddleware}.
-     *
-     * It is the **outermost** middleware, ahead of anything `middleware` declares,
-     * so a request rejected by a guard is still logged with the status it got.
+     * One structured entry per request, on by default and outermost, so a request
+     * a guard rejected is still logged with the status it got.
+     * See {@link RequestLoggingMiddleware}.
      */
     readonly requestLogging?: boolean | RequestLoggingOptions;
     /**
-     * One entry at `listen()` naming every route and gateway the process serves. On
-     * by default, because it is the answer to "is my route registered" and a service
-     * that logs nothing at boot cannot answer it from production.
-     *
-     * `false` removes it. Separate from `requestLogging` rather than sharing its
-     * switch: one is per request and one is per process, and silencing the noisy one
-     * is not a reason to lose the quiet one. `@dunx/testing` defaults it off, for the
-     * same reason it defaults request logging off.
+     * One entry at `listen()` naming every route and gateway served. On by default,
+     * and switched separately from `requestLogging`: one is per process, the other
+     * per request. `@dunx/testing` defaults it off.
      */
     readonly bootLogging?: boolean;
-    /**
-     * Bun's `websocket` options, plus where a throwing handler goes. Server-wide, so
-     * they live here next to `middleware` rather than on a module: gateways
-     * themselves are declared in `@Module({ providers })`.
-     */
+    /** Bun's `websocket` options, plus where a throwing handler goes. Server-wide;
+     * gateways themselves are declared in `@Module({ providers })`. */
     readonly websocket?: SocketOptions;
     /**
-     * The socket half of `middleware`, resolved from the container the same way.
-     *
-     * Each entry wraps every dispatched gateway handler - open, each named message,
-     * the catch-all, close, drain, ping and pong - the way an HTTP middleware wraps a
-     * route. `socketLogging`'s middleware runs outermost, ahead of anything here.
+     * The socket half of `middleware`. Each entry wraps every dispatched gateway
+     * handler; `socketLogging`'s runs outermost, ahead of anything here.
      */
     readonly socketMiddleware?: readonly Ctor<SocketMiddleware>[];
     /**
-     * One structured entry per socket frame, on by default at **`debug`**. `false`
-     * removes it; an options object tunes the level per event. See
-     * {@link SocketLoggingMiddleware}.
-     *
-     * `debug` rather than request logging's `info`, because a gateway can take a
-     * frame per connection per tick. The default `ConsoleLogger` threshold is
-     * `info`, so this writes nothing until an app lowers its level or names a louder
-     * one here.
-     *
-     * Installing it also takes `SocketOptions.onError`'s `console.error` default out
-     * of the way: a middleware wraps the handler, so the failure is already reported
-     * through the `Logger` with the gateway and the event on it.
+     * One structured entry per socket frame, on by default at `debug` - a gateway
+     * can take a frame per connection per tick, so it writes nothing until an app
+     * lowers its level. See {@link SocketLoggingMiddleware}.
      */
     readonly socketLogging?: boolean | SocketLoggingOptions;
     /**
-     * Multi-node websocket fan-out. Absent - the default - means `PubSub` publishes
-     * to this process only, which is exactly Bun's native pub/sub and costs nothing.
-     *
-     * `new RedisRelay({ url })` is the batteries-included one. Anything with a
-     * `publish` and a `subscribe` fits, including `@dunx/infra`'s `RedisConnection`,
-     * which has to come out of the container and so goes through
-     * `app.get(PubSub).relayThrough(...)` instead of this option.
+     * Multi-node websocket fan-out. Absent means `PubSub` publishes to this process
+     * only. Anything with `publish` and `subscribe` fits; one that has to come out
+     * of the container goes through `app.get(PubSub).relayThrough(...)` instead.
      */
     readonly relay?: PubSubRelay;
     /** The broker channel the relay carries frames on. @default 'dunx:ws' */
     readonly relayChannel?: string;
     /**
-     * How hard to retry a subscribe that failed. Same shape as
-     * `RelayOptions.resubscribe`: bounded, doubling, and on an unref'd timer, so a
-     * broker that never comes back cannot hold the process open.
-     *
-     * Here rather than only on `relayThrough` because reaching for that to set one
-     * option means giving up `relay` above entirely - the two conflict, and the
-     * second to run throws `PubSub already relays`.
+     * How hard to retry a failed subscribe. Bounded, doubling, on an unref'd timer,
+     * so a broker that never returns cannot hold the process open.
      */
     readonly relayResubscribe?: RelayOptions['resubscribe'];
     /**
-     * What an unmatched path looks like to global middleware.
-     *
-     * `'guarded'`, the default, gives the miss no route metadata, so a global guard
-     * refuses it and an anonymous caller gets that guard's status rather than a 404.
-     * That is deliberate: a 404 on a miss while every real path answers 401 tells a
-     * prober which paths exist.
-     *
-     * `'public'` reports the miss as `@Public()`, so a guard honouring that flag
-     * passes it through to the conventional 404. The request is still logged and
-     * still gets a request id either way, which is the whole reason the fallback
-     * runs the middleware at all.
-     *
-     * A guard can discriminate under either setting: `UNMATCHED` is set on the miss
-     * and no real route ever sets it.
+     * What an unmatched path looks like to global middleware. `'guarded'` gives the
+     * miss no route metadata, so a global guard refuses it and a prober cannot tell
+     * a 404 from a 401. `'public'` reports it as `@Public()` for a conventional 404.
+     * Either way `UNMATCHED` is set, which no real route sets.
      *
      * @default 'guarded'
      */
     readonly notFound?: 'guarded' | 'public';
 }
 /**
- * Everything below `listen()` configures the route table, which is built exactly
- * once - when the server binds. Calling any of them afterwards throws rather than
- * being quietly dropped.
+ * Everything below `listen()` configures the route table, built once when the
+ * server binds. Calling any of them afterwards throws.
  */
 export interface HttpApp extends App {
     /** Prefixes every discovered route. Last call wins. */
@@ -151,23 +102,16 @@ export declare class HttpApplication implements HttpApp {
     setting<K extends keyof AppSettings>(key: K): AppSettings[K];
     enableCors(options?: CorsOptions): this;
     clientIp(req: BunRequest): string | undefined;
-    /**
-     * The one `Bun.serve` call. A gateway's upgrade is a native `GET` route in the
-     * same table, so Bun's router - not a hand-written `fetch` fallback - is what
-     * matches an upgrade, and no `fetch` handler is needed at all.
-     */
+    /** The one `Bun.serve` call. A gateway's upgrade is a native `GET` route in the
+     * same table, so Bun's router matches it and no `fetch` handler is needed. */
     listen(port?: number): Promise<string>;
-    /**
-     * Delegated unchanged: the drain is the container's phase, and `shutdown()`
-     * runs it. Public so an operator can start draining without committing to a
-     * shutdown, which is what a readiness probe wants during a rolling deploy.
-     */
+    /** Public so an operator can start draining without committing to a shutdown,
+     * which is what a readiness probe wants during a rolling deploy. */
     drain(): Promise<void>;
     /**
-     * The four phases, in order, and **none of them is skipped because an earlier
-     * one failed**. A drain hook that threw used to abort this before `server.stop()`
-     * had run, so the port stayed open and `closed` never resolved; each failure is
-     * collected now and thrown once the whole teardown is over.
+     * Four phases in order, none skipped because an earlier one failed. A throwing
+     * drain hook used to abort before `server.stop()`, leaving the port open and
+     * `closed` unresolved; failures are collected and thrown at the end.
      */
     shutdown(): Promise<void>;
     enableShutdownHooks(signals?: readonly ShutdownSignal[], options?: ShutdownHookOptions): this;

package/dist/server/client-address.d.ts

@@ -4,20 +4,13 @@ export interface AddressSource {
     readonly trustProxy: boolean | number;
 }
 /**
- * The client's address, honouring the `'trust proxy'` setting.
+ * The client's address, honouring `'trust proxy'`. The address is counted from the
+ * right of `X-Forwarded-For` by the number of trusted hops, never from the left: a
+ * client can send anything, and only the entries a proxy appended carry weight.
  *
- * With the setting on, the address is read from `X-Forwarded-For` counting from
- * the right by the number of trusted hops, never from the left. A client can put
- * anything in the header it sends; only the entries a proxy appended carry any
- * weight, and there are exactly as many of those as there are proxies in front of
- * this server.
- *
- * Bound and exported by `HttpFactory`'s global wrapper module, so injecting it in a
- * middleware or controller needs no registration and `app.clientIp(req)` is the same
- * instance. That binding is not optional under module scoping: an unbound class
- * self-binds into whichever scope asks first, so a second module injecting it was a
- * boot error naming the first, and `listen()` could attach the server to an instance
- * nothing else held.
+ * Bound by `HttpFactory`'s global wrapper, which is not optional under module
+ * scoping - an unbound class self-binds into whichever scope asks first, so a
+ * second module injecting it was a boot error.
  */
 export declare class ClientAddress {
     of(req: BunRequest): string | undefined;