fetch-retrier 0.5.6 → 0.6.0

package/lib/core/fetch-retrier.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRetrier = void 0;
+const jitter_1 = require("./backoff/jitter");
+const retry_after_1 = require("./backoff/retry-after");
+const errors_1 = require("./errors");
+const timed_fetch_1 = require("./http/timed-fetch");
+const default_should_retry_1 = require("./policy/default-should-retry");
+const validate_options_1 = require("./policy/validate-options");
+const retry_predicates_1 = require("./retry-predicates");
+const wait_1 = require("./time/wait");
+/**
+ * Wraps `fetch` with retries, per-attempt timeout, Retry-After support, full-jitter backoff, and
+ * optional cancellation.
+ *
+ * Each attempt calls {@link timedFetch} with `timeoutMs`. Non-OK responses are retried when
+ * `shouldRetry` returns `true` (default: {@link defaultShouldRetry}). Between HTTP retries, a
+ * valid `Retry-After` header (delta-seconds or HTTP-date) is preferred over full jitter; abort
+ * and network retries always use full jitter. Optional {@link RequestOptions.maxBackoffMs} clips
+ * the jitter result, not a valid `Retry-After`. 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 {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt,
+ *   including the next attempt after an in-flight external abort while retries remain
+ * @throws {FetchRetrierHttpError} On a non-OK response that is not retried or after the last attempt
+ *   (includes `status` and `body`)
+ * @throws {FetchRetrierNetworkError} On a network `TypeError` after the last attempt
+ * @throws {FetchRetrierAbortError} On per-attempt timeout after the last attempt, or external abort
+ *   on the last attempt
+ * @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 });
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        if (externalSignal?.aborted) {
+            throw new errors_1.FetchRetrierAlreadyAbortedError();
+        }
+        try {
+            const res = await (0, timed_fetch_1.timedFetch)(url, {
+                timeoutMs,
+                init,
+                headers,
+                signal: externalSignal,
+            });
+            if (res.ok) {
+                return res;
+            }
+            const text = await res.text();
+            const isContinue = shouldRetry(res, text);
+            if (!isContinue) {
+                throw new errors_1.FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status, text);
+            }
+            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));
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                if ((0, retry_predicates_1.isLastAttempt)(attempt, retries)) {
+                    throw err instanceof errors_1.FetchRetrierAbortError ? err : new errors_1.FetchRetrierAbortError();
+                }
+                await (0, wait_1.wait)((0, jitter_1.fullJitter)(baseBackoffMs, attempt, maxBackoffMs));
+                continue;
+            }
+            if (err instanceof TypeError) {
+                if ((0, retry_predicates_1.isLastAttempt)(attempt, retries)) {
+                    throw new errors_1.FetchRetrierNetworkError('Network error', err);
+                }
+                await (0, wait_1.wait)((0, jitter_1.fullJitter)(baseBackoffMs, attempt, maxBackoffMs));
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw new errors_1.FetchRetrierUnreachableError();
+};
+exports.fetchRetrier = fetchRetrier;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch-retrier.js","sourceRoot":"","sources":["../../src/core/fetch-retrier.ts"],"names":[],"mappings":";;;AAAA,6CAA8C;AAC9C,uDAA4D;AAC5D,qCAMkB;AAClB,oDAAgD;AAEhD,wEAAmE;AACnE,gEAAmE;AACnE,yDAAmD;AACnD,sCAAmC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACI,MAAM,YAAY,GAAG,KAAK,EAAE,GAAW,EAAE,OAAuB,EAAqB,EAAE;IAC5F,MAAM,EACJ,OAAO,EACP,IAAI,EACJ,OAAO,EACP,SAAS,EACT,aAAa,EACb,YAAY,EACZ,MAAM,EAAE,cAAc,EACtB,WAAW,GAAG,yCAAkB,GACjC,GAAG,OAAO,CAAC;IAEZ,IAAA,yCAAsB,EAAC,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,CAAC,CAAC;IAE5E,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC;QACpD,IAAI,cAAc,EAAE,OAAO,EAAE,CAAC;YAC5B,MAAM,IAAI,wCAA+B,EAAE,CAAC;QAC9C,CAAC;QAED,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,IAAA,wBAAU,EAAC,GAAG,EAAE;gBAChC,SAAS;gBACT,IAAI;gBACJ,OAAO;gBACP,MAAM,EAAE,cAAc;aACvB,CAAC,CAAC;YAEH,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,CAAC,UAAU,EAAE,CAAC;gBAChB,MAAM,IAAI,8BAAqB,CAAC,6BAA6B,GAAG,CAAC,MAAM,EAAE,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC/F,CAAC;YAED,IAAI,IAAA,gCAAa,EAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;gBACpC,MAAM,IAAI,8BAAqB,CAAC,QAAQ,GAAG,CAAC,MAAM,EAAE,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC1E,CAAC;YAED,MAAM,IAAA,WAAI,EAAC,IAAA,iCAAmB,EAAC,GAAG,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;QAC7E,CAAC;QAAC,OAAO,GAAY,EAAE,CAAC;YACtB,IAAI,GAAG,YAAY,KAAK,IAAI,GAAG,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBACtD,IAAI,IAAA,gCAAa,EAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;oBACpC,MAAM,GAAG,YAAY,+BAAsB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,+BAAsB,EAAE,CAAC;gBACnF,CAAC;gBACD,MAAM,IAAA,WAAI,EAAC,IAAA,mBAAU,EAAC,aAAa,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;gBAC7D,SAAS;YACX,CAAC;YAED,IAAI,GAAG,YAAY,SAAS,EAAE,CAAC;gBAC7B,IAAI,IAAA,gCAAa,EAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;oBACpC,MAAM,IAAI,iCAAwB,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;gBAC3D,CAAC;gBACD,MAAM,IAAA,WAAI,EAAC,IAAA,mBAAU,EAAC,aAAa,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;gBAC7D,SAAS;YACX,CAAC;YAED,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;IAED,MAAM,IAAI,qCAA4B,EAAE,CAAC;AAC3C,CAAC,CAAC;AAjEW,QAAA,YAAY,gBAiEvB","sourcesContent":["import { fullJitter } from './backoff/jitter';\nimport { resolveRetryDelayMs } from './backoff/retry-after';\nimport {\n  FetchRetrierAbortError,\n  FetchRetrierAlreadyAbortedError,\n  FetchRetrierHttpError,\n  FetchRetrierNetworkError,\n  FetchRetrierUnreachableError,\n} from './errors';\nimport { timedFetch } from './http/timed-fetch';\nimport { RequestOptions } from './options';\nimport { defaultShouldRetry } from './policy/default-should-retry';\nimport { validateRequestOptions } from './policy/validate-options';\nimport { isLastAttempt } from './retry-predicates';\nimport { wait } from './time/wait';\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. Optional {@link RequestOptions.maxBackoffMs} clips\n * the jitter result, not a valid `Retry-After`. The same {@link FetchInitOptions} (including\n * `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} 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 the next attempt after an in-flight external abort while retries remain\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));\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));\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));\n        continue;\n      }\n\n      throw err;\n    }\n  }\n\n  throw new FetchRetrierUnreachableError();\n};\n"]}

package/lib/core/http/timed-fetch.d.ts

@@ -0,0 +1,32 @@
+/**
+ * One HTTP attempt: per-attempt timeout and optional external abort, then `fetch`.
+ *
+ * Does not retry or map failures to package errors. Native `AbortError` and `TypeError`
+ * propagate to the caller.
+ */
+export interface TimedFetchOptions {
+    /**
+     * Per-attempt timeout in milliseconds.
+     */
+    timeoutMs: number;
+    /**
+     * `fetch` options excluding `signal`.
+     */
+    init?: Omit<RequestInit, 'signal'>;
+    /**
+     * Headers sent on this attempt. Override `init.headers` when both are set.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Optional external abort signal; aborts the in-flight request when fired.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Calls `fetch` with an internal {@link AbortSignal} for `timeoutMs`.
+ *
+ * @param url - Request URL passed to `fetch`
+ * @param options - Timeout, init, headers, and optional external signal
+ * @returns The {@link Response} from this single attempt
+ */
+export declare const timedFetch: (url: string, options: TimedFetchOptions) => Promise<Response>;

package/lib/core/http/timed-fetch.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * One HTTP attempt: per-attempt timeout and optional external abort, then `fetch`.
+ *
+ * Does not retry or map failures to package errors. Native `AbortError` and `TypeError`
+ * propagate to the caller.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timedFetch = void 0;
+/**
+ * Calls `fetch` with an internal {@link AbortSignal} for `timeoutMs`.
+ *
+ * @param url - Request URL passed to `fetch`
+ * @param options - Timeout, init, headers, and optional external signal
+ * @returns The {@link Response} from this single attempt
+ */
+const timedFetch = async (url, options) => {
+    const { timeoutMs, init, headers, signal: externalSignal } = options;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const onExternalAbort = () => {
+        clearTimeout(timer);
+        controller.abort();
+    };
+    if (externalSignal) {
+        externalSignal.addEventListener('abort', onExternalAbort);
+    }
+    try {
+        return await fetch(url, {
+            ...init,
+            ...(headers !== undefined ? { headers } : {}),
+            signal: controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+        externalSignal?.removeEventListener('abort', onExternalAbort);
+    }
+};
+exports.timedFetch = timedFetch;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/options.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Public option types for {@link fetchRetrier}.
+ */
+/**
+ * `fetch` options forwarded to every attempt, excluding `signal`.
+ *
+ * Use for `method`, `body`, `credentials`, `redirect`, `mode`, `cache`, and other
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/RequestInit | RequestInit} fields.
+ * Per-attempt abort and timeout are handled internally via `signal` and must not be set here.
+ */
+export type FetchInitOptions = Omit<RequestInit, 'signal'>;
+/**
+ * Options for {@link fetchRetrier}: retry policy, timeout, backoff (including `Retry-After`),
+ * request payload, and cancellation.
+ *
+ * Request shape is built as `{ ...init, headers?, signal }` on each attempt. Top-level `headers`
+ * override `init.headers` when both are provided.
+ *
+ * Numeric fields are validated when {@link fetchRetrier} is called; invalid values throw
+ * {@link FetchRetrierInvalidOptionsError}.
+ */
+export interface RequestOptions {
+    /**
+     * HTTP headers sent on every attempt.
+     * When `init.headers` is also set, these values take precedence for duplicate keys.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Additional {@link FetchInitOptions} merged into each `fetch` call (e.g. POST `method` and JSON `body`).
+     * The same `init` is reused across retries.
+     */
+    init?: FetchInitOptions;
+    /**
+     * Maximum number of attempts, including the first.
+     * Must be `>= 1`.
+     */
+    retries: number;
+    /**
+     * Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded.
+     * Must be `> 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).
+     */
+    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.
+     */
+    maxBackoffMs?: 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
+     * remain, the next attempt sees the still-aborted signal and throws
+     * {@link FetchRetrierAlreadyAbortedError}. Distinct from per-attempt timeout, which retries
+     * remaining attempts and only then throws {@link FetchRetrierAbortError}.
+     */
+    signal?: AbortSignal;
+    /**
+     * Invoked after `response.text()` when `response.ok` is false.
+     * Return `true` to schedule another attempt (until `retries` is exhausted).
+     * 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;
+}

package/lib/core/options.js

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

package/lib/core/policy/default-should-retry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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;

package/lib/core/policy/default-should-retry.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultShouldRetry = exports.DEFAULT_RETRYABLE_HTTP_STATUSES = void 0;
+/**
+ * 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 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 = (response, _body) => {
+    return exports.DEFAULT_RETRYABLE_HTTP_STATUSES.includes(response.status);
+};
+exports.defaultShouldRetry = defaultShouldRetry;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1zaG91bGQtcmV0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29yZS9wb2xpY3kvZGVmYXVsdC1zaG91bGQtcmV0cnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7Ozs7R0FJRztBQUNVLFFBQUEsK0JBQStCLEdBQXNCLENBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUM7QUFFdEc7Ozs7Ozs7Ozs7R0FVRztBQUNJLE1BQU0sa0JBQWtCLEdBQUcsQ0FBQyxRQUFrQixFQUFFLEtBQWEsRUFBVyxFQUFFO0lBQy9FLE9BQU8sdUNBQStCLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUNuRSxDQUFDLENBQUM7QUFGVyxRQUFBLGtCQUFrQixzQkFFN0IiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEhUVFAgc3RhdHVzIGNvZGVzIHJldHJpZWQgYnkgZGVmYXVsdCB3aGVuIHtAbGluayBSZXF1ZXN0T3B0aW9ucy5zaG91bGRSZXRyeX0gaXMgb21pdHRlZC5cbiAqXG4gKiBJbmNsdWRlcyB0cmFuc2llbnQgY2xpZW50L3NlcnZlciBlcnJvcnM6IDQwOCwgNDI1LCA0MjksIGFuZCBjb21tb24gNXh4IGdhdGV3YXkgb3Igb3ZlcmxvYWQgcmVzcG9uc2VzLlxuICovXG5leHBvcnQgY29uc3QgREVGQVVMVF9SRVRSWUFCTEVfSFRUUF9TVEFUVVNFUzogcmVhZG9ubHkgbnVtYmVyW10gPSBbNDA4LCA0MjUsIDQyOSwgNTAwLCA1MDIsIDUwMywgNTA0XTtcblxuLyoqXG4gKiBEZWZhdWx0IHtAbGluayBSZXF1ZXN0T3B0aW9ucy5zaG91bGRSZXRyeX06IHJldHJpZXMgcmVzcG9uc2VzIHdob3NlIHN0YXR1cyBpcyBpblxuICoge0BsaW5rIERFRkFVTFRfUkVUUllBQkxFX0hUVFBfU1RBVFVTRVN9LlxuICpcbiAqIENvbXBvc2Ugd2l0aCBjdXN0b20gbG9naWMsIGZvciBleGFtcGxlOlxuICogYChyZXMsIGJvZHkpID0+IGRlZmF1bHRTaG91bGRSZXRyeShyZXMsIGJvZHkpIHx8IHJlcy5zdGF0dXMgPT09IDQxOGAuXG4gKlxuICogQHBhcmFtIHJlc3BvbnNlIC0gUmVzcG9uc2UgZnJvbSB0aGUgZmFpbGVkIGF0dGVtcHRcbiAqIEBwYXJhbSBfYm9keSAtIFJlc3BvbnNlIGJvZHkgdGV4dCAodW51c2VkIGJ5IHRoZSBkZWZhdWx0IHByZWRpY2F0ZSlcbiAqIEByZXR1cm5zIGB0cnVlYCB3aGVuIGFub3RoZXIgYXR0ZW1wdCBzaG91bGQgYmUgc2NoZWR1bGVkXG4gKi9cbmV4cG9ydCBjb25zdCBkZWZhdWx0U2hvdWxkUmV0cnkgPSAocmVzcG9uc2U6IFJlc3BvbnNlLCBfYm9keTogc3RyaW5nKTogYm9vbGVhbiA9PiB7XG4gIHJldHVybiBERUZBVUxUX1JFVFJZQUJMRV9IVFRQX1NUQVRVU0VTLmluY2x1ZGVzKHJlc3BvbnNlLnN0YXR1cyk7XG59O1xuIl19

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRequestOptions = void 0;
+const errors_1 = require("../errors");
+/**
+ * Validates retry policy numeric fields on {@link RequestOptions}.
+ *
+ * Constraints: `retries >= 1`, `timeoutMs > 0`, `baseBackoffMs >= 0`, and when set
+ * `maxBackoffMs >= 0`.
+ *
+ * @param options - Options whose `retries`, `timeoutMs`, `baseBackoffMs`, and optional
+ *   `maxBackoffMs` 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');
+    }
+    if (timeoutMs <= 0) {
+        throw new errors_1.FetchRetrierInvalidOptionsError('timeoutMs must be > 0');
+    }
+    if (baseBackoffMs < 0) {
+        throw new errors_1.FetchRetrierInvalidOptionsError('baseBackoffMs must be >= 0');
+    }
+    if (maxBackoffMs !== undefined && maxBackoffMs < 0) {
+        throw new errors_1.FetchRetrierInvalidOptionsError('maxBackoffMs must be >= 0');
+    }
+};
+exports.validateRequestOptions = validateRequestOptions;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/retry-predicates.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Retry-loop predicates with no fetch, timer, or environment dependencies.
+ */
+/**
+ * Whether the current 1-based attempt is the last allowed attempt.
+ *
+ * @param attempt - 1-based attempt index
+ * @param retries - Maximum number of attempts, including the first
+ * @returns `true` when no further attempt should be scheduled
+ */
+export declare const isLastAttempt: (attempt: number, retries: number) => boolean;

package/lib/core/retry-predicates.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Retry-loop predicates with no fetch, timer, or environment dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLastAttempt = void 0;
+/**
+ * Whether the current 1-based attempt is the last allowed attempt.
+ *
+ * @param attempt - 1-based attempt index
+ * @param retries - Maximum number of attempts, including the first
+ * @returns `true` when no further attempt should be scheduled
+ */
+const isLastAttempt = (attempt, retries) => {
+    return attempt === retries;
+};
+exports.isLastAttempt = isLastAttempt;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV0cnktcHJlZGljYXRlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb3JlL3JldHJ5LXByZWRpY2F0ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7QUFFSDs7Ozs7O0dBTUc7QUFDSSxNQUFNLGFBQWEsR0FBRyxDQUFDLE9BQWUsRUFBRSxPQUFlLEVBQVcsRUFBRTtJQUN6RSxPQUFPLE9BQU8sS0FBSyxPQUFPLENBQUM7QUFDN0IsQ0FBQyxDQUFDO0FBRlcsUUFBQSxhQUFhLGlCQUV4QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUmV0cnktbG9vcCBwcmVkaWNhdGVzIHdpdGggbm8gZmV0Y2gsIHRpbWVyLCBvciBlbnZpcm9ubWVudCBkZXBlbmRlbmNpZXMuXG4gKi9cblxuLyoqXG4gKiBXaGV0aGVyIHRoZSBjdXJyZW50IDEtYmFzZWQgYXR0ZW1wdCBpcyB0aGUgbGFzdCBhbGxvd2VkIGF0dGVtcHQuXG4gKlxuICogQHBhcmFtIGF0dGVtcHQgLSAxLWJhc2VkIGF0dGVtcHQgaW5kZXhcbiAqIEBwYXJhbSByZXRyaWVzIC0gTWF4aW11bSBudW1iZXIgb2YgYXR0ZW1wdHMsIGluY2x1ZGluZyB0aGUgZmlyc3RcbiAqIEByZXR1cm5zIGB0cnVlYCB3aGVuIG5vIGZ1cnRoZXIgYXR0ZW1wdCBzaG91bGQgYmUgc2NoZWR1bGVkXG4gKi9cbmV4cG9ydCBjb25zdCBpc0xhc3RBdHRlbXB0ID0gKGF0dGVtcHQ6IG51bWJlciwgcmV0cmllczogbnVtYmVyKTogYm9vbGVhbiA9PiB7XG4gIHJldHVybiBhdHRlbXB0ID09PSByZXRyaWVzO1xufTtcbiJdfQ==

package/lib/core/time/wait.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Delays execution for the given duration (used between retry attempts).
+ *
+ * @param ms - Delay in milliseconds
+ * @returns A promise that resolves after `ms`
+ */
+export declare const wait: (ms: number) => Promise<void>;

package/lib/core/time/wait.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wait = void 0;
+/**
+ * Delays execution for the given duration (used between retry attempts).
+ *
+ * @param ms - Delay in milliseconds
+ * @returns A promise that resolves after `ms`
+ */
+const wait = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};
+exports.wait = wait;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FpdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb3JlL3RpbWUvd2FpdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQTs7Ozs7R0FLRztBQUNJLE1BQU0sSUFBSSxHQUFHLENBQUMsRUFBVSxFQUFpQixFQUFFO0lBQ2hELE9BQU8sSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQztBQUMzRCxDQUFDLENBQUM7QUFGVyxRQUFBLElBQUksUUFFZiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRGVsYXlzIGV4ZWN1dGlvbiBmb3IgdGhlIGdpdmVuIGR1cmF0aW9uICh1c2VkIGJldHdlZW4gcmV0cnkgYXR0ZW1wdHMpLlxuICpcbiAqIEBwYXJhbSBtcyAtIERlbGF5IGluIG1pbGxpc2Vjb25kc1xuICogQHJldHVybnMgQSBwcm9taXNlIHRoYXQgcmVzb2x2ZXMgYWZ0ZXIgYG1zYFxuICovXG5leHBvcnQgY29uc3Qgd2FpdCA9IChtczogbnVtYmVyKTogUHJvbWlzZTx2b2lkPiA9PiB7XG4gIHJldHVybiBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4gc2V0VGltZW91dChyZXNvbHZlLCBtcykpO1xufTtcbiJdfQ==

package/lib/index.d.ts

@@ -4,195 +4,8 @@
  *
  * @module fetch-retrier
  */
-/**
- * `fetch` options forwarded to every attempt, excluding `signal`.
- *
- * Use for `method`, `body`, `credentials`, `redirect`, `mode`, `cache`, and other
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/RequestInit | RequestInit} fields.
- * Per-attempt abort and timeout are handled internally via `signal` and must not be set here.
- */
-export type FetchInitOptions = Omit<RequestInit, 'signal'>;
-/**
- * Options for {@link fetchRetrier}: retry policy, timeout, backoff (including `Retry-After`),
- * request payload, and cancellation.
- *
- * Request shape is built as `{ ...init, headers?, signal }` on each attempt. Top-level `headers`
- * override `init.headers` when both are provided.
- *
- * Numeric fields are validated when {@link fetchRetrier} is called; invalid values throw
- * {@link FetchRetrierInvalidOptionsError}.
- */
-export interface RequestOptions {
-    /**
-     * HTTP headers sent on every attempt.
-     * When `init.headers` is also set, these values take precedence for duplicate keys.
-     */
-    headers?: Record<string, string>;
-    /**
-     * Additional {@link FetchInitOptions} merged into each `fetch` call (e.g. POST `method` and JSON `body`).
-     * The same `init` is reused across retries.
-     */
-    init?: FetchInitOptions;
-    /**
-     * Maximum number of attempts, including the first.
-     * Must be `>= 1`.
-     */
-    retries: number;
-    /**
-     * Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded.
-     * Must be `> 0`.
-     */
-    timeoutMs: number;
-    /**
-     * Base backoff in milliseconds for full jitter when `Retry-After` is absent or invalid.
-     * The cap for attempt `n` is `baseBackoffMs * 2^n`.
-     * Must be `>= 0` (`0` skips backoff delay between attempts when falling back to jitter).
-     */
-    baseBackoffMs: number;
-    /**
-     * Optional external {@link AbortSignal}. When aborted, the in-flight request is aborted; on the
-     * final attempt, cancellation surfaces as {@link FetchRetrierAbortError}.
-     */
-    signal?: AbortSignal;
-    /**
-     * Invoked after `response.text()` when `response.ok` is false.
-     * Return `true` to schedule another attempt (until `retries` is exhausted).
-     * 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;
-}
-/**
- * Error thrown when a request is cancelled by timeout or an external {@link AbortSignal}.
- */
-export declare class FetchRetrierAbortError extends Error {
-    readonly name: string;
-    /**
-     * @param message - Human-readable reason (default: `'Aborted'`)
-     */
-    constructor(message?: string);
-}
-/**
- * Error thrown when {@link RequestOptions.signal} is already aborted before an attempt starts.
- */
-export declare class FetchRetrierAlreadyAbortedError extends FetchRetrierAbortError {
-    readonly name: string;
-    /**
-     * @param message - Human-readable reason (default: `'Signal was already aborted'`)
-     */
-    constructor(message?: string);
-}
-/**
- * Error thrown when the server returns a non-OK HTTP status and no further retry is performed.
- *
- * Carries the last response `status` and the body text already consumed via `response.text()`
- * (the same text passed to {@link RequestOptions.shouldRetry}).
- *
- * @property status - HTTP status code from the last non-OK response
- * @property body - Response body text already read via `response.text()` for that attempt
- */
-export declare class FetchRetrierHttpError extends Error {
-    readonly status: number;
-    readonly body: string;
-    readonly name: string;
-    /**
-     * @param message - Error description
-     * @param status - HTTP status code from the last non-OK response
-     * @param body - Response body text already read via `response.text()` for that attempt
-     */
-    constructor(message: string, status: number, body: string);
-}
-/**
- * Error thrown when a fetch fails with a network-level error (e.g. DNS failure, connection refused).
- *
- * @property cause - Original error from the underlying `fetch`, when available
- */
-export declare class FetchRetrierNetworkError extends Error {
-    readonly cause?: unknown | undefined;
-    readonly name: string;
-    /**
-     * @param message - Human-readable reason (default: `'Network error'`)
-     * @param cause - Original error from the underlying `fetch`, when available
-     */
-    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).
- */
-export declare class FetchRetrierUnreachableError extends Error {
-    readonly name: string;
-    /**
-     * @param message - Human-readable reason (default: `'Unreachable'`)
-     */
-    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, Retry-After support, full-jitter backoff, and
- * optional cancellation.
- *
- * Each attempt calls `fetch(url, { ...options.init, headers?, signal })` with an internal
- * {@link AbortSignal} for `timeoutMs`. Non-OK responses are retried when `shouldRetry` returns
- * `true` (default: {@link defaultShouldRetry}). Between HTTP retries, a valid `Retry-After`
- * header (delta-seconds or HTTP-date) is preferred over full jitter; abort and network retries
- * always use full jitter. The same {@link FetchInitOptions} (including `body`) is reused on
- * every attempt.
- *
- * @param url - Request URL passed to `fetch`
- * @param options - {@link RequestOptions} controlling retries, timeout, request init, and cancellation
- * @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
- *   (includes `status` and `body`)
- * @throws {FetchRetrierNetworkError} On a network `TypeError` after the last attempt
- * @throws {FetchRetrierAbortError} On timeout or external abort after the last attempt
- * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)
- */
-export declare const fetchRetrier: (url: string, options: RequestOptions) => Promise<Response>;
-/**
- * Parses a `Retry-After` header value into a delay in milliseconds.
- *
- * Supports RFC 7231 forms: non-negative integer delta-seconds, or an HTTP-date. Empty values,
- * non-integer numerics (e.g. floats or negatives), and unparsable dates yield `undefined` so
- * callers can fall back to full jitter. An HTTP-date in the past yields `0`.
- *
- * @param value - Raw `Retry-After` header value
- * @param nowMs - Current time in milliseconds (injectable for tests)
- * @returns Delay in milliseconds, or `undefined` when the value cannot be parsed
- */
-export declare const parseRetryAfterMs: (value: string, nowMs?: number) => number | undefined;
+export { FetchRetrierAbortError, FetchRetrierAlreadyAbortedError, FetchRetrierError, FetchRetrierHttpError, FetchRetrierInvalidOptionsError, FetchRetrierNetworkError, FetchRetrierUnreachableError, } from './core/errors';
+export type { FetchInitOptions, RequestOptions } from './core/options';
+export { parseRetryAfterMs } from './core/backoff/retry-after';
+export { fetchRetrier } from './core/fetch-retrier';
+export { DEFAULT_RETRYABLE_HTTP_STATUSES, defaultShouldRetry, } from './core/policy/default-should-retry';