fetch-retrier 0.7.4 → 0.8.0

package/README.md

@@ -9,27 +9,27 @@ A lightweight wrapper around `fetch` that adds **retries**, **per-attempt timeou
 
 ## 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`).
-- **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`). Optional `maxBackoffMs` clips the jitter result (`>= 0`); it does not clip a valid `Retry-After`.
-- **Option validation** – Invalid numeric options throw `FetchRetrierInvalidOptionsError` at call time.
+- **Configurable retries** – Set the maximum number of attempts per request (`retries` is a finite integer `>= 1`).
+- **Per-attempt timeout** – Abort each attempt when it exceeds a given duration (`timeoutMs` is a finite integer `> 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, invalid, or non-finite. Optional `maxRetryAfterMs` clips a finite delay (a finite integer `>= 0` when set) and does not change jitter.
+- **Full jitter backoff** – Exponential backoff with random jitter (AWS-style) for abort/network retries and as the HTTP fallback (`baseBackoffMs` is a finite integer `>= 0`). Optional `maxBackoffMs` clips the jitter result (a finite integer `>= 0` when set); it does not clip a valid `Retry-After`.
+- **Option validation** – Non-finite or non-integer numeric options throw `FetchRetrierInvalidOptionsError` before any request.
 - **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 (receives response body text).
 - **External cancellation** – Pass an `AbortSignal` to cancel in-flight requests and backoff waits.
-- **Typed errors** – All failures extend abstract `FetchRetrierError`. Subclasses include `FetchRetrierHttpError` (with `status` and `body`), `FetchRetrierNetworkError`, `FetchRetrierAbortError`, `FetchRetrierAlreadyAbortedError`, and `FetchRetrierInvalidOptionsError`.
-- **TypeScript** – Exported types including `RequestOptions` and `FetchInitOptions`.
+- **Typed errors** – Errors created by this package extend abstract `FetchRetrierError`. Subclasses include `FetchRetrierHttpError` (with `status` and `body`), `FetchRetrierNetworkError`, `FetchRetrierAbortError`, `FetchRetrierAlreadyAbortedError`, and `FetchRetrierInvalidOptionsError`. Any other exception is rethrown as-is.
+- **TypeScript** – Exported types including `RequestOptions`, `FetchInitOptions`, and `ParseRetryAfterOptions`.
 
 ## How it works
 
-Options are validated, then each attempt sends the same URL and `init`/`headers` with an internal timeout. If `response.ok` is true, that response is returned. Otherwise `shouldRetry` decides whether to wait and try again. HTTP retries prefer a valid `Retry-After` header; abort and network retries use full jitter. After the last attempt, a subclass of `FetchRetrierError` is thrown.
+Options are validated, then each attempt sends the same URL and `init`/`headers` with an internal timeout. If `response.ok` is true, that response is returned. Otherwise `shouldRetry` decides whether to wait and try again. HTTP retries prefer a valid `Retry-After` header; abort and network retries use full jitter. After the last attempt, a subclass of `FetchRetrierError` is thrown. An exception that is neither an abort nor a network `TypeError` is rethrown immediately.
 
 - **Success** – If `response.ok` is true, the response is returned immediately.
 - **Package errors** – Failures from this package extend abstract `FetchRetrierError`. Catch the base, or a subclass for a specific case. Construct a subclass.
-- **Invalid options** – If `retries < 1`, `timeoutMs <= 0`, `baseBackoffMs < 0`, or `maxBackoffMs` is set and `< 0`, `FetchRetrierInvalidOptionsError` is thrown before any request is made. This is not a `TypeError`.
-- **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`).
+- **Invalid options** – If `retries`, `timeoutMs`, `baseBackoffMs`, or a set `maxBackoffMs` or `maxRetryAfterMs` is not a finite integer in range (`retries >= 1`, `timeoutMs > 0`, backoff and Retry-After ceilings `>= 0`), `FetchRetrierInvalidOptionsError` is thrown before any request is made. `NaN`, `Infinity`, and decimals are rejected. This is not a `TypeError`.
+- **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. When `maxRetryAfterMs` is set, a longer finite `Retry-After` is clipped to that ceiling. 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`, that attempt is aborted and retried with full jitter until `retries` is exhausted. Timeout is per-attempt and does not cancel later attempts. The final failure is `FetchRetrierAbortError`.
 - **External abort (in-flight)** – If `signal` is aborted during an attempt, the in-flight request is aborted. On the last attempt, the failure is `FetchRetrierAbortError`. If retries remain, backoff is skipped and the next attempt sees the still-aborted signal and throws `FetchRetrierAlreadyAbortedError` (no further request is made).
