fetch-retrier 0.3.6 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # Fetch Retrier
 
-A lightweight wrapper around `fetch` that adds **retries**, **per-attempt timeout**, and **full jitter** backoff. Pass standard `RequestInit` options (`method`, `body`, `credentials`, and more) for POST/PUT APIs and other HTTP calls that may be rate-limited (429) or temporarily unavailable (5xx).
+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)
@@ -9,14 +9,16 @@ A lightweight wrapper around `fetch` that adds **retries**, **per-attempt timeou
 
 ## Features
 
-- **Configurable retries** – Set the maximum number of attempts per request.
-- **Per-attempt timeout** – Abort each attempt when it exceeds a given duration.
-- **Full jitter backoff** – Exponential backoff with random jitter (AWS-style) between retries.
+- **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`).
+- **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.
-- **Custom retry predicate** – Control which responses trigger a retry (default: 429, 500, 502, 503, 504).
+- **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.
 - **External cancellation** – Pass an `AbortSignal` to cancel in-flight requests.
-- **Typed errors** – `FetchRetrierHttpError`, `FetchRetrierNetworkError`, `FetchRetrierAbortError`, and related classes.
+- **Typed errors** – `FetchRetrierHttpError`, `FetchRetrierNetworkError`, `FetchRetrierAbortError`, `FetchRetrierInvalidOptionsError`, and related classes.
 - **TypeScript** – Exported types including `RequestOptions` and `FetchInitOptions`.
 
 ## Installation
@@ -80,17 +82,27 @@ 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:
+
 ```typescript
+import {
+  DEFAULT_RETRYABLE_HTTP_STATUSES,
+  defaultShouldRetry,
+  fetchRetrier,
+} from 'fetch-retrier';
+
 const response = await fetchRetrier('https://api.example.com/data', {
   retries: 5,
   timeoutMs: 10000,
   baseBackoffMs: 500,
   shouldRetry: (res, body) => {
-    if ([429, 500, 502, 503].includes(res.status)) return true;
+    if (defaultShouldRetry(res, body)) return true;
     if (res.status === 200 && body.includes('"retry": true')) return true;
     return false;
   },
 });
+
+// DEFAULT_RETRYABLE_HTTP_STATUSES is [408, 425, 429, 500, 502, 503, 504]
 ```
 
 ### Cancellation with `AbortController`
@@ -111,6 +123,7 @@ await fetchRetrier('https://api.example.com/data', {
 ### Retry and error behavior
 
 - **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`.
