@dunx/http 3.5.1 → 3.6.0

package/README.md

@@ -64,11 +64,12 @@ The guide is canonical for every row; this table is the index.
 | WebSocket gateways      | `@Gateway`, handlers, `PubSub`, multi-node relay            | [WebSockets](../../docs/guide/09-websockets.md)                   |
 | Request logging         | One structured entry per request, on by default             | [Logging](../../docs/guide/13-logging.md)                         |
 | Trace context           | W3C `traceparent` adopted and propagated, on by default     | [Logging](../../docs/guide/13-logging.md)                         |
-| Metrics                 | Per-route counts and timings, off by default                | [Metrics](../../docs/guide/22-metrics.md)                         |
-| Health and draining     | `/health/live`, `/health/ready`, readiness during a rollout | [Health checks](../../docs/guide/20-health-checks.md)             |
+| Metrics                 | Per-route counts and timings, off by default                | [Metrics](../../docs/guide/23-metrics.md)                         |
+| Health and draining     | `/health/live`, `/health/ready`, readiness during a rollout | [Health checks](../../docs/guide/21-health-checks.md)             |
 | Throttling              | `@Throttle`, `@SkipThrottle`, memory and Redis counters     | [Middleware and guards](../../docs/guide/08-middleware-and-guards.md) |
-| Static files            | `Bun.file` behind a mount, with a cache policy              | [Deployment](../../docs/guide/19-deployment.md)                   |
-| Compression             | zstd and gzip on Bun's own compressors                      | [Deployment](../../docs/guide/19-deployment.md)                   |
+| Outbound resilience     | `HttpRetryClassifier`: which statuses retry, and `Retry-After` | [Resilience](../../docs/guide/25-resilience.md)                |
+| Static files            | `Bun.file` behind a mount, with a cache policy              | [Deployment](../../docs/guide/20-deployment.md)                   |
+| Compression             | zstd and gzip on Bun's own compressors                      | [Deployment](../../docs/guide/20-deployment.md)                   |
 
 ## Subpaths
 

package/dist/client/json.d.ts

@@ -8,17 +8,7 @@
  * the caller and should say so.
  */
 export declare const safeStringify: (value: unknown) => string;
-/**
- * A plain object: `{}`, `Object.create(null)`, or a JSON-parsed value. Anything
- * with its own prototype - `Date`, `Map`, `Error`, a class instance - is not one.
- *
- * The prototype check rather than the reference's `typeof === 'object' && !Array
- * && !(instanceof Error)`, which answered `true` for a `Date` and for every class
- * instance, so "is this a plain object" did not mean what it said. Body routing
- * does not use this - see {@link isJsonBody} - so tightening it changes no
- * behaviour beyond making the predicate honest.
- */
-export declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
+export { isPlainObject } from '@dunx/core';
 /**
  * Whether a payload should be JSON-encoded, or handed to `fetch` as-is.
  *
@@ -32,3 +22,14 @@ export declare const isPlainObject: (value: unknown) => value is Record<string,
  * JSON-encodable; a `Blob` is neither.
  */
 export declare const isJsonBody: (payload: unknown) => boolean;
+/**
+ * JSON when the upstream said so or the body parses; text otherwise; undefined
+ * for empty.
+ *
+ * **A failed read rejects.** It used to be caught and reported as an empty body,
+ * so a 2xx whose body died mid-stream reached the caller as a success with no
+ * data, and a retry policy saw nothing to retry. A caller that wants the old
+ * behaviour asks for it: the two error paths in `HttpService` do, because there
+ * the status is the signal and an unreadable body should not replace it.
+ */
+export declare const readBody: (response: Response) => Promise<unknown>;

package/dist/client/options.d.ts

@@ -1,4 +1,4 @@
-import type { RetryOptions } from './retry.js';
+import type { HttpRetryOptions } from './retry.js';
 /**
  * Named `HttpClientOptions`, not `HttpOptions`: the server half already exports
  * that from `@dunx/http` for `HttpFactory.create`, and two things called
@@ -15,7 +15,7 @@ export interface HttpClientOptionsInit {
     readonly timeoutMs?: number;
     /** Sent on every request, under anything a call sets itself. */
     readonly headers?: Readonly<Record<string, string>>;
-    readonly retry?: RetryOptions<unknown>;
+    readonly retry?: HttpRetryOptions;
     /**
      * Forward W3C Trace Context upstream as `traceparent`, so the callee's spans
      * join this request's trace and one trace spans both services.
@@ -71,7 +71,7 @@ export declare class HttpClientOptions {
     readonly baseUrl: string | undefined;
     readonly timeoutMs: number;
     readonly headers: Readonly<Record<string, string>>;
-    readonly retry: RetryOptions<unknown>;
+    readonly retry: HttpRetryOptions;
     readonly propagateTrace: boolean;
     readonly name: string | undefined;
     readonly fetchOptions: Readonly<Record<string, unknown>>;

package/dist/client/retry.d.ts

@@ -1,49 +1,35 @@
-export interface BackoffOptions {
-    /** Base delay, doubled each attempt. */
-    readonly baseMs: number;
-    /** @default 2 */
-    readonly power?: number;
-    /** Upper bound of the random component added to each delay. @default 1000 */
-    readonly jitterMs?: number;
-    /** @default 30000 */
-    readonly maxMs?: number;
-}
-/** `base * power^attempt + jitter`, capped. `attempt` is 0 for the first retry. */
-export declare const backoffDelay: (attempt: number, { baseMs, power, jitterMs, maxMs }: BackoffOptions) => number;
+import { RetryClassifier, type RetryOptions, type RetryVerdict } from '@dunx/core';
 /**
  * The wait an upstream asked for, in ms, or undefined.
  *
  * RFC 9110 allows either a delay in seconds or an HTTP date, and both appear in
- * the wild - GitHub sends seconds, some CDNs send a date. Ignoring the header, as
- * the reference did, means retrying straight back into a rate limit that had just
- * told you exactly how long to wait.
+ * the wild: GitHub sends seconds, some CDNs send a date. Ignoring the header means
+ * retrying straight back into a rate limit that had just said how long to wait.
  */
 export declare const retryAfterMs: (headers: Headers, now?: number) => number | undefined;
 /**
  * Statuses worth trying again: a server that failed, one that is overloaded, and
- * one that timed out. Deliberately narrower than the source, which also retried
- * 409 and 422 - both of those are the server rejecting the *request*, and sending
- * it again unchanged gets the same answer.
+ * one that timed out. Narrower than 409 and 422, which are the server rejecting
+ * the *request* - sending it again unchanged gets the same answer.
  */
 export declare const isRetryableStatus: (status: number) => boolean;
-export interface RetryOptions<T> {
-    /** Retries *after* the first attempt, so 3 means up to 4 calls. @default 3 */
-    readonly maxRetries?: number;
-    /** @default 1000 */
-    readonly retryDelayMs?: number;
-    readonly backoff?: Omit<BackoffOptions, 'baseMs'>;
+/** Core's generic retry knobs plus the two an HTTP failure carries. */
+export interface HttpRetryOptions<T = unknown> extends RetryOptions<T> {
     /** @default isRetryableStatus */
     readonly shouldRetryOnStatus?: (status: number) => boolean;
     /** Honour a `Retry-After` header over the computed backoff. @default true */
     readonly respectRetryAfter?: boolean;
-    readonly onAttempt?: (attempt: number, isRetry: boolean) => void;
-    readonly onError?: (error: unknown, attempt: number, willRetry: boolean) => void;
-    readonly onSuccess?: (result: T, attempt: number) => void;
 }
 /**
- * Runs `operation`, retrying per `options`.
+ * The HTTP half of the retry decision, and the only place in dunx's resilience
+ * path that knows what a status is.
  *
- * `Bun.sleep` rather than a `setTimeout` promise: it is the runtime's own timer and
- * needs no wrapper.
+ * An abort is never retried: the caller's signal fired or the timeout expired, and
+ * both mean the budget for this call is spent. A transport failure is retried,
+ * because a refused connection is the case retrying exists for.
  */
-export declare const executeWithRetry: <T>(operation: () => Promise<T> | T, options?: RetryOptions<T>) => Promise<T>;
+export declare class HttpRetryClassifier extends RetryClassifier {
+    private readonly options;
+    constructor(options?: HttpRetryOptions);
+    classify(error: unknown): RetryVerdict;
+}

package/dist/client/service.d.ts

@@ -2,7 +2,7 @@ import { Logger, RequestContext } from '@dunx/core';
 import { UrlHelper, type ParamsType } from '@arkv/shared';
 import type { HttpMethod } from '../route/marker.js';
 import { HttpClientOptions } from './options.js';
-import { type RetryOptions } from './retry.js';
+import { type HttpRetryOptions } from './retry.js';
 /** The client speaks two more verbs than a route can declare. */
 export type RequestMethod = HttpMethod | 'HEAD' | 'OPTIONS';
 /**
@@ -36,7 +36,7 @@ export interface RequestConfig<TRequest = unknown, TResponse = unknown> {
     readonly headerFactory?: HeaderFactory;
     /** Merged into the async context for this call, so its logs carry it. */
     readonly flow?: string;
-    readonly retry?: RetryOptions<TResponse>;
+    readonly retry?: HttpRetryOptions<TResponse>;
     /** Cancels the call. Combined with the timeout, whichever fires first. */
     readonly signal?: AbortSignal;
 }
@@ -86,6 +86,12 @@ export declare class HttpService extends UrlHelper {
      * regex, so it cannot disagree with `new URL`.
      */
     private urlFor;
+    /**
+     * One policy per call, because the budget and the caller's signal are. Core owns
+     * the timeout, the loop and the backoff; `HttpRetryClassifier` is the only part
+     * of it that knows what a status is.
+     */
+    private policyFor;
     /** `serialised` is what a `headerFactory` signs, and is `''` for no body. */
     private bodyFor;
     private send;

package/dist/client/sse.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The `data:` payloads of a server-sent-events body, in order, ending when the
+ * stream does or when a line reads `[DONE]`.
+ *
+ * Async iteration rather than `getReader()`: it acquires the reader and releases
+ * it on completion, on a `break` in the consumer, and on the `[DONE]` return,
+ * which is the case the manual form needed a `releaseLock()` in a `finally` for.
+ *
+ * Hand-rolled because Bun exposes no `EventSource` global and no SSE parser,
+ * which was measured rather than assumed.
+ */
+export declare function sseData(body: ReadableStream<Uint8Array>): AsyncGenerator<string>;
+/**
+ * A deadline on the connect alone.
+ *
+ * An `AbortSignal.timeout` handed to `fetch` keeps aborting after the headers
+ * arrive, which cut a 600 ms stream at 200 ms when the policy supplied one. This
+ * holds its timer so the caller can drop it the moment `fetch` resolves, leaving
+ * the body cancellable only by the caller's own signal.
+ */
+export declare class ConnectDeadline {
+    #private;
+    constructor(ms: number, target: string);
+    get signal(): AbortSignal;
+    clear(): void;
+}

package/dist/client.d.ts

@@ -7,6 +7,13 @@
  */
 export { FetchError, FetchTransportError } from './client/errors.js';
 export { HttpClientOptions, type HttpClientOptionsInit, } from './client/options.js';
-export type { BackoffOptions, RetryOptions } from './client/retry.js';
+/**
+ * Retry, backoff and jitter are `@dunx/core`'s, re-exported so an import of this
+ * subpath still names them. What stays here is the HTTP half of the decision:
+ * `HttpRetryClassifier` reads a status and a `Retry-After`, which is the seam that
+ * keeps both out of core.
+ */
+export type { BackoffOptions, RetryOptions } from '@dunx/core';
+export { HttpRetryClassifier, type HttpRetryOptions } from './client/retry.js';
 export { httpClient, HttpModule, type ClientTarget } from './client/module.js';
 export { HttpService, type HeaderFactory, type RequestConfig, type RequestMethod, } from './client/service.js';

package/dist/client.js

@@ -1,12 +1,12 @@
 // @bun
+import {
+  HttpStatusCode2
+} from "./chunk-bg0dr54z.js";
 import {
   TRACEPARENT_HEADER2,
   TRACESTATE_HEADER2,
   TraceContext2
 } from "./chunk-gmtwad7f.js";
-import {
-  HttpStatusCode2
-} from "./chunk-bg0dr54z.js";
 
 // src/client/errors.ts
 import { AppError } from "@dunx/core";
@@ -71,6 +71,45 @@ class HttpClientOptions {
   }
 }
 Object.defineProperty(HttpClientOptions, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "init: HttpClientOptionsInit = {}", optional: true }] });
+// src/client/retry.ts
+import {
+  RetryClassifier
+} from "@dunx/core";
+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 >= HttpStatusCode2.INTERNAL_SERVER_ERROR || status === HttpStatusCode2.REQUEST_TIMEOUT || status === HttpStatusCode2.TOO_MANY_REQUESTS;
+
+class HttpRetryClassifier extends RetryClassifier {
+  options;
+  constructor(options = {}) {
+    super();
+    this.options = options;
+  }
+  classify(error) {
+    if (error instanceof FetchTransportError)
+      return { retry: !error.aborted };
+    if (error instanceof FetchError) {
+      const {
+        shouldRetryOnStatus = isRetryableStatus,
+        respectRetryAfter = true
+      } = this.options;
+      if (!shouldRetryOnStatus(error.status))
+        return { retry: false };
+      const asked = respectRetryAfter ? retryAfterMs(error.response.headers) : undefined;
+      return asked === undefined ? { retry: true } : { retry: true, delayMs: asked };
+    }
+    return { retry: true };
+  }
+}
+Object.defineProperty(HttpRetryClassifier, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "private readonly options: HttpRetryOptions = {}", optional: true }] });
 // src/client/module.ts
 import {
   Logger as Logger2,
@@ -80,10 +119,16 @@ import {
 } from "@dunx/core";
 
 // src/client/service.ts
-import { Logger, RequestContext } from "@dunx/core";
+import {
+  Logger,
+  RequestContext,
+  ResilienceOptions,
+  ResiliencePolicy
+} from "@dunx/core";
 import { UrlHelper } from "@arkv/shared";
 
 // src/client/json.ts
+import { isPlainObject } from "@dunx/core";
 var safeStringify = (value) => {
   const seen = new WeakSet;
   return JSON.stringify(value, (_key, entry) => {
@@ -102,69 +147,57 @@ var isJsonBody = (payload) => {
     return typeof payload !== "string";
   return !(payload instanceof FormData || payload instanceof URLSearchParams || payload instanceof Blob || payload instanceof ArrayBuffer || payload instanceof ReadableStream || ArrayBuffer.isView(payload));
 };
-
-// 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)
+var readBody = async (response) => {
+  const text = await response.text();
+  if (text === "")
     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 >= HttpStatusCode2.INTERNAL_SERVER_ERROR || status === HttpStatusCode2.REQUEST_TIMEOUT || status === HttpStatusCode2.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)
-    };
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
   }
-  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);
+
+// src/client/sse.ts
+async function* sseData(body) {
+  const decoder = new TextDecoder;
+  let buffer = "";
+  for await (const chunk of body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let newline = buffer.indexOf(`
+`);
+    while (newline !== -1) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      newline = buffer.indexOf(`
+`);
+      if (!line.startsWith("data:"))
+        continue;
+      const data = line.slice(5).trim();
+      if (data === "[DONE]")
+        return;
+      yield data;
     }
   }
-  throw lastError;
-};
+}
+
+class ConnectDeadline {
+  #controller = new AbortController;
+  #timer;
+  constructor(ms, target) {
+    this.#timer = ms > 0 ? setTimeout(() => {
+      this.#controller.abort(new DOMException(`Connecting to ${target} timed out after ${ms}ms`, "TimeoutError"));
+    }, ms) : undefined;
+  }
+  get signal() {
+    return this.#controller.signal;
+  }
+  clear() {
+    if (this.#timer !== undefined)
+      clearTimeout(this.#timer);
+  }
+}
+Object.defineProperty(ConnectDeadline, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "ms: number" }, { unresolved: "target: string" }] });
 
 // src/client/service.ts
 class HttpService extends UrlHelper {
@@ -184,12 +217,14 @@ class HttpService extends UrlHelper {
     let status;
     const { body, serialised } = this.bodyFor(config.payload);
     const replayable = !(config.payload instanceof ReadableStream);
-    const attempt = async () => {
+    const attempt = async (signal) => {
       attempts += 1;
-      const response = await this.send(config, url, body, serialised);
+      const response = await this.send(config, url, body, serialised, signal);
       status = response.status;
       if (!response.ok) {
-        throw new FetchError(response.status, response.statusText, await readBody(response), {
+        throw new FetchError(response.status, response.statusText, await readBody(response).catch(() => {
+          return;
+        }), {
           method: config.method,
           url: url.href,
           headers: response.headers
@@ -198,15 +233,16 @@ class HttpService extends UrlHelper {
       return await readBody(response);
     };
     const describe = () => `${config.method} ${url.href}`;
+    const policy = this.policyFor(config, {
+      ...this.options.retry,
+      ...config.retry,
+      ...replayable ? {} : { maxRetries: 0 }
+    });
     try {
       const result = await this.requestContext.runWithContext({
         ...config.flow === undefined ? {} : { flow: config.flow },
         event: config.path ?? url.pathname
-      }, () => executeWithRetry(attempt, {
-        ...this.options.retry,
-        ...config.retry,
-        ...replayable ? {} : { maxRetries: 0 }
-      }));
+      }, () => policy.run(attempt));
       this.logger.debug(`${describe()} succeeded`, {
         status,
         attempts,
@@ -265,30 +301,23 @@ class HttpService extends UrlHelper {
     const method = config.method ?? "POST";
     const startedAt = Date.now();
     const { body, serialised } = this.bodyFor(config.payload);
-    const response = await this.send({ ...config, method }, url, body, serialised, "text/event-stream");
+    const deadline = new ConnectDeadline(config.timeoutMs ?? this.options.timeoutMs, url.href);
+    let response;
+    try {
+      const policy = this.policyFor({ ...config, timeoutMs: 0 }, {
+        maxRetries: 0
+      });
+      response = await policy.run((signal) => this.send({ ...config, method }, url, body, serialised, AbortSignal.any([signal, deadline.signal]), "text/event-stream"));
+    } finally {
+      deadline.clear();
+    }
     if (!response.ok || response.body === null) {
-      throw new FetchError(response.status, response.statusText, await readBody(response), { method, url: url.href, headers: response.headers });
+      throw new FetchError(response.status, response.statusText, await readBody(response).catch(() => {
+        return;
+      }), { method, url: url.href, headers: response.headers });
     }
-    const decoder = new TextDecoder;
-    let buffer = "";
     try {
-      for await (const chunk of response.body) {
-        buffer += decoder.decode(chunk, { stream: true });
-        let newline = buffer.indexOf(`
-`);
-        while (newline !== -1) {
-          const line = buffer.slice(0, newline).trim();
-          buffer = buffer.slice(newline + 1);
-          newline = buffer.indexOf(`
-`);
-          if (!line.startsWith("data:"))
-            continue;
-          const data = line.slice(5).trim();
-          if (data === "[DONE]")
-            return;
-          yield data;
-        }
-      }
+      yield* sseData(response.body);
     } finally {
       this.logger.debug(`SSE ${method} ${url.href} closed`, {
         elapsedMs: Date.now() - startedAt
@@ -313,6 +342,14 @@ class HttpService extends UrlHelper {
       ...config.queryParams === undefined ? {} : { queryParams: config.queryParams }
     });
   }
+  policyFor(config, retry) {
+    return new ResiliencePolicy(new ResilienceOptions({
+      timeoutMs: config.timeoutMs ?? this.options.timeoutMs,
+      ...config.signal === undefined ? {} : { signal: config.signal },
+      retry,
+      classifier: new HttpRetryClassifier(retry)
+    }));
+  }
   bodyFor(payload) {
     if (payload === undefined || payload === null) {
       return { body: undefined, serialised: "", json: false };
@@ -323,7 +360,7 @@ class HttpService extends UrlHelper {
     const serialised = JSON.stringify(payload);
     return { body: serialised, serialised, json: true };
   }
-  async send(config, url, body, serialised, accept = "application/json") {
+  async send(config, url, body, serialised, signal, accept = "application/json") {
     const trace = this.options.propagateTrace ? this.requestContext.getContext() : undefined;
     const headers = {
       accept,
@@ -345,17 +382,12 @@ class HttpService extends UrlHelper {
       }),
       ...config.headers
     };
-    const timeoutMs = config.timeoutMs ?? this.options.timeoutMs;
-    const signals = [
-      ...timeoutMs > 0 ? [AbortSignal.timeout(timeoutMs)] : [],
-      ...config.signal === undefined ? [] : [config.signal]
-    ];
     try {
       return await fetch(url.href, {
         method: config.method,
         headers,
         ...body === undefined ? {} : { body },
-        ...signals.length === 0 ? {} : { signal: AbortSignal.any(signals) },
+        signal,
         ...this.options.fetchOptions
       });
     } catch (error) {
@@ -366,16 +398,6 @@ class HttpService extends UrlHelper {
 }
 Object.defineProperty(HttpService, Symbol.for("dunx.deps"), { value: () => [HttpClientOptions, Logger, RequestContext] });
 var urlOf = (url) => url === undefined ? {} : { url };
-var readBody = async (response) => {
-  const text = await response.text().catch(() => "");
-  if (text === "")
-    return;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-};
 var describeError = (error) => {
   if (error instanceof FetchError) {
     return {
@@ -458,6 +480,7 @@ export {
   FetchTransportError,
   HttpClientOptions,
   HttpModule,
+  HttpRetryClassifier,
   HttpService,
   httpClient
 };

package/dist/server/options.d.ts

@@ -146,7 +146,7 @@ export interface HttpOptions extends AppOptions {
      * and never both. The pair without a `gatewayPort` is a boot error.
      *
      * `0` takes any free port and is the one value that does not warn when no
-     * gateway is declared. See docs/guide/19-deployment.md.
+     * gateway is declared. See docs/guide/20-deployment.md.
      */
     readonly gatewayPort?: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/http",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "description": "Bun.serve adapter for the dunx framework: controllers, middleware and WebSocket gateways",
   "keywords": [
     "bun",
@@ -65,7 +65,7 @@
     "@opentelemetry/sdk-trace-node": "2.11.0"
   },
   "peerDependencies": {
-    "@dunx/core": "^3.5.1",
+    "@dunx/core": "^3.6.0",
     "@types/bun": ">=1.4.1"
   },
   "peerDependenciesMeta": {