@@ -127,8 +127,9 @@ const response = await fetchRetrier('https://api.example.com/data', {
 
 ### Handling errors
 
-All failures thrown by `fetchRetrier` extend `FetchRetrierError`. The base class is abstract.
+Errors created by `fetchRetrier` extend `FetchRetrierError`. The base class is abstract.
 Catch it for any library failure, or a subclass for a specific case. Construct a subclass.
+An exception that is neither an abort nor a network `TypeError` is rethrown as-is.
 `FetchRetrierInvalidOptionsError` does not extend `TypeError`.
 
 On a non-OK response that is not retried (or after retries are exhausted), `FetchRetrierHttpError`
@@ -202,10 +203,11 @@ try {
 
 | Option | Type | Required | Description |
 |--------|------|----------|-------------|
-| `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 full jitter when `Retry-After` is absent or invalid (also used for abort/network retries). Exponential span is `baseBackoffMs * 2^attempt`, randomized. Must be `>= 0` (`0` skips backoff delay when falling back). |
-| `maxBackoffMs` | `number` | No | Optional ceiling in milliseconds applied to the full-jitter result (`Math.min(jitter, maxBackoffMs)`). Does not clip a valid `Retry-After`. Must be `>= 0` when set (`0` skips jitter wait). Omitted means no extra clip. |
+| `retries` | `number` | Yes | Maximum number of attempts (including the first request). Must be a finite integer `>= 1`. |
+| `timeoutMs` | `number` | Yes | Timeout in milliseconds for each attempt. Exceeded attempts are aborted and retried. Must be a finite integer `> 0`. |
+| `baseBackoffMs` | `number` | Yes | Base delay in milliseconds for full jitter when `Retry-After` is absent or invalid (also used for abort/network retries). Exponential span is `baseBackoffMs * 2^attempt`, randomized. Must be a finite integer `>= 0` (`0` skips backoff delay when falling back). |
+| `maxBackoffMs` | `number` | No | Optional ceiling in milliseconds applied to the full-jitter result (`Math.min(jitter, maxBackoffMs)`). Does not clip a valid `Retry-After`. Must be a finite integer `>= 0` when set (`0` skips jitter wait). Omitted means no extra clip. |
+| `maxRetryAfterMs` | `number` | No | Optional ceiling in milliseconds applied to a finite `Retry-After` delay (`Math.min(delay, maxRetryAfterMs)`). Does not change full jitter. A non-finite delta-seconds value still falls back to jitter. Must be a finite integer `>= 0` when set (`0` skips the `Retry-After` wait). Omitted means a finite `Retry-After` is not clipped. |
 | `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 before an attempt, `FetchRetrierAlreadyAbortedError` is thrown. If aborted during an attempt, the in-flight request is aborted: the last attempt fails with `FetchRetrierAbortError`; remaining attempts fail with `FetchRetrierAlreadyAbortedError` without waiting out backoff. If aborted during a full-jitter or `Retry-After` wait, the wait ends immediately and `FetchRetrierAlreadyAbortedError` is thrown. Distinct from `timeoutMs`, which retries remaining attempts and then throws `FetchRetrierAbortError`. |
@@ -217,7 +219,10 @@ try {
 |--------|-------------|
 | `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. |
+| `parseRetryAfterMs` | Parses a `Retry-After` header (delta-seconds or HTTP-date) into a delay in milliseconds. Pass `ParseRetryAfterOptions` (`{ nowMs }`) to inject the current time. Overflowing delta-seconds are unparsable. |
+| `ParseRetryAfterOptions` | Options for `parseRetryAfterMs`. `nowMs` is the current time in milliseconds and defaults to `Date.now()` when omitted. |
+
+`parseRetryAfterMs(value, nowMs)` still works.
 
 ## Requirements
 

package/lib/core/backoff/retry-after.d.ts

@@ -1,27 +1,45 @@
+/**
+ * Options for {@link parseRetryAfterMs}.
+ *
+ * Pass this object as the second argument. A numeric second argument is still accepted.
+ */
+export interface ParseRetryAfterOptions {
+    /**
+     * Current time in milliseconds.
+     * When omitted, {@link parseRetryAfterMs} uses `Date.now()`.
+     */
+    nowMs?: number;
+}
 /**
  * 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`.
+ * non-integer numerics (e.g. floats or negatives), unparsable dates, and delta-seconds that
+ * overflow to a non-finite delay yield `undefined` so callers can fall back to full jitter.
+ * An HTTP-date in the past yields `0`.
+ *
+ * Prefer `{ nowMs }` from {@link ParseRetryAfterOptions}. A numeric second argument is still accepted.
  *
  * @param value - Raw `Retry-After` header value
- * @param nowMs - Current time in milliseconds (injectable for tests)
+ * @param nowMsOrOptions - `{ nowMs }` (preferred) or a current time in milliseconds. Defaults to `Date.now()`
  * @returns Delay in milliseconds, or `undefined` when the value cannot be parsed
  */
-export declare const parseRetryAfterMs: (value: string, nowMs?: number) => number | undefined;
+export declare const parseRetryAfterMs: (value: string, nowMsOrOptions?: number | ParseRetryAfterOptions) => number | undefined;
 /**
  * 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.
+ * A finite delay is returned as-is when `maxRetryAfterMs` is omitted, and clipped with
+ * `Math.min(delay, maxRetryAfterMs)` when that ceiling is set. 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 maxBackoffMs - Optional ceiling applied only to the jitter fallback
+ * @param maxRetryAfterMs - Optional ceiling applied only to a finite `Retry-After` delay
  * @param nowMs - Current time in milliseconds (injectable for tests)
  * @returns Wait duration in milliseconds before the next attempt
  */
-export declare const resolveRetryDelayMs: (response: Response, baseBackoffMs: number, attempt: number, maxBackoffMs?: number, nowMs?: number) => number;
+export declare const resolveRetryDelayMs: (response: Response, baseBackoffMs: number, attempt: number, maxBackoffMs?: number, maxRetryAfterMs?: number, nowMs?: number) => number;

package/lib/core/backoff/retry-after.js

@@ -2,24 +2,45 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRetryDelayMs = exports.parseRetryAfterMs = void 0;
 const jitter_1 = require("./jitter");
+/**
+ * Resolves the clock for {@link parseRetryAfterMs}.
+ *
+ * A number is the positional current time. An options object reads `nowMs`.
+ * Either form falls back to `Date.now()` when the clock is omitted.
+ */
+const currentTimeMs = (nowMsOrOptions) => {
+    if (typeof nowMsOrOptions === 'number') {
+        return nowMsOrOptions;
+    }
+    return nowMsOrOptions?.nowMs ?? Date.now();
+};
 /**
  * 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`.
+ * non-integer numerics (e.g. floats or negatives), unparsable dates, and delta-seconds that
+ * overflow to a non-finite delay yield `undefined` so callers can fall back to full jitter.
+ * An HTTP-date in the past yields `0`.
+ *
+ * Prefer `{ nowMs }` from {@link ParseRetryAfterOptions}. A numeric second argument is still accepted.
  *
  * @param value - Raw `Retry-After` header value
- * @param nowMs - Current time in milliseconds (injectable for tests)
+ * @param nowMsOrOptions - `{ nowMs }` (preferred) or a current time in milliseconds. Defaults to `Date.now()`
  * @returns Delay in milliseconds, or `undefined` when the value cannot be parsed
  */
-const parseRetryAfterMs = (value, nowMs = Date.now()) => {
+const parseRetryAfterMs = (value, nowMsOrOptions) => {
+    const nowMs = currentTimeMs(nowMsOrOptions);
     const trimmed = value.trim();
     if (trimmed === '') {
         return undefined;
     }
     if (/^\d+$/.test(trimmed)) {
-        return Number.parseInt(trimmed, 10) * 1000;
+        // A long digit string can overflow to Infinity. That delay cannot be waited on safely.
+        const delayMs = Number.parseInt(trimmed, 10) * 1000;
+        if (!Number.isFinite(delayMs)) {
+            return undefined;
+        }
+        return delayMs;
     }
     // Reject other numeric forms (floats, negatives); not valid delta-seconds or HTTP-date.
     if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
@@ -37,25 +58,31 @@ exports.parseRetryAfterMs = parseRetryAfterMs;
  *
  * 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.
+ * A finite delay is returned as-is when `maxRetryAfterMs` is omitted, and clipped with
+ * `Math.min(delay, maxRetryAfterMs)` when that ceiling is set. 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 maxBackoffMs - Optional ceiling applied only to the jitter fallback
+ * @param maxRetryAfterMs - Optional ceiling applied only to a finite `Retry-After` delay
  * @param nowMs - Current time in milliseconds (injectable for tests)
  * @returns Wait duration in milliseconds before the next attempt
  */
-const resolveRetryDelayMs = (response, baseBackoffMs, attempt, maxBackoffMs, nowMs = Date.now()) => {
+const resolveRetryDelayMs = (response, baseBackoffMs, attempt, maxBackoffMs, maxRetryAfterMs, nowMs = Date.now()) => {
     const header = response.headers?.get('Retry-After');
     if (header == null) {
         return (0, jitter_1.fullJitter)(baseBackoffMs, attempt, maxBackoffMs);
     }
-    const fromHeader = (0, exports.parseRetryAfterMs)(header, nowMs);
+    const fromHeader = (0, exports.parseRetryAfterMs)(header, { nowMs });
     if (fromHeader === undefined) {
         return (0, jitter_1.fullJitter)(baseBackoffMs, attempt, maxBackoffMs);
     }
-    return fromHeader;
+    if (maxRetryAfterMs === undefined) {
+        return fromHeader;
+    }
+    return Math.min(fromHeader, maxRetryAfterMs);
 };
 exports.resolveRetryDelayMs = resolveRetryDelayMs;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV0cnktYWZ0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29yZS9iYWNrb2ZmL3JldHJ5LWFmdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFDQUFzQztBQUV0Qzs7Ozs7Ozs7OztHQVVHO0FBQ0ksTUFBTSxpQkFBaUIsR0FBRyxDQUFDLEtBQWEsRUFBRSxRQUFnQixJQUFJLENBQUMsR0FBRyxFQUFFLEVBQXNCLEVBQUU7SUFDakcsTUFBTSxPQUFPLEdBQUcsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQzdCLElBQUksT0FBTyxLQUFLLEVBQUUsRUFBRSxDQUFDO1FBQ25CLE9BQU8sU0FBUyxDQUFDO0lBQ25CLENBQUM7SUFFRCxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztRQUMxQixPQUFPLE1BQU0sQ0FBQyxRQUFRLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQztJQUM3QyxDQUFDO0lBRUQsd0ZBQXdGO0lBQ3hGLElBQUksaUJBQWlCLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7UUFDcEMsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUVELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDbkMsSUFBSSxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7UUFDekIsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUVELE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsTUFBTSxHQUFHLEtBQUssQ0FBQyxDQUFDO0FBQ3JDLENBQUMsQ0FBQztBQXJCVyxRQUFBLGlCQUFpQixxQkFxQjVCO0FBRUY7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUNJLE1BQU0sbUJBQW1CLEdBQUcsQ0FDakMsUUFBa0IsRUFDbEIsYUFBcUIsRUFDckIsT0FBZSxFQUNmLFlBQXFCLEVBQ3JCLFFBQWdCLElBQUksQ0FBQyxHQUFHLEVBQUUsRUFDbEIsRUFBRTtJQUNWLE1BQU0sTUFBTSxHQUFHLFFBQVEsQ0FBQyxPQUFPLEVBQUUsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBQ3BELElBQUksTUFBTSxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ25CLE9BQU8sSUFBQSxtQkFBVSxFQUFDLGFBQWEsRUFBRSxPQUFPLEVBQUUsWUFBWSxDQUFDLENBQUM7SUFDMUQsQ0FBQztJQUVELE1BQU0sVUFBVSxHQUFHLElBQUEseUJBQWlCLEVBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ3BELElBQUksVUFBVSxLQUFLLFNBQVMsRUFBRSxDQUFDO1FBQzdCLE9BQU8sSUFBQSxtQkFBVSxFQUFDLGFBQWEsRUFBRSxPQUFPLEVBQUUsWUFBWSxDQUFDLENBQUM7SUFDMUQsQ0FBQztJQUVELE9BQU8sVUFBVSxDQUFDO0FBQ3BCLENBQUMsQ0FBQztBQWxCVyxRQUFBLG1CQUFtQix1QkFrQjlCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZnVsbEppdHRlciB9IGZyb20gJy4vaml0dGVyJztcblxuLyoqXG4gKiBQYXJzZXMgYSBgUmV0cnktQWZ0ZXJgIGhlYWRlciB2YWx1ZSBpbnRvIGEgZGVsYXkgaW4gbWlsbGlzZWNvbmRzLlxuICpcbiAqIFN1cHBvcnRzIFJGQyA3MjMxIGZvcm1zOiBub24tbmVnYXRpdmUgaW50ZWdlciBkZWx0YS1zZWNvbmRzLCBvciBhbiBIVFRQLWRhdGUuIEVtcHR5IHZhbHVlcyxcbiAqIG5vbi1pbnRlZ2VyIG51bWVyaWNzIChlLmcuIGZsb2F0cyBvciBuZWdhdGl2ZXMpLCBhbmQgdW5wYXJzYWJsZSBkYXRlcyB5aWVsZCBgdW5kZWZpbmVkYCBzb1xuICogY2FsbGVycyBjYW4gZmFsbCBiYWNrIHRvIGZ1bGwgaml0dGVyLiBBbiBIVFRQLWRhdGUgaW4gdGhlIHBhc3QgeWllbGRzIGAwYC5cbiAqXG4gKiBAcGFyYW0gdmFsdWUgLSBSYXcgYFJldHJ5LUFmdGVyYCBoZWFkZXIgdmFsdWVcbiAqIEBwYXJhbSBub3dNcyAtIEN1cnJlbnQgdGltZSBpbiBtaWxsaXNlY29uZHMgKGluamVjdGFibGUgZm9yIHRlc3RzKVxuICogQHJldHVybnMgRGVsYXkgaW4gbWlsbGlzZWNvbmRzLCBvciBgdW5kZWZpbmVkYCB3aGVuIHRoZSB2YWx1ZSBjYW5ub3QgYmUgcGFyc2VkXG4gKi9cbmV4cG9ydCBjb25zdCBwYXJzZVJldHJ5QWZ0ZXJNcyA9ICh2YWx1ZTogc3RyaW5nLCBub3dNczogbnVtYmVyID0gRGF0ZS5ub3coKSk6IG51bWJlciB8IHVuZGVmaW5lZCA9PiB7XG4gIGNvbnN0IHRyaW1tZWQgPSB2YWx1ZS50cmltKCk7XG4gIGlmICh0cmltbWVkID09PSAnJykge1xuICAgIHJldHVybiB1bmRlZmluZWQ7XG4gIH1cblxuICBpZiAoL15cXGQrJC8udGVzdCh0cmltbWVkKSkge1xuICAgIHJldHVybiBOdW1iZXIucGFyc2VJbnQodHJpbW1lZCwgMTApICogMTAwMDtcbiAgfVxuXG4gIC8vIFJlamVjdCBvdGhlciBudW1lcmljIGZvcm1zIChmbG9hdHMsIG5lZ2F0aXZlcyk7IG5vdCB2YWxpZCBkZWx0YS1zZWNvbmRzIG9yIEhUVFAtZGF0ZS5cbiAgaWYgKC9eLT9cXGQrKFxcLlxcZCspPyQvLnRlc3QodHJpbW1lZCkpIHtcbiAgICByZXR1cm4gdW5kZWZpbmVkO1xuICB9XG5cbiAgY29uc3QgZGF0ZU1zID0gRGF0ZS5wYXJzZSh0cmltbWVkKTtcbiAgaWYgKE51bWJlci5pc05hTihkYXRlTXMpKSB7XG4gICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgfVxuXG4gIHJldHVybiBNYXRoLm1heCgwLCBkYXRlTXMgLSBub3dNcyk7XG59O1xuXG4vKipcbiAqIENob29zZXMgdGhlIGRlbGF5IGJlZm9yZSB0aGUgbmV4dCBIVFRQIHJldHJ5OiBwcmVmZXIgYSB2YWxpZCBgUmV0cnktQWZ0ZXJgLCBlbHNlIGZ1bGwgaml0dGVyLlxuICpcbiAqIFJlYWRzIGByZXNwb25zZS5oZWFkZXJzLmdldCgnUmV0cnktQWZ0ZXInKWAgYW5kIHBhcnNlcyBpdCB3aXRoIHtAbGluayBwYXJzZVJldHJ5QWZ0ZXJNc30uXG4gKiBNaXNzaW5nIGhlYWRlcnMsIG9yIHZhbHVlcyB0aGF0IHBhcnNlIHRvIGB1bmRlZmluZWRgLCBmYWxsIGJhY2sgdG8ge0BsaW5rIGZ1bGxKaXR0ZXJ9LlxuICogQWJvcnQgYW5kIG5ldHdvcmsgcmV0cmllcyBkbyBub3QgdXNlIHRoaXMgaGVscGVyLlxuICpcbiAqIEBwYXJhbSByZXNwb25zZSAtIE5vbi1PSyByZXNwb25zZSBmcm9tIHRoZSBjdXJyZW50IGF0dGVtcHRcbiAqIEBwYXJhbSBiYXNlQmFja29mZk1zIC0gQmFzZSBiYWNrb2ZmIHBhc3NlZCB0byB7QGxpbmsgZnVsbEppdHRlcn0gd2hlbiBmYWxsaW5nIGJhY2tcbiAqIEBwYXJhbSBhdHRlbXB0IC0gMS1iYXNlZCBhdHRlbXB0IGluZGV4XG4gKiBAcGFyYW0gbWF4QmFja29mZk1zIC0gT3B0aW9uYWwgY2VpbGluZyBhcHBsaWVkIG9ubHkgdG8gdGhlIGppdHRlciBmYWxsYmFja1xuICogQHBhcmFtIG5vd01zIC0gQ3VycmVudCB0aW1lIGluIG1pbGxpc2Vjb25kcyAoaW5qZWN0YWJsZSBmb3IgdGVzdHMpXG4gKiBAcmV0dXJucyBXYWl0IGR1cmF0aW9uIGluIG1pbGxpc2Vjb25kcyBiZWZvcmUgdGhlIG5leHQgYXR0ZW1wdFxuICovXG5leHBvcnQgY29uc3QgcmVzb2x2ZVJldHJ5RGVsYXlNcyA9IChcbiAgcmVzcG9uc2U6IFJlc3BvbnNlLFxuICBiYXNlQmFja29mZk1zOiBudW1iZXIsXG4gIGF0dGVtcHQ6IG51bWJlcixcbiAgbWF4QmFja29mZk1zPzogbnVtYmVyLFxuICBub3dNczogbnVtYmVyID0gRGF0ZS5ub3coKSxcbik6IG51bWJlciA9PiB7XG4gIGNvbnN0IGhlYWRlciA9IHJlc3BvbnNlLmhlYWRlcnM/LmdldCgnUmV0cnktQWZ0ZXInKTtcbiAgaWYgKGhlYWRlciA9PSBudWxsKSB7XG4gICAgcmV0dXJuIGZ1bGxKaXR0ZXIoYmFzZUJhY2tvZmZNcywgYXR0ZW1wdCwgbWF4QmFja29mZk1zKTtcbiAgfVxuXG4gIGNvbnN0IGZyb21IZWFkZXIgPSBwYXJzZVJldHJ5QWZ0ZXJNcyhoZWFkZXIsIG5vd01zKTtcbiAgaWYgKGZyb21IZWFkZXIgPT09IHVuZGVmaW5lZCkge1xuICAgIHJldHVybiBmdWxsSml0dGVyKGJhc2VCYWNrb2ZmTXMsIGF0dGVtcHQsIG1heEJhY2tvZmZNcyk7XG4gIH1cblxuICByZXR1cm4gZnJvbUhlYWRlcjtcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/options.d.ts

@@ -32,27 +32,34 @@ export interface RequestOptions {
     init?: FetchInitOptions;
     /**
      * Maximum number of attempts, including the first.
-     * Must be `>= 1`.
+     * Must be a finite integer `>= 1`.
      */
     retries: number;
     /**
      * Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded.
-     * Must be `> 0`.
+     * Must be a finite integer `> 0`.
      */
     timeoutMs: number;
     /**
      * Base backoff in milliseconds for full jitter when `Retry-After` is absent or invalid.
      * The exponential span for attempt `n` is `baseBackoffMs * 2^n`, then the result is clipped
      * by {@link RequestOptions.maxBackoffMs} when that option is set.
-     * Must be `>= 0` (`0` skips backoff delay between attempts when falling back to jitter).
+     * Must be a finite integer `>= 0` (`0` skips backoff delay between attempts when falling back to jitter).
      */
     baseBackoffMs: number;
     /**
      * Optional ceiling in milliseconds applied to the full-jitter delay.
      * When set, `Math.min(jitter, maxBackoffMs)` is used. Does not clip a valid `Retry-After`.
-     * Must be `>= 0` when provided (`0` skips jitter wait). Omitted means no extra clip.
+     * Must be a finite integer `>= 0` when provided (`0` skips jitter wait). Omitted means no extra clip.
      */
     maxBackoffMs?: number;
+    /**
+     * Optional ceiling in milliseconds applied to a finite `Retry-After` delay.
+     * When set, `Math.min(delay, maxRetryAfterMs)` is used. Does not change full jitter.
+     * Must be a finite integer `>= 0` when provided (`0` skips the `Retry-After` wait).
+     * Omitted means a finite `Retry-After` delay is not clipped.
+     */
+    maxRetryAfterMs?: number;
     /**
      * Optional external {@link AbortSignal}. When aborted during an attempt, the in-flight request
      * is aborted. On the last attempt this surfaces as {@link FetchRetrierAbortError}. If retries

package/lib/core/options.js

@@ -3,4 +3,4 @@
  * Public option types for {@link fetchRetrier}.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/policy/validate-options.d.ts

@@ -2,11 +2,11 @@ import { RequestOptions } from '../options';
 /**
  * Validates retry policy numeric fields on {@link RequestOptions}.
  *
- * Constraints: `retries >= 1`, `timeoutMs > 0`, `baseBackoffMs >= 0`, and when set
- * `maxBackoffMs >= 0`.
+ * Each value must be a finite integer. Constraints: `retries >= 1`, `timeoutMs > 0`,
+ * `baseBackoffMs >= 0`, and when set `maxBackoffMs >= 0` and `maxRetryAfterMs >= 0`.
  *
  * @param options - Options whose `retries`, `timeoutMs`, `baseBackoffMs`, and optional
- *   `maxBackoffMs` are checked
+ *   `maxBackoffMs` and `maxRetryAfterMs` are checked
  * @throws {FetchRetrierInvalidOptionsError} When any constraint is violated
  */
-export declare const validateRequestOptions: (options: Pick<RequestOptions, "retries" | "timeoutMs" | "baseBackoffMs" | "maxBackoffMs">) => void;
+export declare const validateRequestOptions: (options: Pick<RequestOptions, "retries" | "timeoutMs" | "baseBackoffMs" | "maxBackoffMs" | "maxRetryAfterMs">) => void;

package/lib/core/policy/validate-options.js

@@ -2,30 +2,42 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateRequestOptions = void 0;
 const errors_1 = require("../errors");
+/**
+ * True when `value` is a finite integer.
+ *
+ * Relational checks alone accept `NaN` (every comparison is false) and `Infinity`.
+ * A non-integer `retries` also changes how many attempts the loop runs.
+ */
+const isFiniteInteger = (value) => {
+    return Number.isFinite(value) && Number.isInteger(value);
+};
 /**
  * Validates retry policy numeric fields on {@link RequestOptions}.
  *
- * Constraints: `retries >= 1`, `timeoutMs > 0`, `baseBackoffMs >= 0`, and when set
- * `maxBackoffMs >= 0`.
+ * Each value must be a finite integer. Constraints: `retries >= 1`, `timeoutMs > 0`,
+ * `baseBackoffMs >= 0`, and when set `maxBackoffMs >= 0` and `maxRetryAfterMs >= 0`.
  *
  * @param options - Options whose `retries`, `timeoutMs`, `baseBackoffMs`, and optional
- *   `maxBackoffMs` are checked
+ *   `maxBackoffMs` and `maxRetryAfterMs` are checked
  * @throws {FetchRetrierInvalidOptionsError} When any constraint is violated
  */
 const validateRequestOptions = (options) => {
-    const { retries, timeoutMs, baseBackoffMs, maxBackoffMs } = options;
-    if (retries < 1) {
-        throw new errors_1.FetchRetrierInvalidOptionsError('retries must be >= 1');
+    const { retries, timeoutMs, baseBackoffMs, maxBackoffMs, maxRetryAfterMs } = options;
+    if (!isFiniteInteger(retries) || retries < 1) {
+        throw new errors_1.FetchRetrierInvalidOptionsError('retries must be an integer >= 1');
+    }
+    if (!isFiniteInteger(timeoutMs) || timeoutMs <= 0) {
+        throw new errors_1.FetchRetrierInvalidOptionsError('timeoutMs must be an integer > 0');
     }
-    if (timeoutMs <= 0) {
-        throw new errors_1.FetchRetrierInvalidOptionsError('timeoutMs must be > 0');
+    if (!isFiniteInteger(baseBackoffMs) || baseBackoffMs < 0) {
+        throw new errors_1.FetchRetrierInvalidOptionsError('baseBackoffMs must be an integer >= 0');
     }
-    if (baseBackoffMs < 0) {
-        throw new errors_1.FetchRetrierInvalidOptionsError('baseBackoffMs must be >= 0');
+    if (maxBackoffMs !== undefined && (!isFiniteInteger(maxBackoffMs) || maxBackoffMs < 0)) {
+        throw new errors_1.FetchRetrierInvalidOptionsError('maxBackoffMs must be an integer >= 0');
     }
-    if (maxBackoffMs !== undefined && maxBackoffMs < 0) {
-        throw new errors_1.FetchRetrierInvalidOptionsError('maxBackoffMs must be >= 0');
+    if (maxRetryAfterMs !== undefined && (!isFiniteInteger(maxRetryAfterMs) || maxRetryAfterMs < 0)) {
+        throw new errors_1.FetchRetrierInvalidOptionsError('maxRetryAfterMs must be an integer >= 0');
     }
 };
 exports.validateRequestOptions = validateRequestOptions;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/fetch-retrier.d.ts

@@ -9,15 +9,18 @@ export type { FetchInitOptions, RequestOptions } from './core/options';
  * valid `Retry-After` header (delta-seconds or HTTP-date) is preferred over full jitter; abort
  * and network retries always use full jitter. Those waits end immediately when
  * {@link RequestOptions.signal} aborts. Optional {@link RequestOptions.maxBackoffMs} clips the
- * jitter result, not a valid `Retry-After`. The same {@link FetchInitOptions} (including `body`)
- * is reused on every attempt.
+ * jitter result, not a valid `Retry-After`. Optional {@link RequestOptions.maxRetryAfterMs} clips
+ * a finite `Retry-After` delay and does not change 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
  * @returns The first {@link Response} for which `ok` is `true`
- * @throws {FetchRetrierError} All failures from this function are subclasses of this class
- * @throws {FetchRetrierInvalidOptionsError} If `retries < 1`, `timeoutMs <= 0`, `baseBackoffMs < 0`,
- *   or `maxBackoffMs` is set and `< 0`
+ * @throws {FetchRetrierError} Failures created by this function are subclasses of this class.
+ *   An exception that is neither an `AbortError` nor a network `TypeError` is rethrown as-is
+ * @throws {FetchRetrierInvalidOptionsError} If `retries` is not a finite integer `>= 1`, `timeoutMs`
+ *   is not a finite integer `> 0`, `baseBackoffMs` is not a finite integer `>= 0`, or `maxBackoffMs`
+ *   or `maxRetryAfterMs` is set and is not a finite integer `>= 0`
  * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt,
  *   including after an in-flight external abort while retries remain, or when it aborts during
  *   backoff before the next attempt

package/lib/fetch-retrier.js

@@ -18,15 +18,18 @@ const wait_1 = require("./core/time/wait");
  * valid `Retry-After` header (delta-seconds or HTTP-date) is preferred over full jitter; abort
  * and network retries always use full jitter. Those waits end immediately when
  * {@link RequestOptions.signal} aborts. Optional {@link RequestOptions.maxBackoffMs} clips the
- * jitter result, not a valid `Retry-After`. The same {@link FetchInitOptions} (including `body`)
- * is reused on every attempt.
+ * jitter result, not a valid `Retry-After`. Optional {@link RequestOptions.maxRetryAfterMs} clips
+ * a finite `Retry-After` delay and does not change 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
  * @returns The first {@link Response} for which `ok` is `true`
- * @throws {FetchRetrierError} All failures from this function are subclasses of this class
- * @throws {FetchRetrierInvalidOptionsError} If `retries < 1`, `timeoutMs <= 0`, `baseBackoffMs < 0`,
- *   or `maxBackoffMs` is set and `< 0`
+ * @throws {FetchRetrierError} Failures created by this function are subclasses of this class.
+ *   An exception that is neither an `AbortError` nor a network `TypeError` is rethrown as-is
+ * @throws {FetchRetrierInvalidOptionsError} If `retries` is not a finite integer `>= 1`, `timeoutMs`
+ *   is not a finite integer `> 0`, `baseBackoffMs` is not a finite integer `>= 0`, or `maxBackoffMs`
+ *   or `maxRetryAfterMs` is set and is not a finite integer `>= 0`
  * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt,
  *   including after an in-flight external abort while retries remain, or when it aborts during
  *   backoff before the next attempt
@@ -38,8 +41,8 @@ const wait_1 = require("./core/time/wait");
  * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)
  */
 const fetchRetrier = async (url, options) => {
-    const { headers, init, retries, timeoutMs, baseBackoffMs, maxBackoffMs, signal: externalSignal, shouldRetry = default_should_retry_1.defaultShouldRetry, } = options;
-    (0, validate_options_1.validateRequestOptions)({ retries, timeoutMs, baseBackoffMs, maxBackoffMs });
+    const { headers, init, retries, timeoutMs, baseBackoffMs, maxBackoffMs, maxRetryAfterMs, signal: externalSignal, shouldRetry = default_should_retry_1.defaultShouldRetry, } = options;
+    (0, validate_options_1.validateRequestOptions)({ retries, timeoutMs, baseBackoffMs, maxBackoffMs, maxRetryAfterMs });
     for (let attempt = 1; attempt <= retries; attempt++) {
         if (externalSignal?.aborted) {
             throw new errors_1.FetchRetrierAlreadyAbortedError();
@@ -62,7 +65,7 @@ const fetchRetrier = async (url, options) => {
             if ((0, retry_predicates_1.isLastAttempt)(attempt, retries)) {
                 throw new errors_1.FetchRetrierHttpError(`HTTP ${res.status}`, res.status, text);
             }
-            await (0, wait_1.wait)((0, retry_after_1.resolveRetryDelayMs)(res, baseBackoffMs, attempt, maxBackoffMs), externalSignal);
+            await (0, wait_1.wait)((0, retry_after_1.resolveRetryDelayMs)(res, baseBackoffMs, attempt, maxBackoffMs, maxRetryAfterMs), externalSignal);
         }
         catch (err) {
             if (err instanceof Error && err.name === 'AbortError') {
@@ -85,4 +88,4 @@ const fetchRetrier = async (url, options) => {
     throw new errors_1.FetchRetrierUnreachableError();
 };
 exports.fetchRetrier = fetchRetrier;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch-retrier.js","sourceRoot":"","sources":["../src/fetch-retrier.ts"],"names":[],"mappings":"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","sourcesContent":["import { fullJitter } from './core/backoff/jitter';\nimport { resolveRetryDelayMs } from './core/backoff/retry-after';\nimport {\n  FetchRetrierAbortError,\n  FetchRetrierAlreadyAbortedError,\n  FetchRetrierHttpError,\n  FetchRetrierNetworkError,\n  FetchRetrierUnreachableError,\n} from './core/errors';\nimport { timedFetch } from './core/http/timed-fetch';\nimport { RequestOptions } from './core/options';\nimport { defaultShouldRetry } from './core/policy/default-should-retry';\nimport { validateRequestOptions } from './core/policy/validate-options';\nimport { isLastAttempt } from './core/retry-predicates';\nimport { wait } from './core/time/wait';\n\nexport type { FetchInitOptions, RequestOptions } from './core/options';\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 {@link timedFetch} with `timeoutMs`. Non-OK responses are retried when\n * `shouldRetry` returns `true` (default: {@link defaultShouldRetry}). Between HTTP retries, a\n * valid `Retry-After` header (delta-seconds or HTTP-date) is preferred over full jitter; abort\n * and network retries always use full jitter. Those waits end immediately when\n * {@link RequestOptions.signal} aborts. Optional {@link RequestOptions.maxBackoffMs} clips the\n * jitter result, not a valid `Retry-After`. The same {@link FetchInitOptions} (including `body`)\n * is reused 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 {FetchRetrierError} All failures from this function are subclasses of this class\n * @throws {FetchRetrierInvalidOptionsError} If `retries < 1`, `timeoutMs <= 0`, `baseBackoffMs < 0`,\n *   or `maxBackoffMs` is set and `< 0`\n * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt,\n *   including after an in-flight external abort while retries remain, or when it aborts during\n *   backoff before the next 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 per-attempt timeout after the last attempt, or external abort\n *   on 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    maxBackoffMs,\n    signal: externalSignal,\n    shouldRetry = defaultShouldRetry,\n  } = options;\n\n  validateRequestOptions({ retries, timeoutMs, baseBackoffMs, maxBackoffMs });\n\n  for (let attempt = 1; attempt <= retries; attempt++) {\n    if (externalSignal?.aborted) {\n      throw new FetchRetrierAlreadyAbortedError();\n    }\n\n    try {\n      const res = await timedFetch(url, {\n        timeoutMs,\n        init,\n        headers,\n        signal: externalSignal,\n      });\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        throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status, text);\n      }\n\n      if (isLastAttempt(attempt, retries)) {\n        throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status, text);\n      }\n\n      await wait(resolveRetryDelayMs(res, baseBackoffMs, attempt, maxBackoffMs), externalSignal);\n    } catch (err: unknown) {\n      if (err instanceof Error && err.name === 'AbortError') {\n        if (isLastAttempt(attempt, retries)) {\n          throw err instanceof FetchRetrierAbortError ? err : new FetchRetrierAbortError();\n        }\n        await wait(fullJitter(baseBackoffMs, attempt, maxBackoffMs), externalSignal);\n        continue;\n      }\n\n      if (err instanceof TypeError) {\n        if (isLastAttempt(attempt, retries)) {\n          throw new FetchRetrierNetworkError('Network error', err);\n        }\n        await wait(fullJitter(baseBackoffMs, attempt, maxBackoffMs), externalSignal);\n        continue;\n      }\n\n      throw err;\n    }\n  }\n\n  throw new FetchRetrierUnreachableError();\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch-retrier.js","sourceRoot":"","sources":["../src/fetch-retrier.ts"],"names":[],"mappings":"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","sourcesContent":["import { fullJitter } from './core/backoff/jitter';\nimport { resolveRetryDelayMs } from './core/backoff/retry-after';\nimport {\n  FetchRetrierAbortError,\n  FetchRetrierAlreadyAbortedError,\n  FetchRetrierHttpError,\n  FetchRetrierNetworkError,\n  FetchRetrierUnreachableError,\n} from './core/errors';\nimport { timedFetch } from './core/http/timed-fetch';\nimport { RequestOptions } from './core/options';\nimport { defaultShouldRetry } from './core/policy/default-should-retry';\nimport { validateRequestOptions } from './core/policy/validate-options';\nimport { isLastAttempt } from './core/retry-predicates';\nimport { wait } from './core/time/wait';\n\nexport type { FetchInitOptions, RequestOptions } from './core/options';\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 {@link timedFetch} with `timeoutMs`. Non-OK responses are retried when\n * `shouldRetry` returns `true` (default: {@link defaultShouldRetry}). Between HTTP retries, a\n * valid `Retry-After` header (delta-seconds or HTTP-date) is preferred over full jitter; abort\n * and network retries always use full jitter. Those waits end immediately when\n * {@link RequestOptions.signal} aborts. Optional {@link RequestOptions.maxBackoffMs} clips the\n * jitter result, not a valid `Retry-After`. Optional {@link RequestOptions.maxRetryAfterMs} clips\n * a finite `Retry-After` delay and does not change jitter. The same {@link FetchInitOptions}\n * (including `body`) is reused 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 {FetchRetrierError} Failures created by this function are subclasses of this class.\n *   An exception that is neither an `AbortError` nor a network `TypeError` is rethrown as-is\n * @throws {FetchRetrierInvalidOptionsError} If `retries` is not a finite integer `>= 1`, `timeoutMs`\n *   is not a finite integer `> 0`, `baseBackoffMs` is not a finite integer `>= 0`, or `maxBackoffMs`\n *   or `maxRetryAfterMs` is set and is not a finite integer `>= 0`\n * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt,\n *   including after an in-flight external abort while retries remain, or when it aborts during\n *   backoff before the next 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 per-attempt timeout after the last attempt, or external abort\n *   on 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    maxBackoffMs,\n    maxRetryAfterMs,\n    signal: externalSignal,\n    shouldRetry = defaultShouldRetry,\n  } = options;\n\n  validateRequestOptions({ retries, timeoutMs, baseBackoffMs, maxBackoffMs, maxRetryAfterMs });\n\n  for (let attempt = 1; attempt <= retries; attempt++) {\n    if (externalSignal?.aborted) {\n      throw new FetchRetrierAlreadyAbortedError();\n    }\n\n    try {\n      const res = await timedFetch(url, {\n        timeoutMs,\n        init,\n        headers,\n        signal: externalSignal,\n      });\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        throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status, text);\n      }\n\n      if (isLastAttempt(attempt, retries)) {\n        throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status, text);\n      }\n\n      await wait(\n        resolveRetryDelayMs(res, baseBackoffMs, attempt, maxBackoffMs, maxRetryAfterMs),\n        externalSignal,\n      );\n    } catch (err: unknown) {\n      if (err instanceof Error && err.name === 'AbortError') {\n        if (isLastAttempt(attempt, retries)) {\n          throw err instanceof FetchRetrierAbortError ? err : new FetchRetrierAbortError();\n        }\n        await wait(fullJitter(baseBackoffMs, attempt, maxBackoffMs), externalSignal);\n        continue;\n      }\n\n      if (err instanceof TypeError) {\n        if (isLastAttempt(attempt, retries)) {\n          throw new FetchRetrierNetworkError('Network error', err);\n        }\n        await wait(fullJitter(baseBackoffMs, attempt, maxBackoffMs), externalSignal);\n        continue;\n      }\n\n      throw err;\n    }\n  }\n\n  throw new FetchRetrierUnreachableError();\n};\n"]}

package/lib/index.d.ts

@@ -9,3 +9,4 @@ export { DEFAULT_RETRYABLE_HTTP_STATUSES, defaultShouldRetry, } from './default-
 export { fetchRetrier } from './fetch-retrier';
 export type { FetchInitOptions, RequestOptions } from './fetch-retrier';
 export { parseRetryAfterMs } from './parse-retry-after';
+export type { ParseRetryAfterOptions } from './parse-retry-after';

package/lib/index.js

@@ -22,4 +22,4 @@ var fetch_retrier_1 = require("./fetch-retrier");
 Object.defineProperty(exports, "fetchRetrier", { enumerable: true, get: function () { return fetch_retrier_1.fetchRetrier; } });
 var parse_retry_after_1 = require("./parse-retry-after");
 Object.defineProperty(exports, "parseRetryAfterMs", { enumerable: true, get: function () { return parse_retry_after_1.parseRetryAfterMs; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7OztHQUtHOzs7QUFFSCx3Q0FRdUI7QUFQckIsZ0hBQUEsc0JBQXNCLE9BQUE7QUFDdEIseUhBQUEsK0JBQStCLE9BQUE7QUFDL0IsMkdBQUEsaUJBQWlCLE9BQUE7QUFDakIsK0dBQUEscUJBQXFCLE9BQUE7QUFDckIseUhBQUEsK0JBQStCLE9BQUE7QUFDL0Isa0hBQUEsd0JBQXdCLE9BQUE7QUFDeEIsc0hBQUEsNEJBQTRCLE9BQUE7QUFFOUIsK0RBR2dDO0FBRjlCLHVJQUFBLCtCQUErQixPQUFBO0FBQy9CLDBIQUFBLGtCQUFrQixPQUFBO0FBRXBCLGlEQUErQztBQUF0Qyw2R0FBQSxZQUFZLE9BQUE7QUFFckIseURBQXdEO0FBQS9DLHNIQUFBLGlCQUFpQixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZXRyeS1lbmFibGVkIGBmZXRjaGAgd3JhcHBlciB3aXRoIHBlci1hdHRlbXB0IHRpbWVvdXQsIFJldHJ5LUFmdGVyIHN1cHBvcnQsIGZ1bGwtaml0dGVyIGJhY2tvZmYsXG4gKiBvcHRpb24gdmFsaWRhdGlvbiwgYW5kIHR5cGVkIGVycm9ycy5cbiAqXG4gKiBAbW9kdWxlIGZldGNoLXJldHJpZXJcbiAqL1xuXG5leHBvcnQge1xuICBGZXRjaFJldHJpZXJBYm9ydEVycm9yLFxuICBGZXRjaFJldHJpZXJBbHJlYWR5QWJvcnRlZEVycm9yLFxuICBGZXRjaFJldHJpZXJFcnJvcixcbiAgRmV0Y2hSZXRyaWVySHR0cEVycm9yLFxuICBGZXRjaFJldHJpZXJJbnZhbGlkT3B0aW9uc0Vycm9yLFxuICBGZXRjaFJldHJpZXJOZXR3b3JrRXJyb3IsXG4gIEZldGNoUmV0cmllclVucmVhY2hhYmxlRXJyb3IsXG59IGZyb20gJy4vY29yZS9lcnJvcnMnO1xuZXhwb3J0IHtcbiAgREVGQVVMVF9SRVRSWUFCTEVfSFRUUF9TVEFUVVNFUyxcbiAgZGVmYXVsdFNob3VsZFJldHJ5LFxufSBmcm9tICcuL2RlZmF1bHQtc2hvdWxkLXJldHJ5JztcbmV4cG9ydCB7IGZldGNoUmV0cmllciB9IGZyb20gJy4vZmV0Y2gtcmV0cmllcic7XG5leHBvcnQgdHlwZSB7IEZldGNoSW5pdE9wdGlvbnMsIFJlcXVlc3RPcHRpb25zIH0gZnJvbSAnLi9mZXRjaC1yZXRyaWVyJztcbmV4cG9ydCB7IHBhcnNlUmV0cnlBZnRlck1zIH0gZnJvbSAnLi9wYXJzZS1yZXRyeS1hZnRlcic7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7OztHQUtHOzs7QUFFSCx3Q0FRdUI7QUFQckIsZ0hBQUEsc0JBQXNCLE9BQUE7QUFDdEIseUhBQUEsK0JBQStCLE9BQUE7QUFDL0IsMkdBQUEsaUJBQWlCLE9BQUE7QUFDakIsK0dBQUEscUJBQXFCLE9BQUE7QUFDckIseUhBQUEsK0JBQStCLE9BQUE7QUFDL0Isa0hBQUEsd0JBQXdCLE9BQUE7QUFDeEIsc0hBQUEsNEJBQTRCLE9BQUE7QUFFOUIsK0RBR2dDO0FBRjlCLHVJQUFBLCtCQUErQixPQUFBO0FBQy9CLDBIQUFBLGtCQUFrQixPQUFBO0FBRXBCLGlEQUErQztBQUF0Qyw2R0FBQSxZQUFZLE9BQUE7QUFFckIseURBQXdEO0FBQS9DLHNIQUFBLGlCQUFpQixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZXRyeS1lbmFibGVkIGBmZXRjaGAgd3JhcHBlciB3aXRoIHBlci1hdHRlbXB0IHRpbWVvdXQsIFJldHJ5LUFmdGVyIHN1cHBvcnQsIGZ1bGwtaml0dGVyIGJhY2tvZmYsXG4gKiBvcHRpb24gdmFsaWRhdGlvbiwgYW5kIHR5cGVkIGVycm9ycy5cbiAqXG4gKiBAbW9kdWxlIGZldGNoLXJldHJpZXJcbiAqL1xuXG5leHBvcnQge1xuICBGZXRjaFJldHJpZXJBYm9ydEVycm9yLFxuICBGZXRjaFJldHJpZXJBbHJlYWR5QWJvcnRlZEVycm9yLFxuICBGZXRjaFJldHJpZXJFcnJvcixcbiAgRmV0Y2hSZXRyaWVySHR0cEVycm9yLFxuICBGZXRjaFJldHJpZXJJbnZhbGlkT3B0aW9uc0Vycm9yLFxuICBGZXRjaFJldHJpZXJOZXR3b3JrRXJyb3IsXG4gIEZldGNoUmV0cmllclVucmVhY2hhYmxlRXJyb3IsXG59IGZyb20gJy4vY29yZS9lcnJvcnMnO1xuZXhwb3J0IHtcbiAgREVGQVVMVF9SRVRSWUFCTEVfSFRUUF9TVEFUVVNFUyxcbiAgZGVmYXVsdFNob3VsZFJldHJ5LFxufSBmcm9tICcuL2RlZmF1bHQtc2hvdWxkLXJldHJ5JztcbmV4cG9ydCB7IGZldGNoUmV0cmllciB9IGZyb20gJy4vZmV0Y2gtcmV0cmllcic7XG5leHBvcnQgdHlwZSB7IEZldGNoSW5pdE9wdGlvbnMsIFJlcXVlc3RPcHRpb25zIH0gZnJvbSAnLi9mZXRjaC1yZXRyaWVyJztcbmV4cG9ydCB7IHBhcnNlUmV0cnlBZnRlck1zIH0gZnJvbSAnLi9wYXJzZS1yZXRyeS1hZnRlcic7XG5leHBvcnQgdHlwZSB7IFBhcnNlUmV0cnlBZnRlck9wdGlvbnMgfSBmcm9tICcuL3BhcnNlLXJldHJ5LWFmdGVyJztcbiJdfQ==

package/lib/parse-retry-after.d.ts

@@ -4,3 +4,4 @@
  * The implementation stays in core because HTTP retry delay selection uses the same function.
  */
 export { parseRetryAfterMs } from './core/backoff/retry-after';
+export type { ParseRetryAfterOptions } from './core/backoff/retry-after';

package/lib/parse-retry-after.js

@@ -8,4 +8,4 @@ exports.parseRetryAfterMs = void 0;
  */
 var retry_after_1 = require("./core/backoff/retry-after");
 Object.defineProperty(exports, "parseRetryAfterMs", { enumerable: true, get: function () { return retry_after_1.parseRetryAfterMs; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2UtcmV0cnktYWZ0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvcGFyc2UtcmV0cnktYWZ0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7Ozs7R0FJRztBQUNILDBEQUErRDtBQUF0RCxnSEFBQSxpQkFBaUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIGVudHJ5IGZvciBwYXJzaW5nIGEgYFJldHJ5LUFmdGVyYCBoZWFkZXIuXG4gKlxuICogVGhlIGltcGxlbWVudGF0aW9uIHN0YXlzIGluIGNvcmUgYmVjYXVzZSBIVFRQIHJldHJ5IGRlbGF5IHNlbGVjdGlvbiB1c2VzIHRoZSBzYW1lIGZ1bmN0aW9uLlxuICovXG5leHBvcnQgeyBwYXJzZVJldHJ5QWZ0ZXJNcyB9IGZyb20gJy4vY29yZS9iYWNrb2ZmL3JldHJ5LWFmdGVyJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2UtcmV0cnktYWZ0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvcGFyc2UtcmV0cnktYWZ0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7Ozs7R0FJRztBQUNILDBEQUErRDtBQUF0RCxnSEFBQSxpQkFBaUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIGVudHJ5IGZvciBwYXJzaW5nIGEgYFJldHJ5LUFmdGVyYCBoZWFkZXIuXG4gKlxuICogVGhlIGltcGxlbWVudGF0aW9uIHN0YXlzIGluIGNvcmUgYmVjYXVzZSBIVFRQIHJldHJ5IGRlbGF5IHNlbGVjdGlvbiB1c2VzIHRoZSBzYW1lIGZ1bmN0aW9uLlxuICovXG5leHBvcnQgeyBwYXJzZVJldHJ5QWZ0ZXJNcyB9IGZyb20gJy4vY29yZS9iYWNrb2ZmL3JldHJ5LWFmdGVyJztcbmV4cG9ydCB0eXBlIHsgUGFyc2VSZXRyeUFmdGVyT3B0aW9ucyB9IGZyb20gJy4vY29yZS9iYWNrb2ZmL3JldHJ5LWFmdGVyJztcbiJdfQ==

package/package.json

@@ -32,7 +32,7 @@
     "organization": false
   },
   "devDependencies": {
-    "@gammarers/projen-projects": "^0.5.8",
+    "@gammarers/projen-projects": "^0.8.0",
     "@stylistic/eslint-plugin": "^2",
     "@types/jest": "^30.0.0",
     "@types/node": "^20",
@@ -64,9 +64,17 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.7.4",
+  "version": "0.8.0",
   "jest": {
     "coverageProvider": "v8",
+    "coverageThreshold": {
+      "global": {
+        "branches": 95,
+        "functions": 90,
+        "lines": 100,
+        "statements": 100
+      }
+    },
     "testMatch": [
       "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
       "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",