@@ -121,13 +134,20 @@ await fetchRetrier('https://api.example.com/data', {
 
 | Option | Type | Required | Description |
 |--------|------|----------|-------------|
-| `retries` | `number` | Yes | Maximum number of attempts (including the first request). |
-| `timeoutMs` | `number` | Yes | Timeout in milliseconds for each attempt. Exceeded attempts are aborted and retried. |
-| `baseBackoffMs` | `number` | Yes | Base delay in milliseconds for backoff. Delay is capped at `baseBackoffMs * 2^attempt` and randomized (full jitter). |
+| `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). |
 | `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. |
-| `shouldRetry` | `(response: Response, body: string) => boolean` | No | Called after `response.text()` when `response.ok` is false. Return `true` to retry. Default: 429, 500, 502, 503, 504. |
+| `shouldRetry` | `(response: Response, body: string) => boolean` | No | Called after `response.text()` when `response.ok` is false. Return `true` to retry. Default: `defaultShouldRetry` (statuses in `DEFAULT_RETRYABLE_HTTP_STATUSES`: 408, 425, 429, 500, 502, 503, 504). |
+
+### Exported helpers
+
+| Export | Description |
+|--------|-------------|
+| `defaultShouldRetry` | Default `shouldRetry` predicate; compose with custom logic. |
+| `DEFAULT_RETRYABLE_HTTP_STATUSES` | Readonly list of HTTP status codes retried by default. |
 
 ## Requirements
 
@@ -136,4 +156,4 @@ await fetchRetrier('https://api.example.com/data', {
 
 ## License
 
-This project is licensed under the (Apache-2.0) License.
+This project is licensed under the Apache-2.0 License.

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Retry-enabled `fetch` wrapper with per-attempt timeout, full-jitter backoff, and typed errors.
+ * Retry-enabled `fetch` wrapper with per-attempt timeout, full-jitter backoff, option validation, and typed errors.
  *
  * @module fetch-retrier
  */
@@ -16,6 +16,9 @@ export type FetchInitOptions = Omit<RequestInit, 'signal'>;
  *
  * Request shape is built as `{ ...init, headers?, signal }` on each attempt. Top-level `headers`
  * override `init.headers` when both are provided.
+ *
+ * Numeric fields are validated when {@link fetchRetrier} is called; invalid values throw
+ * {@link FetchRetrierInvalidOptionsError}.
  */
 export interface RequestOptions {
     /**
@@ -28,12 +31,19 @@ export interface RequestOptions {
      * The same `init` is reused across retries.
      */
     init?: FetchInitOptions;
-    /** Maximum number of attempts, including the first. */
+    /**
+     * Maximum number of attempts, including the first.
+     * Must be `>= 1`.
+     */
     retries: number;
-    /** Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded. */
+    /**
+     * Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded.
+     * Must be `> 0`.
+     */
     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).
      */
     baseBackoffMs: number;
     /**
@@ -44,10 +54,11 @@ export interface RequestOptions {
     /**
      * Invoked after `response.text()` when `response.ok` is false.
      * Return `true` to schedule another attempt (until `retries` is exhausted).
-     * Default: retry on status 429, 500, 502, 503, or 504.
+     * Default: {@link defaultShouldRetry} (see {@link DEFAULT_RETRYABLE_HTTP_STATUSES}).
      *
      * @param response - Non-OK response from the current attempt
      * @param body - Response body text from `response.text()`
+     * @returns `true` to schedule another attempt (until `retries` is exhausted)
      */
     shouldRetry?: (response: Response, body: string) => boolean;
 }
@@ -99,6 +110,20 @@ export declare class FetchRetrierNetworkError extends Error {
      */
     constructor(message?: string, cause?: unknown | undefined);
 }
+/**
+ * Error thrown when {@link RequestOptions} contains invalid numeric values.
+ *
+ * Subclass of {@link TypeError} for compatibility with `instanceof TypeError`. Distinct from
+ * network-level `TypeError` values thrown by `fetch`, which are retried and surfaced as
+ * {@link FetchRetrierNetworkError} after the last attempt.
+ */
+export declare class FetchRetrierInvalidOptionsError extends TypeError {
+    readonly name: string;
+    /**
+     * @param message - Human-readable reason describing the invalid option
+     */
+    constructor(message: string);
+}
 /**
  * Error thrown when an internal invariant fails (should not happen in normal use).
  */
@@ -109,17 +134,36 @@ export declare class FetchRetrierUnreachableError extends Error {
      */
     constructor(message?: string);
 }
+/**
+ * HTTP status codes retried by default when {@link RequestOptions.shouldRetry} is omitted.
+ *
+ * Includes transient client/server errors: 408, 425, 429, and common 5xx gateway or overload responses.
+ */
+export declare const DEFAULT_RETRYABLE_HTTP_STATUSES: readonly number[];
+/**
+ * Default {@link RequestOptions.shouldRetry}: retries responses whose status is in
+ * {@link DEFAULT_RETRYABLE_HTTP_STATUSES}.
+ *
+ * Compose with custom logic, for example:
+ * `(res, body) => defaultShouldRetry(res, body) || res.status === 418`.
+ *
+ * @param response - Response from the failed attempt
+ * @param _body - Response body text (unused by the default predicate)
+ * @returns `true` when another attempt should be scheduled
+ */
+export declare const defaultShouldRetry: (response: Response, _body: string) => boolean;
 /**
  * Wraps `fetch` with retries, per-attempt timeout, 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: 429 and 5xx). The same {@link FetchInitOptions} (including `body`) is reused
+ * `true` (default: {@link DEFAULT_RETRYABLE_HTTP_STATUSES}). 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
  * @returns The first {@link Response} for which `ok` is `true`
+ * @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
  * @throws {FetchRetrierNetworkError} On a network `TypeError` after the last attempt

package/lib/index.js

@@ -1,11 +1,11 @@
 "use strict";
 /**
- * Retry-enabled `fetch` wrapper with per-attempt timeout, full-jitter backoff, and typed errors.
+ * Retry-enabled `fetch` wrapper with per-attempt timeout, full-jitter backoff, option validation, and typed errors.
  *
  * @module fetch-retrier
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchRetrier = exports.FetchRetrierUnreachableError = exports.FetchRetrierNetworkError = exports.FetchRetrierHttpError = exports.FetchRetrierAlreadyAbortedError = exports.FetchRetrierAbortError = void 0;
+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}.
  */
@@ -70,6 +70,24 @@ class FetchRetrierNetworkError extends Error {
     }
 }
 exports.FetchRetrierNetworkError = FetchRetrierNetworkError;
+/**
+ * Error thrown when {@link RequestOptions} contains invalid numeric values.
+ *
+ * Subclass of {@link TypeError} for compatibility with `instanceof TypeError`. Distinct from
+ * network-level `TypeError` values thrown by `fetch`, which are retried and surfaced as
+ * {@link FetchRetrierNetworkError} after the last attempt.
+ */
+class FetchRetrierInvalidOptionsError extends TypeError {
+    /**
+     * @param message - Human-readable reason describing the invalid option
+     */
+    constructor(message) {
+        super(message);
+        this.name = 'FetchRetrierInvalidOptionsError';
+        Object.setPrototypeOf(this, FetchRetrierInvalidOptionsError.prototype);
+    }
+}
+exports.FetchRetrierInvalidOptionsError = FetchRetrierInvalidOptionsError;
 /**
  * Error thrown when an internal invariant fails (should not happen in normal use).
  */
@@ -85,25 +103,58 @@ class FetchRetrierUnreachableError extends Error {
 }
 exports.FetchRetrierUnreachableError = FetchRetrierUnreachableError;
 /**
- * Default {@link RequestOptions.shouldRetry}: retry on HTTP 429, 500, 502, 503, or 504.
+ * HTTP status codes retried by default when {@link RequestOptions.shouldRetry} is omitted.
+ *
+ * Includes transient client/server errors: 408, 425, 429, and common 5xx gateway or overload responses.
+ */
+exports.DEFAULT_RETRYABLE_HTTP_STATUSES = [408, 425, 429, 500, 502, 503, 504];
+/**
+ * Default {@link RequestOptions.shouldRetry}: retries responses whose status is in
+ * {@link DEFAULT_RETRYABLE_HTTP_STATUSES}.
+ *
+ * Compose with custom logic, for example:
+ * `(res, body) => defaultShouldRetry(res, body) || res.status === 418`.
  *
- * @param res - Response from the failed attempt
+ * @param response - Response from the failed attempt
+ * @param _body - Response body text (unused by the default predicate)
  * @returns `true` when another attempt should be scheduled
  */
-const defaultShouldRetry = (res) => {
-    return [429, 500, 502, 503, 504].includes(res.status);
+const defaultShouldRetry = (response, _body) => {
+    return exports.DEFAULT_RETRYABLE_HTTP_STATUSES.includes(response.status);
+};
+exports.defaultShouldRetry = defaultShouldRetry;
+/**
+ * Validates retry policy numeric fields on {@link RequestOptions}.
+ *
+ * Constraints: `retries >= 1`, `timeoutMs > 0`, `baseBackoffMs >= 0`.
+ *
+ * @param options - Options whose `retries`, `timeoutMs`, and `baseBackoffMs` are checked
+ * @throws {FetchRetrierInvalidOptionsError} When any constraint is violated
+ */
+const validateRequestOptions = (options) => {
+    const { retries, timeoutMs, baseBackoffMs } = options;
+    if (retries < 1) {
+        throw new FetchRetrierInvalidOptionsError('retries must be >= 1');
+    }
+    if (timeoutMs <= 0) {
+        throw new FetchRetrierInvalidOptionsError('timeoutMs must be > 0');
+    }
+    if (baseBackoffMs < 0) {
+        throw new FetchRetrierInvalidOptionsError('baseBackoffMs must be >= 0');
+    }
 };
 /**
  * Wraps `fetch` with retries, per-attempt timeout, 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: 429 and 5xx). The same {@link FetchInitOptions} (including `body`) is reused
+ * `true` (default: {@link DEFAULT_RETRYABLE_HTTP_STATUSES}). 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
  * @returns The first {@link Response} for which `ok` is `true`
+ * @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
  * @throws {FetchRetrierNetworkError} On a network `TypeError` after the last attempt
@@ -111,7 +162,8 @@ const defaultShouldRetry = (res) => {
  * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)
  */
 const fetchRetrier = async (url, options) => {
-    const { headers, init, retries, timeoutMs, baseBackoffMs, signal: externalSignal, shouldRetry = defaultShouldRetry, } = options;
+    const { headers, init, retries, timeoutMs, baseBackoffMs, signal: externalSignal, shouldRetry = exports.defaultShouldRetry, } = options;
+    validateRequestOptions({ retries, timeoutMs, baseBackoffMs });
     for (let attempt = 1; attempt <= retries; attempt++) {
         if (externalSignal?.aborted) {
             throw new FetchRetrierAlreadyAbortedError();
@@ -189,4 +241,4 @@ 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, 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 */\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  /** Maximum number of attempts, including the first. */\n  retries: number;\n  /** Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded. */\n  timeoutMs: number;\n  /**\n   * Base backoff in milliseconds for full jitter. The cap for attempt `n` is `baseBackoffMs * 2^n`.\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: retry on status 429, 500, 502, 503, or 504.\n   *\n   * @param response - Non-OK response from the current attempt\n   * @param body - Response body text from `response.text()`\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 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 * Default {@link RequestOptions.shouldRetry}: retry on HTTP 429, 500, 502, 503, or 504.\n *\n * @param res - Response from the failed attempt\n * @returns `true` when another attempt should be scheduled\n */\nconst defaultShouldRetry = (res: Response): boolean => {\n  return [429, 500, 502, 503, 504].includes(res.status);\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: 429 and 5xx). 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 {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  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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AA+DH;;GAEG;AACH,MAAa,sBAAuB,SAAQ,KAAK;IAE/C;;OAEG;IACH,YAAY,OAAO,GAAG,SAAS;QAC7B,KAAK,CAAC,OAAO,CAAC,CAAC;QALC,SAAI,GAAW,wBAAwB,CAAC;QAMxD,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAChE,CAAC;CACF;AATD,wDASC;AAED;;GAEG;AACH,MAAa,+BAAgC,SAAQ,sBAAsB;IAEzE;;OAEG;IACH,YAAY,OAAO,GAAG,4BAA4B;QAChD,KAAK,CAAC,OAAO,CAAC,CAAC;QALC,SAAI,GAAW,iCAAiC,CAAC;QAMjE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,+BAA+B,CAAC,SAAS,CAAC,CAAC;IACzE,CAAC;CACF;AATD,0EASC;AAED;;;;GAIG;AACH,MAAa,qBAAsB,SAAQ,KAAK;IAE9C;;;OAGG;IACH,YACE,OAAe,EACC,MAAc;QAE9B,KAAK,CAAC,OAAO,CAAC,CAAC;QAFC,WAAM,GAAN,MAAM,CAAQ;QAPd,SAAI,GAAW,uBAAuB,CAAC;QAUvD,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAC/D,CAAC;CACF;AAbD,sDAaC;AAED;;;;GAIG;AACH,MAAa,wBAAyB,SAAQ,KAAK;IAEjD;;;OAGG;IACH,YAAY,OAAO,GAAG,eAAe,EAAkB,KAAe;QACpE,KAAK,CAAC,OAAO,CAAC,CAAC;QADsC,UAAK,GAAL,KAAK,CAAU;QALpD,SAAI,GAAW,0BAA0B,CAAC;QAO1D,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAC;IAClE,CAAC;CACF;AAVD,4DAUC;AAED;;;;;;GAMG;AACH,MAAa,+BAAgC,SAAQ,SAAS;IAE5D;;OAEG;IACH,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QALC,SAAI,GAAW,iCAAiC,CAAC;QAMjE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,+BAA+B,CAAC,SAAS,CAAC,CAAC;IACzE,CAAC;CACF;AATD,0EASC;AAED;;GAEG;AACH,MAAa,4BAA6B,SAAQ,KAAK;IAErD;;OAEG;IACH,YAAY,OAAO,GAAG,aAAa;QACjC,KAAK,CAAC,OAAO,CAAC,CAAC;QALC,SAAI,GAAW,8BAA8B,CAAC;QAM9D,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,4BAA4B,CAAC,SAAS,CAAC,CAAC;IACtE,CAAC;CACF;AATD,oEASC;AAED;;;;GAIG;AACU,QAAA,+BAA+B,GAAsB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAEtG;;;;;;;;;;GAUG;AACI,MAAM,kBAAkB,GAAG,CAAC,QAAkB,EAAE,KAAa,EAAW,EAAE;IAC/E,OAAO,uCAA+B,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AACnE,CAAC,CAAC;AAFW,QAAA,kBAAkB,sBAE7B;AAEF;;;;;;;GAOG;AACH,MAAM,sBAAsB,GAAG,CAAC,OAAwE,EAAQ,EAAE;IAChH,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC;IAEtD,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;QAChB,MAAM,IAAI,+BAA+B,CAAC,sBAAsB,CAAC,CAAC;IACpE,CAAC;IACD,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,+BAA+B,CAAC,uBAAuB,CAAC,CAAC;IACrE,CAAC;IACD,IAAI,aAAa,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,+BAA+B,CAAC,4BAA4B,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACI,MAAM,YAAY,GAAG,KAAK,EAAE,GAAW,EAAE,OAAuB,EAAqB,EAAE;IAC5F,MAAM,EACJ,OAAO,EACP,IAAI,EACJ,OAAO,EACP,SAAS,EACT,aAAa,EACb,MAAM,EAAE,cAAc,EACtB,WAAW,GAAG,0BAAkB,GACjC,GAAG,OAAO,CAAC;IAEZ,sBAAsB,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC,CAAC;IAE9D,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC;QACpD,IAAI,cAAc,EAAE,OAAO,EAAE,CAAC;YAC5B,MAAM,IAAI,+BAA+B,EAAE,CAAC;QAC9C,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,SAAS,CAAC,CAAC;QAE9D,MAAM,eAAe,GAAG,GAAS,EAAE;YACjC,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,UAAU,CAAC,KAAK,EAAE,CAAC;QACrB,CAAC,CAAC;QAEF,IAAI,cAAc,EAAE,CAAC;YACnB,cAAc,CAAC,gBAAgB,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;QAC5D,CAAC;QAED,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;gBAC3B,GAAG,IAAI;gBACP,GAAG,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC7C,MAAM,EAAE,UAAU,CAAC,MAAM;aAC1B,CAAC,CAAC;YAEH,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,cAAc,EAAE,mBAAmB,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;YAE9D,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC;gBACX,OAAO,GAAG,CAAC;YACb,CAAC;YAED,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;YAC9B,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;YAE1C,IAAI,UAAU,EAAE,CAAC;gBACf,IAAI,OAAO,KAAK,OAAO,EAAE,CAAC;oBACxB,MAAM,IAAI,qBAAqB,CAAC,QAAQ,GAAG,CAAC,MAAM,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;gBACpE,CAAC;gBACD,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC;YACjD,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,qBAAqB,CAAC,6BAA6B,GAAG,CAAC,MAAM,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;YACzF,CAAC;QACH,CAAC;QAAC,OAAO,GAAY,EAAE,CAAC;YACtB,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,cAAc,EAAE,mBAAmB,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;YAE9D,IAAI,GAAG,YAAY,KAAK,IAAI,GAAG,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBACtD,IAAI,OAAO,KAAK,OAAO;oBAAE,MAAM,GAAG,YAAY,sBAAsB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,sBAAsB,EAAE,CAAC;gBAC1G,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC;gBAC/C,SAAS;YACX,CAAC;YAED,IAAI,GAAG,YAAY,SAAS,EAAE,CAAC;gBAC7B,IAAI,OAAO,KAAK,OAAO;oBAAE,MAAM,IAAI,wBAAwB,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;gBAClF,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC;gBAC/C,SAAS;YACX,CAAC;YAED,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;IAED,MAAM,IAAI,4BAA4B,EAAE,CAAC;AAC3C,CAAC,CAAC;AA5EW,QAAA,YAAY,gBA4EvB;AAEF;;;;;GAKG;AACH,MAAM,IAAI,GAAG,CAAC,EAAU,EAAiB,EAAE;IACzC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AAC3D,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,GAAG,CAAC,IAAY,EAAE,OAAe,EAAU,EAAE;IAC3D,MAAM,GAAG,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IACxC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC;AACzC,CAAC,CAAC","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"]}

package/package.json

@@ -55,7 +55,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.6",
+  "version": "0.4.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [