fetch-retrier 0.4.4 → 0.5.0

package/.devcontainer/devcontainer.json

@@ -1,14 +1,15 @@
 {
   "name": "dev-fetch-retrier",
-  "image": "mcr.microsoft.com/devcontainers/base:bookworm",
+  "image": "mcr.microsoft.com/devcontainers/base:trixie",
   "features": {
     "ghcr.io/devcontainers/features/common-utils:2": {
       "username": "developer",
       "upgradePackages": true
     },
     "ghcr.io/devcontainers/features/git:1": {},
-    "ghcr.io/devcontainers/features/node:1": {
-      "version": "24"
+    "ghcr.io/devcontainers/features/node:2": {
+      "version": "24",
+      "npmVersion": "12"
     }
   },
   "workspaceMount": "source=${localWorkspaceFolder},target=/workspace,type=bind",

package/README.md

@@ -1,24 +1,25 @@
 # Fetch Retrier
 
-A lightweight wrapper around `fetch` that adds **retries**, **per-attempt timeout**, **full jitter** backoff, and **option validation**. Pass standard `RequestInit` options (`method`, `body`, `credentials`, and more) for POST/PUT APIs and other HTTP calls that may be rate-limited or temporarily unavailable.
-
 [![npm version](https://img.shields.io/npm/v/fetch-retrier.svg)](https://www.npmjs.com/package/fetch-retrier)
 [![npm downloads](https://img.shields.io/npm/dm/fetch-retrier.svg)](https://www.npmjs.com/package/fetch-retrier)
 [![build](https://github.com/gammarers-labs/fetch-retrier/actions/workflows/build.yml/badge.svg)](https://github.com/gammarers-labs/fetch-retrier/actions/workflows/build.yml)
 [![release](https://github.com/gammarers-labs/fetch-retrier/actions/workflows/release.yml/badge.svg)](https://github.com/gammarers-labs/fetch-retrier/actions/workflows/release.yml)
 
+A lightweight wrapper around `fetch` that adds **retries**, **per-attempt timeout**, **Retry-After** support, **full jitter** backoff, and **option validation**. Pass standard `RequestInit` options (`method`, `body`, `credentials`, and more) for POST/PUT APIs and other HTTP calls that may be rate-limited or temporarily unavailable.
+
 ## Features
 
 - **Configurable retries** – Set the maximum number of attempts per request (`retries >= 1`).
 - **Per-attempt timeout** – Abort each attempt when it exceeds a given duration (`timeoutMs > 0`).
-- **Full jitter backoff** – Exponential backoff with random jitter (AWS-style) between retries (`baseBackoffMs >= 0`).
+- **Retry-After support** – On HTTP retries, prefers a valid `Retry-After` header (delta-seconds or HTTP-date); falls back to full jitter when absent or invalid.
+- **Full jitter backoff** – Exponential backoff with random jitter (AWS-style) for abort/network retries and as the HTTP fallback (`baseBackoffMs >= 0`).
 - **Option validation** – Invalid numeric options throw `FetchRetrierInvalidOptionsError` at call time.
 - **RequestInit forwarding** – Pass `method`, `body`, `credentials`, `redirect`, and other `fetch` options via `init` on every attempt.
 - **Header shorthand** – Optional top-level `headers` override `init.headers` when both are set.
 - **Default retry policy** – Retries transient HTTP statuses (408, 425, 429, 500, 502, 503, 504) via `defaultShouldRetry` and `DEFAULT_RETRYABLE_HTTP_STATUSES`.
-- **Extensible retry predicate** – Compose `defaultShouldRetry` with custom `shouldRetry` logic.
+- **Extensible retry predicate** – Compose `defaultShouldRetry` with custom `shouldRetry` logic (receives response body text).
 - **External cancellation** – Pass an `AbortSignal` to cancel in-flight requests.
-- **Typed errors** – `FetchRetrierHttpError`, `FetchRetrierNetworkError`, `FetchRetrierAbortError`, `FetchRetrierInvalidOptionsError`, and related classes.
+- **Typed errors** – `FetchRetrierHttpError` (with `status` and `body`), `FetchRetrierNetworkError`, `FetchRetrierAbortError`, `FetchRetrierInvalidOptionsError`, and related classes.
 - **TypeScript** – Exported types including `RequestOptions` and `FetchInitOptions`.
 
 ## Installation
@@ -52,10 +53,7 @@ const options: RequestOptions = {
 };
 
 const response = await fetchRetrier('https://api.example.com/data', options);
-
-if (response.ok) {
-  const data = await response.json();
-}
+const data = await response.json();
 ```
 
 ### POST with JSON body (`init`)
@@ -82,7 +80,7 @@ The same `init` (including `body`) is applied on every retry attempt. Per-attemp
 
 ### Custom retry logic
 
-Extend the default predicate instead of reimplementing the status list:
+`shouldRetry` runs only when `response.ok` is false, after `response.text()`. Extend the default predicate instead of reimplementing the status list:
 
 ```typescript
 import {
@@ -97,7 +95,8 @@ const response = await fetchRetrier('https://api.example.com/data', {
   baseBackoffMs: 500,
   shouldRetry: (res, body) => {
     if (defaultShouldRetry(res, body)) return true;
-    if (res.status === 200 && body.includes('"retry": true')) return true;
+    if (res.status === 418) return true;
+    if (body.includes('"retryable":true')) return true;
     return false;
   },
 });
@@ -105,6 +104,27 @@ const response = await fetchRetrier('https://api.example.com/data', {
 // DEFAULT_RETRYABLE_HTTP_STATUSES is [408, 425, 429, 500, 502, 503, 504]
 ```
 
+### Handling HTTP errors
+
+On a non-OK response that is not retried (or after retries are exhausted), `FetchRetrierHttpError` includes both `status` and the already-read `body`:
+
+```typescript
+import { fetchRetrier, FetchRetrierHttpError } from 'fetch-retrier';
+
+try {
+  await fetchRetrier('https://api.example.com/data', {
+    retries: 3,
+    timeoutMs: 5000,
+    baseBackoffMs: 1000,
+  });
+} catch (err) {
+  if (err instanceof FetchRetrierHttpError) {
+    console.error(err.status, err.body);
+  }
+  throw err;
+}
+```
+
 ### Cancellation with `AbortController`
 
 ```typescript
@@ -124,10 +144,10 @@ await fetchRetrier('https://api.example.com/data', {
 
 - **Success** – If `response.ok` is true, the response is returned immediately.
 - **Invalid options** – If `retries < 1`, `timeoutMs <= 0`, or `baseBackoffMs < 0`, `FetchRetrierInvalidOptionsError` is thrown before any request is made.
-- **Retriable failure** – If the response is not OK and `shouldRetry(response, body)` returns true, the client waits (full jitter backoff) and retries until `retries` is exhausted. On the last attempt, `FetchRetrierHttpError` is thrown (includes `status`).
-- **Non-retriable failure** – If `shouldRetry` returns false, `FetchRetrierHttpError` is thrown immediately (e.g. `Non-retriable HTTP error: 404`).
-- **Timeout** – If a request exceeds `timeoutMs`, it is aborted and retried until `retries` is exhausted; the final failure is `FetchRetrierAbortError`.
-- **Network / TypeError** – Network errors are retried with backoff; after the last attempt, `FetchRetrierNetworkError` is thrown with the original error as `cause`.
+- **Retriable failure** – If the response is not OK and `shouldRetry(response, body)` returns true, the client waits and retries until `retries` is exhausted. Wait prefers a valid `Retry-After` header (delta-seconds or HTTP-date); otherwise uses full jitter. On the last attempt, `FetchRetrierHttpError` is thrown (includes `status` and `body`).
+- **Non-retriable failure** – If `shouldRetry` returns false, `FetchRetrierHttpError` is thrown immediately with `status` and `body` (e.g. `Non-retriable HTTP error: 404`).
+- **Timeout** – If a request exceeds `timeoutMs`, it is aborted and retried with full jitter until `retries` is exhausted; the final failure is `FetchRetrierAbortError`.
+- **Network / TypeError** – Network errors are retried with full jitter; after the last attempt, `FetchRetrierNetworkError` is thrown with the original error as `cause`.
 - **Already aborted signal** – If `signal` is already aborted before an attempt starts, `FetchRetrierAlreadyAbortedError` is thrown (no attempt is made).
 
 ## Options
@@ -136,7 +156,7 @@ await fetchRetrier('https://api.example.com/data', {
 |--------|------|----------|-------------|
 | `retries` | `number` | Yes | Maximum number of attempts (including the first request). Must be `>= 1`. |
 | `timeoutMs` | `number` | Yes | Timeout in milliseconds for each attempt. Exceeded attempts are aborted and retried. Must be `> 0`. |
-| `baseBackoffMs` | `number` | Yes | Base delay in milliseconds for backoff. Delay is capped at `baseBackoffMs * 2^attempt` and randomized (full jitter). Must be `>= 0` (`0` skips backoff delay). |
+| `baseBackoffMs` | `number` | Yes | Base delay in milliseconds for full jitter when `Retry-After` is absent or invalid (also used for abort/network retries). Cap is `baseBackoffMs * 2^attempt`, randomized. Must be `>= 0` (`0` skips backoff delay when falling back). |
 | `init` | `FetchInitOptions` | No | `fetch` options forwarded to every attempt: `method`, `body`, `credentials`, `redirect`, `mode`, `cache`, etc. `signal` is reserved for internal timeout and cancellation. |
 | `headers` | `Record<string, string>` | No | Headers sent on every attempt. Overrides `init.headers` when both are set. |
 | `signal` | `AbortSignal` | No | External abort signal. If already aborted, `FetchRetrierAlreadyAbortedError` is thrown. If aborted during an attempt, the request is aborted and retried until `retries` is exhausted. |
@@ -148,6 +168,7 @@ await fetchRetrier('https://api.example.com/data', {
 |--------|-------------|
 | `defaultShouldRetry` | Default `shouldRetry` predicate; compose with custom logic. |
 | `DEFAULT_RETRYABLE_HTTP_STATUSES` | Readonly list of HTTP status codes retried by default. |
+| `parseRetryAfterMs` | Parses a `Retry-After` header (delta-seconds or HTTP-date) into a delay in milliseconds. |
 
 ## Requirements
 

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 /**
- * Retry-enabled `fetch` wrapper with per-attempt timeout, full-jitter backoff, option validation, and typed errors.
+ * Retry-enabled `fetch` wrapper with per-attempt timeout, Retry-After support, full-jitter backoff,
+ * option validation, and typed errors.
  *
  * @module fetch-retrier
  */
@@ -12,7 +13,8 @@
  */
 export type FetchInitOptions = Omit<RequestInit, 'signal'>;
 /**
- * Options for {@link fetchRetrier}: retry policy, timeout, backoff, request payload, and cancellation.
+ * Options for {@link fetchRetrier}: retry policy, timeout, backoff (including `Retry-After`),
+ * request payload, and cancellation.
  *
  * Request shape is built as `{ ...init, headers?, signal }` on each attempt. Top-level `headers`
  * override `init.headers` when both are provided.
@@ -42,8 +44,9 @@ export interface RequestOptions {
      */
     timeoutMs: number;
     /**
-     * Base backoff in milliseconds for full jitter. The cap for attempt `n` is `baseBackoffMs * 2^n`.
-     * Must be `>= 0` (`0` skips backoff delay between attempts).
+     * Base backoff in milliseconds for full jitter when `Retry-After` is absent or invalid.
+     * The cap for attempt `n` is `baseBackoffMs * 2^n`.
+     * Must be `>= 0` (`0` skips backoff delay between attempts when falling back to jitter).
      */
     baseBackoffMs: number;
     /**
@@ -85,16 +88,22 @@ export declare class FetchRetrierAlreadyAbortedError extends FetchRetrierAbortEr
 /**
  * Error thrown when the server returns a non-OK HTTP status and no further retry is performed.
  *
+ * Carries the last response `status` and the body text already consumed via `response.text()`
+ * (the same text passed to {@link RequestOptions.shouldRetry}).
+ *
  * @property status - HTTP status code from the last non-OK response
+ * @property body - Response body text already read via `response.text()` for that attempt
  */
 export declare class FetchRetrierHttpError extends Error {
     readonly status: number;
+    readonly body: string;
     readonly name: string;
     /**
      * @param message - Error description
      * @param status - HTTP status code from the last non-OK response
+     * @param body - Response body text already read via `response.text()` for that attempt
      */
-    constructor(message: string, status: number);
+    constructor(message: string, status: number, body: string);
 }
 /**
  * Error thrown when a fetch fails with a network-level error (e.g. DNS failure, connection refused).
@@ -153,12 +162,15 @@ export declare const DEFAULT_RETRYABLE_HTTP_STATUSES: readonly number[];
  */
 export declare const defaultShouldRetry: (response: Response, _body: string) => boolean;
 /**
- * Wraps `fetch` with retries, per-attempt timeout, full-jitter backoff, and optional cancellation.
+ * Wraps `fetch` with retries, per-attempt timeout, Retry-After support, full-jitter backoff, and
+ * optional cancellation.
  *
  * Each attempt calls `fetch(url, { ...options.init, headers?, signal })` with an internal
  * {@link AbortSignal} for `timeoutMs`. Non-OK responses are retried when `shouldRetry` returns
- * `true` (default: {@link DEFAULT_RETRYABLE_HTTP_STATUSES}). The same {@link FetchInitOptions} (including `body`) is reused
- * on every attempt.
+ * `true` (default: {@link defaultShouldRetry}). Between HTTP retries, a valid `Retry-After`
+ * header (delta-seconds or HTTP-date) is preferred over full jitter; abort and network retries
+ * always use full jitter. The same {@link FetchInitOptions} (including `body`) is reused on
+ * every attempt.
  *
  * @param url - Request URL passed to `fetch`
  * @param options - {@link RequestOptions} controlling retries, timeout, request init, and cancellation
@@ -166,8 +178,21 @@ export declare const defaultShouldRetry: (response: Response, _body: string) =>
  * @throws {FetchRetrierInvalidOptionsError} If `retries < 1`, `timeoutMs <= 0`, or `baseBackoffMs < 0`
  * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt
  * @throws {FetchRetrierHttpError} On a non-OK response that is not retried or after the last attempt
+ *   (includes `status` and `body`)
  * @throws {FetchRetrierNetworkError} On a network `TypeError` after the last attempt
  * @throws {FetchRetrierAbortError} On timeout or external abort after the last attempt
  * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)
  */
 export declare const fetchRetrier: (url: string, options: RequestOptions) => Promise<Response>;
+/**
+ * Parses a `Retry-After` header value into a delay in milliseconds.
+ *
+ * Supports RFC 7231 forms: non-negative integer delta-seconds, or an HTTP-date. Empty values,
+ * non-integer numerics (e.g. floats or negatives), and unparsable dates yield `undefined` so
+ * callers can fall back to full jitter. An HTTP-date in the past yields `0`.
+ *
+ * @param value - Raw `Retry-After` header value
+ * @param nowMs - Current time in milliseconds (injectable for tests)
+ * @returns Delay in milliseconds, or `undefined` when the value cannot be parsed
+ */
+export declare const parseRetryAfterMs: (value: string, nowMs?: number) => number | undefined;

package/lib/index.js

@@ -1,11 +1,12 @@
 "use strict";
 /**
- * Retry-enabled `fetch` wrapper with per-attempt timeout, full-jitter backoff, option validation, and typed errors.
+ * Retry-enabled `fetch` wrapper with per-attempt timeout, Retry-After support, full-jitter backoff,
+ * option validation, and typed errors.
  *
  * @module fetch-retrier
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchRetrier = exports.defaultShouldRetry = exports.DEFAULT_RETRYABLE_HTTP_STATUSES = exports.FetchRetrierUnreachableError = exports.FetchRetrierInvalidOptionsError = exports.FetchRetrierNetworkError = exports.FetchRetrierHttpError = exports.FetchRetrierAlreadyAbortedError = exports.FetchRetrierAbortError = void 0;
+exports.parseRetryAfterMs = exports.fetchRetrier = exports.defaultShouldRetry = exports.DEFAULT_RETRYABLE_HTTP_STATUSES = exports.FetchRetrierUnreachableError = exports.FetchRetrierInvalidOptionsError = exports.FetchRetrierNetworkError = exports.FetchRetrierHttpError = exports.FetchRetrierAlreadyAbortedError = exports.FetchRetrierAbortError = void 0;
 /**
  * Error thrown when a request is cancelled by timeout or an external {@link AbortSignal}.
  */
@@ -37,16 +38,22 @@ exports.FetchRetrierAlreadyAbortedError = FetchRetrierAlreadyAbortedError;
 /**
  * Error thrown when the server returns a non-OK HTTP status and no further retry is performed.
  *
+ * Carries the last response `status` and the body text already consumed via `response.text()`
+ * (the same text passed to {@link RequestOptions.shouldRetry}).
+ *
  * @property status - HTTP status code from the last non-OK response
+ * @property body - Response body text already read via `response.text()` for that attempt
  */
 class FetchRetrierHttpError extends Error {
     /**
      * @param message - Error description
      * @param status - HTTP status code from the last non-OK response
+     * @param body - Response body text already read via `response.text()` for that attempt
      */
-    constructor(message, status) {
+    constructor(message, status, body) {
         super(message);
         this.status = status;
+        this.body = body;
         this.name = 'FetchRetrierHttpError';
         Object.setPrototypeOf(this, FetchRetrierHttpError.prototype);
     }
@@ -144,12 +151,15 @@ const validateRequestOptions = (options) => {
     }
 };
 /**
- * Wraps `fetch` with retries, per-attempt timeout, full-jitter backoff, and optional cancellation.
+ * Wraps `fetch` with retries, per-attempt timeout, Retry-After support, full-jitter backoff, and
+ * optional cancellation.
  *
  * Each attempt calls `fetch(url, { ...options.init, headers?, signal })` with an internal
  * {@link AbortSignal} for `timeoutMs`. Non-OK responses are retried when `shouldRetry` returns
- * `true` (default: {@link DEFAULT_RETRYABLE_HTTP_STATUSES}). The same {@link FetchInitOptions} (including `body`) is reused
- * on every attempt.
+ * `true` (default: {@link defaultShouldRetry}). Between HTTP retries, a valid `Retry-After`
+ * header (delta-seconds or HTTP-date) is preferred over full jitter; abort and network retries
+ * always use full jitter. The same {@link FetchInitOptions} (including `body`) is reused on
+ * every attempt.
  *
  * @param url - Request URL passed to `fetch`
  * @param options - {@link RequestOptions} controlling retries, timeout, request init, and cancellation
@@ -157,6 +167,7 @@ const validateRequestOptions = (options) => {
  * @throws {FetchRetrierInvalidOptionsError} If `retries < 1`, `timeoutMs <= 0`, or `baseBackoffMs < 0`
  * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt
  * @throws {FetchRetrierHttpError} On a non-OK response that is not retried or after the last attempt
+ *   (includes `status` and `body`)
  * @throws {FetchRetrierNetworkError} On a network `TypeError` after the last attempt
  * @throws {FetchRetrierAbortError} On timeout or external abort after the last attempt
  * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)
@@ -192,12 +203,12 @@ const fetchRetrier = async (url, options) => {
             const isContinue = shouldRetry(res, text);
             if (isContinue) {
                 if (attempt === retries) {
-                    throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status);
+                    throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status, text);
                 }
-                await wait(fullJitter(baseBackoffMs, attempt));
+                await wait(resolveRetryDelayMs(res, baseBackoffMs, attempt));
             }
             else {
-                throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status);
+                throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status, text);
             }
         }
         catch (err) {
@@ -233,6 +244,9 @@ const wait = (ms) => {
 /**
  * Full jitter backoff: random delay in `[0, base * 2^attempt)` ms (AWS-recommended pattern).
  *
+ * Used between abort/network retries, and as the fallback when HTTP retries lack a usable
+ * `Retry-After` header.
+ *
  * @param base - Base backoff in milliseconds
  * @param attempt - 1-based attempt index (first retry uses `attempt === 1`)
  * @returns Wait duration in milliseconds before the next attempt
@@ -241,4 +255,58 @@ const fullJitter = (base, attempt) => {
     const cap = base * Math.pow(2, attempt);
     return Math.floor(Math.random() * cap);
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Retry-enabled `fetch` wrapper with per-attempt timeout, full-jitter backoff, option validation, and typed errors.\n *\n * @module fetch-retrier\n */\n\n/**\n * `fetch` options forwarded to every attempt, excluding `signal`.\n *\n * Use for `method`, `body`, `credentials`, `redirect`, `mode`, `cache`, and other\n * {@link https://developer.mozilla.org/en-US/docs/Web/API/RequestInit | RequestInit} fields.\n * Per-attempt abort and timeout are handled internally via `signal` and must not be set here.\n */\nexport type FetchInitOptions = Omit<RequestInit, 'signal'>;\n\n/**\n * Options for {@link fetchRetrier}: retry policy, timeout, backoff, request payload, and cancellation.\n *\n * Request shape is built as `{ ...init, headers?, signal }` on each attempt. Top-level `headers`\n * override `init.headers` when both are provided.\n *\n * Numeric fields are validated when {@link fetchRetrier} is called; invalid values throw\n * {@link FetchRetrierInvalidOptionsError}.\n */\nexport interface RequestOptions {\n  /**\n   * HTTP headers sent on every attempt.\n   * When `init.headers` is also set, these values take precedence for duplicate keys.\n   */\n  headers?: Record<string, string>;\n  /**\n   * Additional {@link FetchInitOptions} merged into each `fetch` call (e.g. POST `method` and JSON `body`).\n   * The same `init` is reused across retries.\n   */\n  init?: FetchInitOptions;\n  /**\n   * Maximum number of attempts, including the first.\n   * Must be `>= 1`.\n   */\n  retries: number;\n  /**\n   * Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded.\n   * Must be `> 0`.\n   */\n  timeoutMs: number;\n  /**\n   * Base backoff in milliseconds for full jitter. The cap for attempt `n` is `baseBackoffMs * 2^n`.\n   * Must be `>= 0` (`0` skips backoff delay between attempts).\n   */\n  baseBackoffMs: number;\n  /**\n   * Optional external {@link AbortSignal}. When aborted, the in-flight request is aborted; on the\n   * final attempt, cancellation surfaces as {@link FetchRetrierAbortError}.\n   */\n  signal?: AbortSignal;\n  /**\n   * Invoked after `response.text()` when `response.ok` is false.\n   * Return `true` to schedule another attempt (until `retries` is exhausted).\n   * Default: {@link defaultShouldRetry} (see {@link DEFAULT_RETRYABLE_HTTP_STATUSES}).\n   *\n   * @param response - Non-OK response from the current attempt\n   * @param body - Response body text from `response.text()`\n   * @returns `true` to schedule another attempt (until `retries` is exhausted)\n   */\n  shouldRetry?: (response: Response, body: string) => boolean;\n}\n\n/**\n * Error thrown when a request is cancelled by timeout or an external {@link AbortSignal}.\n */\nexport class FetchRetrierAbortError extends Error {\n  override readonly name: string = 'FetchRetrierAbortError';\n  /**\n   * @param message - Human-readable reason (default: `'Aborted'`)\n   */\n  constructor(message = 'Aborted') {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierAbortError.prototype);\n  }\n}\n\n/**\n * Error thrown when {@link RequestOptions.signal} is already aborted before an attempt starts.\n */\nexport class FetchRetrierAlreadyAbortedError extends FetchRetrierAbortError {\n  override readonly name: string = 'FetchRetrierAlreadyAbortedError';\n  /**\n   * @param message - Human-readable reason (default: `'Signal was already aborted'`)\n   */\n  constructor(message = 'Signal was already aborted') {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierAlreadyAbortedError.prototype);\n  }\n}\n\n/**\n * Error thrown when the server returns a non-OK HTTP status and no further retry is performed.\n *\n * @property status - HTTP status code from the last non-OK response\n */\nexport class FetchRetrierHttpError extends Error {\n  override readonly name: string = 'FetchRetrierHttpError';\n  /**\n   * @param message - Error description\n   * @param status - HTTP status code from the last non-OK response\n   */\n  constructor(\n    message: string,\n    public readonly status: number,\n  ) {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierHttpError.prototype);\n  }\n}\n\n/**\n * Error thrown when a fetch fails with a network-level error (e.g. DNS failure, connection refused).\n *\n * @property cause - Original error from the underlying `fetch`, when available\n */\nexport class FetchRetrierNetworkError extends Error {\n  override readonly name: string = 'FetchRetrierNetworkError';\n  /**\n   * @param message - Human-readable reason (default: `'Network error'`)\n   * @param cause - Original error from the underlying `fetch`, when available\n   */\n  constructor(message = 'Network error', public readonly cause?: unknown) {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierNetworkError.prototype);\n  }\n}\n\n/**\n * Error thrown when {@link RequestOptions} contains invalid numeric values.\n *\n * Subclass of {@link TypeError} for compatibility with `instanceof TypeError`. Distinct from\n * network-level `TypeError` values thrown by `fetch`, which are retried and surfaced as\n * {@link FetchRetrierNetworkError} after the last attempt.\n */\nexport class FetchRetrierInvalidOptionsError extends TypeError {\n  override readonly name: string = 'FetchRetrierInvalidOptionsError';\n  /**\n   * @param message - Human-readable reason describing the invalid option\n   */\n  constructor(message: string) {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierInvalidOptionsError.prototype);\n  }\n}\n\n/**\n * Error thrown when an internal invariant fails (should not happen in normal use).\n */\nexport class FetchRetrierUnreachableError extends Error {\n  override readonly name: string = 'FetchRetrierUnreachableError';\n  /**\n   * @param message - Human-readable reason (default: `'Unreachable'`)\n   */\n  constructor(message = 'Unreachable') {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierUnreachableError.prototype);\n  }\n}\n\n/**\n * HTTP status codes retried by default when {@link RequestOptions.shouldRetry} is omitted.\n *\n * Includes transient client/server errors: 408, 425, 429, and common 5xx gateway or overload responses.\n */\nexport const DEFAULT_RETRYABLE_HTTP_STATUSES: readonly number[] = [408, 425, 429, 500, 502, 503, 504];\n\n/**\n * Default {@link RequestOptions.shouldRetry}: retries responses whose status is in\n * {@link DEFAULT_RETRYABLE_HTTP_STATUSES}.\n *\n * Compose with custom logic, for example:\n * `(res, body) => defaultShouldRetry(res, body) || res.status === 418`.\n *\n * @param response - Response from the failed attempt\n * @param _body - Response body text (unused by the default predicate)\n * @returns `true` when another attempt should be scheduled\n */\nexport const defaultShouldRetry = (response: Response, _body: string): boolean => {\n  return DEFAULT_RETRYABLE_HTTP_STATUSES.includes(response.status);\n};\n\n/**\n * Validates retry policy numeric fields on {@link RequestOptions}.\n *\n * Constraints: `retries >= 1`, `timeoutMs > 0`, `baseBackoffMs >= 0`.\n *\n * @param options - Options whose `retries`, `timeoutMs`, and `baseBackoffMs` are checked\n * @throws {FetchRetrierInvalidOptionsError} When any constraint is violated\n */\nconst validateRequestOptions = (options: Pick<RequestOptions, 'retries' | 'timeoutMs' | 'baseBackoffMs'>): void => {\n  const { retries, timeoutMs, baseBackoffMs } = options;\n\n  if (retries < 1) {\n    throw new FetchRetrierInvalidOptionsError('retries must be >= 1');\n  }\n  if (timeoutMs <= 0) {\n    throw new FetchRetrierInvalidOptionsError('timeoutMs must be > 0');\n  }\n  if (baseBackoffMs < 0) {\n    throw new FetchRetrierInvalidOptionsError('baseBackoffMs must be >= 0');\n  }\n};\n\n/**\n * Wraps `fetch` with retries, per-attempt timeout, full-jitter backoff, and optional cancellation.\n *\n * Each attempt calls `fetch(url, { ...options.init, headers?, signal })` with an internal\n * {@link AbortSignal} for `timeoutMs`. Non-OK responses are retried when `shouldRetry` returns\n * `true` (default: {@link DEFAULT_RETRYABLE_HTTP_STATUSES}). The same {@link FetchInitOptions} (including `body`) is reused\n * on every attempt.\n *\n * @param url - Request URL passed to `fetch`\n * @param options - {@link RequestOptions} controlling retries, timeout, request init, and cancellation\n * @returns The first {@link Response} for which `ok` is `true`\n * @throws {FetchRetrierInvalidOptionsError} If `retries < 1`, `timeoutMs <= 0`, or `baseBackoffMs < 0`\n * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt\n * @throws {FetchRetrierHttpError} On a non-OK response that is not retried or after the last attempt\n * @throws {FetchRetrierNetworkError} On a network `TypeError` after the last attempt\n * @throws {FetchRetrierAbortError} On timeout or external abort after the last attempt\n * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)\n */\nexport const fetchRetrier = async (url: string, options: RequestOptions): Promise<Response> => {\n  const {\n    headers,\n    init,\n    retries,\n    timeoutMs,\n    baseBackoffMs,\n    signal: externalSignal,\n    shouldRetry = defaultShouldRetry,\n  } = options;\n\n  validateRequestOptions({ retries, timeoutMs, baseBackoffMs });\n\n  for (let attempt = 1; attempt <= retries; attempt++) {\n    if (externalSignal?.aborted) {\n      throw new FetchRetrierAlreadyAbortedError();\n    }\n\n    const controller = new AbortController();\n    const timer = setTimeout(() => controller.abort(), timeoutMs);\n\n    const onExternalAbort = (): void => {\n      clearTimeout(timer);\n      controller.abort();\n    };\n\n    if (externalSignal) {\n      externalSignal.addEventListener('abort', onExternalAbort);\n    }\n\n    try {\n      const res = await fetch(url, {\n        ...init,\n        ...(headers !== undefined ? { headers } : {}),\n        signal: controller.signal,\n      });\n\n      clearTimeout(timer);\n      externalSignal?.removeEventListener('abort', onExternalAbort);\n\n      if (res.ok) {\n        return res;\n      }\n\n      const text = await res.text();\n      const isContinue = shouldRetry(res, text);\n\n      if (isContinue) {\n        if (attempt === retries) {\n          throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status);\n        }\n        await wait(fullJitter(baseBackoffMs, attempt));\n      } else {\n        throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status);\n      }\n    } catch (err: unknown) {\n      clearTimeout(timer);\n      externalSignal?.removeEventListener('abort', onExternalAbort);\n\n      if (err instanceof Error && err.name === 'AbortError') {\n        if (attempt === retries) throw err instanceof FetchRetrierAbortError ? err : new FetchRetrierAbortError();\n        await wait(fullJitter(baseBackoffMs, attempt));\n        continue;\n      }\n\n      if (err instanceof TypeError) {\n        if (attempt === retries) throw new FetchRetrierNetworkError('Network error', err);\n        await wait(fullJitter(baseBackoffMs, attempt));\n        continue;\n      }\n\n      throw err;\n    }\n  }\n\n  throw new FetchRetrierUnreachableError();\n};\n\n/**\n * Delays execution for the given duration (used between retry attempts).\n *\n * @param ms - Delay in milliseconds\n * @returns A promise that resolves after `ms`\n */\nconst wait = (ms: number): Promise<void> => {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n};\n\n/**\n * Full jitter backoff: random delay in `[0, base * 2^attempt)` ms (AWS-recommended pattern).\n *\n * @param base - Base backoff in milliseconds\n * @param attempt - 1-based attempt index (first retry uses `attempt === 1`)\n * @returns Wait duration in milliseconds before the next attempt\n */\nconst fullJitter = (base: number, attempt: number): number => {\n  const cap = base * Math.pow(2, attempt);\n  return Math.floor(Math.random() * cap);\n};\n"]}
+/**
+ * Parses a `Retry-After` header value into a delay in milliseconds.
+ *
+ * Supports RFC 7231 forms: non-negative integer delta-seconds, or an HTTP-date. Empty values,
+ * non-integer numerics (e.g. floats or negatives), and unparsable dates yield `undefined` so
+ * callers can fall back to full jitter. An HTTP-date in the past yields `0`.
+ *
+ * @param value - Raw `Retry-After` header value
+ * @param nowMs - Current time in milliseconds (injectable for tests)
+ * @returns Delay in milliseconds, or `undefined` when the value cannot be parsed
+ */
+const parseRetryAfterMs = (value, nowMs = Date.now()) => {
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return undefined;
+    }
+    if (/^\d+$/.test(trimmed)) {
+        return Number.parseInt(trimmed, 10) * 1000;
+    }
+    // Reject other numeric forms (floats, negatives); not valid delta-seconds or HTTP-date.
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+        return undefined;
+    }
+    const dateMs = Date.parse(trimmed);
+    if (Number.isNaN(dateMs)) {
+        return undefined;
+    }
+    return Math.max(0, dateMs - nowMs);
+};
+exports.parseRetryAfterMs = parseRetryAfterMs;
+/**
+ * Chooses the delay before the next HTTP retry: prefer a valid `Retry-After`, else full jitter.
+ *
+ * Reads `response.headers.get('Retry-After')` and parses it with {@link parseRetryAfterMs}.
+ * Missing headers, or values that parse to `undefined`, fall back to {@link fullJitter}.
+ * Abort and network retries do not use this helper.
+ *
+ * @param response - Non-OK response from the current attempt
+ * @param baseBackoffMs - Base backoff passed to {@link fullJitter} when falling back
+ * @param attempt - 1-based attempt index
+ * @param nowMs - Current time in milliseconds (injectable for tests)
+ * @returns Wait duration in milliseconds before the next attempt
+ */
+const resolveRetryDelayMs = (response, baseBackoffMs, attempt, nowMs = Date.now()) => {
+    const header = response.headers?.get('Retry-After');
+    if (header == null) {
+        return fullJitter(baseBackoffMs, attempt);
+    }
+    const fromHeader = (0, exports.parseRetryAfterMs)(header, nowMs);
+    if (fromHeader === undefined) {
+        return fullJitter(baseBackoffMs, attempt);
+    }
+    return fromHeader;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Retry-enabled `fetch` wrapper with per-attempt timeout, Retry-After support, full-jitter backoff,\n * option validation, and typed errors.\n *\n * @module fetch-retrier\n */\n\n/**\n * `fetch` options forwarded to every attempt, excluding `signal`.\n *\n * Use for `method`, `body`, `credentials`, `redirect`, `mode`, `cache`, and other\n * {@link https://developer.mozilla.org/en-US/docs/Web/API/RequestInit | RequestInit} fields.\n * Per-attempt abort and timeout are handled internally via `signal` and must not be set here.\n */\nexport type FetchInitOptions = Omit<RequestInit, 'signal'>;\n\n/**\n * Options for {@link fetchRetrier}: retry policy, timeout, backoff (including `Retry-After`),\n * request payload, and cancellation.\n *\n * Request shape is built as `{ ...init, headers?, signal }` on each attempt. Top-level `headers`\n * override `init.headers` when both are provided.\n *\n * Numeric fields are validated when {@link fetchRetrier} is called; invalid values throw\n * {@link FetchRetrierInvalidOptionsError}.\n */\nexport interface RequestOptions {\n  /**\n   * HTTP headers sent on every attempt.\n   * When `init.headers` is also set, these values take precedence for duplicate keys.\n   */\n  headers?: Record<string, string>;\n  /**\n   * Additional {@link FetchInitOptions} merged into each `fetch` call (e.g. POST `method` and JSON `body`).\n   * The same `init` is reused across retries.\n   */\n  init?: FetchInitOptions;\n  /**\n   * Maximum number of attempts, including the first.\n   * Must be `>= 1`.\n   */\n  retries: number;\n  /**\n   * Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded.\n   * Must be `> 0`.\n   */\n  timeoutMs: number;\n  /**\n   * Base backoff in milliseconds for full jitter when `Retry-After` is absent or invalid.\n   * The cap for attempt `n` is `baseBackoffMs * 2^n`.\n   * Must be `>= 0` (`0` skips backoff delay between attempts when falling back to jitter).\n   */\n  baseBackoffMs: number;\n  /**\n   * Optional external {@link AbortSignal}. When aborted, the in-flight request is aborted; on the\n   * final attempt, cancellation surfaces as {@link FetchRetrierAbortError}.\n   */\n  signal?: AbortSignal;\n  /**\n   * Invoked after `response.text()` when `response.ok` is false.\n   * Return `true` to schedule another attempt (until `retries` is exhausted).\n   * Default: {@link defaultShouldRetry} (see {@link DEFAULT_RETRYABLE_HTTP_STATUSES}).\n   *\n   * @param response - Non-OK response from the current attempt\n   * @param body - Response body text from `response.text()`\n   * @returns `true` to schedule another attempt (until `retries` is exhausted)\n   */\n  shouldRetry?: (response: Response, body: string) => boolean;\n}\n\n/**\n * Error thrown when a request is cancelled by timeout or an external {@link AbortSignal}.\n */\nexport class FetchRetrierAbortError extends Error {\n  override readonly name: string = 'FetchRetrierAbortError';\n  /**\n   * @param message - Human-readable reason (default: `'Aborted'`)\n   */\n  constructor(message = 'Aborted') {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierAbortError.prototype);\n  }\n}\n\n/**\n * Error thrown when {@link RequestOptions.signal} is already aborted before an attempt starts.\n */\nexport class FetchRetrierAlreadyAbortedError extends FetchRetrierAbortError {\n  override readonly name: string = 'FetchRetrierAlreadyAbortedError';\n  /**\n   * @param message - Human-readable reason (default: `'Signal was already aborted'`)\n   */\n  constructor(message = 'Signal was already aborted') {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierAlreadyAbortedError.prototype);\n  }\n}\n\n/**\n * Error thrown when the server returns a non-OK HTTP status and no further retry is performed.\n *\n * Carries the last response `status` and the body text already consumed via `response.text()`\n * (the same text passed to {@link RequestOptions.shouldRetry}).\n *\n * @property status - HTTP status code from the last non-OK response\n * @property body - Response body text already read via `response.text()` for that attempt\n */\nexport class FetchRetrierHttpError extends Error {\n  override readonly name: string = 'FetchRetrierHttpError';\n  /**\n   * @param message - Error description\n   * @param status - HTTP status code from the last non-OK response\n   * @param body - Response body text already read via `response.text()` for that attempt\n   */\n  constructor(\n    message: string,\n    public readonly status: number,\n    public readonly body: string,\n  ) {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierHttpError.prototype);\n  }\n}\n\n/**\n * Error thrown when a fetch fails with a network-level error (e.g. DNS failure, connection refused).\n *\n * @property cause - Original error from the underlying `fetch`, when available\n */\nexport class FetchRetrierNetworkError extends Error {\n  override readonly name: string = 'FetchRetrierNetworkError';\n  /**\n   * @param message - Human-readable reason (default: `'Network error'`)\n   * @param cause - Original error from the underlying `fetch`, when available\n   */\n  constructor(message = 'Network error', public readonly cause?: unknown) {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierNetworkError.prototype);\n  }\n}\n\n/**\n * Error thrown when {@link RequestOptions} contains invalid numeric values.\n *\n * Subclass of {@link TypeError} for compatibility with `instanceof TypeError`. Distinct from\n * network-level `TypeError` values thrown by `fetch`, which are retried and surfaced as\n * {@link FetchRetrierNetworkError} after the last attempt.\n */\nexport class FetchRetrierInvalidOptionsError extends TypeError {\n  override readonly name: string = 'FetchRetrierInvalidOptionsError';\n  /**\n   * @param message - Human-readable reason describing the invalid option\n   */\n  constructor(message: string) {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierInvalidOptionsError.prototype);\n  }\n}\n\n/**\n * Error thrown when an internal invariant fails (should not happen in normal use).\n */\nexport class FetchRetrierUnreachableError extends Error {\n  override readonly name: string = 'FetchRetrierUnreachableError';\n  /**\n   * @param message - Human-readable reason (default: `'Unreachable'`)\n   */\n  constructor(message = 'Unreachable') {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierUnreachableError.prototype);\n  }\n}\n\n/**\n * HTTP status codes retried by default when {@link RequestOptions.shouldRetry} is omitted.\n *\n * Includes transient client/server errors: 408, 425, 429, and common 5xx gateway or overload responses.\n */\nexport const DEFAULT_RETRYABLE_HTTP_STATUSES: readonly number[] = [408, 425, 429, 500, 502, 503, 504];\n\n/**\n * Default {@link RequestOptions.shouldRetry}: retries responses whose status is in\n * {@link DEFAULT_RETRYABLE_HTTP_STATUSES}.\n *\n * Compose with custom logic, for example:\n * `(res, body) => defaultShouldRetry(res, body) || res.status === 418`.\n *\n * @param response - Response from the failed attempt\n * @param _body - Response body text (unused by the default predicate)\n * @returns `true` when another attempt should be scheduled\n */\nexport const defaultShouldRetry = (response: Response, _body: string): boolean => {\n  return DEFAULT_RETRYABLE_HTTP_STATUSES.includes(response.status);\n};\n\n/**\n * Validates retry policy numeric fields on {@link RequestOptions}.\n *\n * Constraints: `retries >= 1`, `timeoutMs > 0`, `baseBackoffMs >= 0`.\n *\n * @param options - Options whose `retries`, `timeoutMs`, and `baseBackoffMs` are checked\n * @throws {FetchRetrierInvalidOptionsError} When any constraint is violated\n */\nconst validateRequestOptions = (options: Pick<RequestOptions, 'retries' | 'timeoutMs' | 'baseBackoffMs'>): void => {\n  const { retries, timeoutMs, baseBackoffMs } = options;\n\n  if (retries < 1) {\n    throw new FetchRetrierInvalidOptionsError('retries must be >= 1');\n  }\n  if (timeoutMs <= 0) {\n    throw new FetchRetrierInvalidOptionsError('timeoutMs must be > 0');\n  }\n  if (baseBackoffMs < 0) {\n    throw new FetchRetrierInvalidOptionsError('baseBackoffMs must be >= 0');\n  }\n};\n\n/**\n * Wraps `fetch` with retries, per-attempt timeout, Retry-After support, full-jitter backoff, and\n * optional cancellation.\n *\n * Each attempt calls `fetch(url, { ...options.init, headers?, signal })` with an internal\n * {@link AbortSignal} for `timeoutMs`. Non-OK responses are retried when `shouldRetry` returns\n * `true` (default: {@link defaultShouldRetry}). Between HTTP retries, a valid `Retry-After`\n * header (delta-seconds or HTTP-date) is preferred over full jitter; abort and network retries\n * always use full jitter. The same {@link FetchInitOptions} (including `body`) is reused on\n * every attempt.\n *\n * @param url - Request URL passed to `fetch`\n * @param options - {@link RequestOptions} controlling retries, timeout, request init, and cancellation\n * @returns The first {@link Response} for which `ok` is `true`\n * @throws {FetchRetrierInvalidOptionsError} If `retries < 1`, `timeoutMs <= 0`, or `baseBackoffMs < 0`\n * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt\n * @throws {FetchRetrierHttpError} On a non-OK response that is not retried or after the last attempt\n *   (includes `status` and `body`)\n * @throws {FetchRetrierNetworkError} On a network `TypeError` after the last attempt\n * @throws {FetchRetrierAbortError} On timeout or external abort after the last attempt\n * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)\n */\nexport const fetchRetrier = async (url: string, options: RequestOptions): Promise<Response> => {\n  const {\n    headers,\n    init,\n    retries,\n    timeoutMs,\n    baseBackoffMs,\n    signal: externalSignal,\n    shouldRetry = defaultShouldRetry,\n  } = options;\n\n  validateRequestOptions({ retries, timeoutMs, baseBackoffMs });\n\n  for (let attempt = 1; attempt <= retries; attempt++) {\n    if (externalSignal?.aborted) {\n      throw new FetchRetrierAlreadyAbortedError();\n    }\n\n    const controller = new AbortController();\n    const timer = setTimeout(() => controller.abort(), timeoutMs);\n\n    const onExternalAbort = (): void => {\n      clearTimeout(timer);\n      controller.abort();\n    };\n\n    if (externalSignal) {\n      externalSignal.addEventListener('abort', onExternalAbort);\n    }\n\n    try {\n      const res = await fetch(url, {\n        ...init,\n        ...(headers !== undefined ? { headers } : {}),\n        signal: controller.signal,\n      });\n\n      clearTimeout(timer);\n      externalSignal?.removeEventListener('abort', onExternalAbort);\n\n      if (res.ok) {\n        return res;\n      }\n\n      const text = await res.text();\n      const isContinue = shouldRetry(res, text);\n\n      if (isContinue) {\n        if (attempt === retries) {\n          throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status, text);\n        }\n        await wait(resolveRetryDelayMs(res, baseBackoffMs, attempt));\n      } else {\n        throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status, text);\n      }\n    } catch (err: unknown) {\n      clearTimeout(timer);\n      externalSignal?.removeEventListener('abort', onExternalAbort);\n\n      if (err instanceof Error && err.name === 'AbortError') {\n        if (attempt === retries) throw err instanceof FetchRetrierAbortError ? err : new FetchRetrierAbortError();\n        await wait(fullJitter(baseBackoffMs, attempt));\n        continue;\n      }\n\n      if (err instanceof TypeError) {\n        if (attempt === retries) throw new FetchRetrierNetworkError('Network error', err);\n        await wait(fullJitter(baseBackoffMs, attempt));\n        continue;\n      }\n\n      throw err;\n    }\n  }\n\n  throw new FetchRetrierUnreachableError();\n};\n\n/**\n * Delays execution for the given duration (used between retry attempts).\n *\n * @param ms - Delay in milliseconds\n * @returns A promise that resolves after `ms`\n */\nconst wait = (ms: number): Promise<void> => {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n};\n\n/**\n * Full jitter backoff: random delay in `[0, base * 2^attempt)` ms (AWS-recommended pattern).\n *\n * Used between abort/network retries, and as the fallback when HTTP retries lack a usable\n * `Retry-After` header.\n *\n * @param base - Base backoff in milliseconds\n * @param attempt - 1-based attempt index (first retry uses `attempt === 1`)\n * @returns Wait duration in milliseconds before the next attempt\n */\nconst fullJitter = (base: number, attempt: number): number => {\n  const cap = base * Math.pow(2, attempt);\n  return Math.floor(Math.random() * cap);\n};\n\n/**\n * Parses a `Retry-After` header value into a delay in milliseconds.\n *\n * Supports RFC 7231 forms: non-negative integer delta-seconds, or an HTTP-date. Empty values,\n * non-integer numerics (e.g. floats or negatives), and unparsable dates yield `undefined` so\n * callers can fall back to full jitter. An HTTP-date in the past yields `0`.\n *\n * @param value - Raw `Retry-After` header value\n * @param nowMs - Current time in milliseconds (injectable for tests)\n * @returns Delay in milliseconds, or `undefined` when the value cannot be parsed\n */\nexport const parseRetryAfterMs = (value: string, nowMs: number = Date.now()): number | undefined => {\n  const trimmed = value.trim();\n  if (trimmed === '') {\n    return undefined;\n  }\n\n  if (/^\\d+$/.test(trimmed)) {\n    return Number.parseInt(trimmed, 10) * 1000;\n  }\n\n  // Reject other numeric forms (floats, negatives); not valid delta-seconds or HTTP-date.\n  if (/^-?\\d+(\\.\\d+)?$/.test(trimmed)) {\n    return undefined;\n  }\n\n  const dateMs = Date.parse(trimmed);\n  if (Number.isNaN(dateMs)) {\n    return undefined;\n  }\n\n  return Math.max(0, dateMs - nowMs);\n};\n\n/**\n * Chooses the delay before the next HTTP retry: prefer a valid `Retry-After`, else full jitter.\n *\n * Reads `response.headers.get('Retry-After')` and parses it with {@link parseRetryAfterMs}.\n * Missing headers, or values that parse to `undefined`, fall back to {@link fullJitter}.\n * Abort and network retries do not use this helper.\n *\n * @param response - Non-OK response from the current attempt\n * @param baseBackoffMs - Base backoff passed to {@link fullJitter} when falling back\n * @param attempt - 1-based attempt index\n * @param nowMs - Current time in milliseconds (injectable for tests)\n * @returns Wait duration in milliseconds before the next attempt\n */\nconst resolveRetryDelayMs = (\n  response: Response,\n  baseBackoffMs: number,\n  attempt: number,\n  nowMs: number = Date.now(),\n): number => {\n  const header = response.headers?.get('Retry-After');\n  if (header == null) {\n    return fullJitter(baseBackoffMs, attempt);\n  }\n\n  const fromHeader = parseRetryAfterMs(header, nowMs);\n  if (fromHeader === undefined) {\n    return fullJitter(baseBackoffMs, attempt);\n  }\n\n  return fromHeader;\n};\n"]}

package/package.json

@@ -43,20 +43,26 @@
     "eslint-plugin-import": "^2.32.0",
     "jest": "^30.4.2",
     "jest-junit": "^17",
-    "projen": "^0.101.20",
+    "projen": "^0.101.23",
     "ts-jest": "^29.4.12",
     "ts-node": "^10.9.2",
-    "typescript": "5.9.x"
+    "typescript": "6.0.x"
   },
   "engines": {
     "node": ">= 20.0.0"
   },
+  "devEngines": {
+    "packageManager": {
+      "name": "npm",
+      "onFail": "ignore"
+    }
+  },
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.4.4",
+  "version": "0.5.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [