@zap-studio/retry 0.3.1 → 1.0.0

package/dist/base-policy.js

@@ -0,0 +1,306 @@
+import { AbortError, RetryError } from "./errors.js";
+//#region src/base-policy.ts
+/**
+* Retry runner base class and shared orchestration implementation.
+*
+* @module @zap-studio/retry/base-policy
+*/
+/**
+* Awaits a timer-based delay, unless `delayMs` is non-positive.
+*
+* @param delayMs - Milliseconds to wait before resolving.
+* @returns Promise that resolves when the delay completes.
+*
+* @example
+* ```ts
+* import { defaultSleep } from "@zap-studio/retry";
+*
+* await defaultSleep(250); // waits 250ms
+* ```
+*/
+const defaultSleep = async (delayMs) => {
+	if (delayMs <= 0) return;
+	await new Promise((resolve) => {
+		setTimeout(resolve, delayMs);
+	});
+};
+/**
+* Normalizes an abort `reason` into an `AbortError`.
+*/
+const toAbortError = (reason) => {
+	if (reason instanceof AbortError) return reason;
+	if (reason instanceof Error) return new AbortError(reason.message, { cause: reason });
+	if (typeof reason === "string" && reason.length > 0) return new AbortError(reason);
+	if (reason === void 0) return new AbortError("Retry aborted.");
+	try {
+		return new AbortError(`Retry aborted: ${JSON.stringify(reason)}`);
+	} catch {
+		return new AbortError("Retry aborted.");
+	}
+};
+/**
+* Throws when the provided abort signal is already aborted.
+*
+* @param signal - Optional abort signal to inspect.
+* @throws {AbortError} When the signal is aborted.
+*/
+const throwIfAborted = (signal) => {
+	if (signal?.aborted !== true) return;
+	throw toAbortError(signal.reason);
+};
+/**
+* Waits for delay sleep while observing cancellation through an abort signal.
+*
+* @param sleep - Sleep function used to await `delayMs`.
+* @param delayMs - Delay duration in milliseconds.
+* @param signal - Abort signal to observe while waiting.
+* @returns Promise that resolves when delay finishes.
+* @throws {AbortError} When the signal aborts before or during wait.
+*/
+const sleepWithAbortSignal = async (sleep, delayMs, signal) => {
+	if (signal.aborted) throw toAbortError(signal.reason);
+	let onAbort;
+	try {
+		await Promise.race([sleep(delayMs), new Promise((_resolve, reject) => {
+			onAbort = () => {
+				reject(toAbortError(signal.reason));
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+		})]);
+	} finally {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	}
+};
+/**
+* Runs the throw-mode retry loop: throws `RetryError` on exhaustion and
+* `AbortError` when `signal` aborts.
+*
+* @param policy - Resolved retry policy providing `next` and `onExhausted`.
+* @param execute - Async work callback per attempt.
+* @param sleep - Delay function between retries.
+* @param signal - Optional cancel signal.
+* @returns Resolves to the first successful return value.
+* @throws {RetryError} When retries are exhausted and `onExhausted` returns
+*   the terminal error.
+* @throws {AbortError} When `signal` is already aborted or aborts while waiting.
+* @throws {Error} Any error thrown by `next`, `onExhausted`, or `sleep`. Also
+*   rethrows the original caught value immediately, bypassing retry, when
+*   `policy.isKnownError` rejects it as outside this policy's error domain.
+*/
+const runThrowMode = async (policy, execute, sleep, signal) => {
+	let attempt = 1;
+	while (true) {
+		throwIfAborted(signal);
+		try {
+			return await execute(attempt);
+		} catch (error) {
+			throwIfAborted(signal);
+			if (!policy.isKnownError(error)) throw error;
+			const decision = policy.next({
+				attempt,
+				error
+			});
+			if (!decision.shouldRetry) throw policy.onExhausted({
+				attempts: attempt,
+				error
+			});
+			if (decision.delayMs > 0) await (signal === void 0 ? sleep(decision.delayMs) : sleepWithAbortSignal(sleep, decision.delayMs, signal));
+			attempt += 1;
+		}
+	}
+};
+/**
+* When `signal` is already aborted, builds the terminal `{ ok: false }` object
+* with a normalized `AbortError` on `error`.
+*
+* @param signal - Optional abort signal; only acts when `aborted` is set.
+* @param attempts - Number of finished attempts to report in the result.
+* @returns Failure result or `undefined` if not aborted.
+*/
+const buildAbortResult = (signal, attempts) => {
+	if (signal?.aborted !== true) return;
+	return {
+		attempts,
+		error: toAbortError(signal.reason),
+		ok: false
+	};
+};
+/**
+* Runs one `execute(attempt)` call and returns either a success value or a
+* captured error without rethrowing.
+*
+* @param execute - User work callback.
+* @param attempt - One-based attempt number passed to `execute`.
+* @returns A tagged success with `value` or a tagged failure with `error`.
+*/
+const runAttempt = async (execute, attempt) => {
+	try {
+		return {
+			ok: true,
+			value: await execute(attempt)
+		};
+	} catch (error) {
+		return {
+			error,
+			ok: false
+		};
+	}
+};
+/**
+* Awaits inter-attempt delay in result mode, mapping an abort during wait to
+* a terminal result instead of throwing when `throwOnExhausted` is false.
+*
+* @param sleep - Custom or default sleep implementation.
+* @param delayMs - Milliseconds to wait.
+* @param signal - If set, `sleep` is raced with the abort signal.
+* @param attempts - Attempt count to attach if the wait ends in abort.
+* @returns A terminal result when canceled during the wait, otherwise
+*   `undefined`.
+* @throws {Error} The underlying `sleep` rejection when it is not an abort.
+*/
+const waitForDelay = async (sleep, delayMs, signal, attempts) => {
+	if (signal === void 0) {
+		await sleep(delayMs);
+		return;
+	}
+	try {
+		await sleepWithAbortSignal(sleep, delayMs, signal);
+		return;
+	} catch (error) {
+		const aborted = buildAbortResult(signal, attempts);
+		if (aborted !== void 0) return aborted;
+		throw error;
+	}
+};
+/**
+* After a failed attempt, applies abort rules, `next`, optional delay, and
+* either returns a terminal `RetryRunResult` or `undefined` to continue.
+*
+* @param policy - Resolved retry policy hooks (`next`, `onExhausted`).
+* @param params - Failure context for the current attempt.
+* @param params.attempt - Current attempt number.
+* @param params.error - Error thrown by the attempt.
+* @param params.sleep - Delay function between retries.
+* @param params.signal - Optional abort signal.
+* @returns Terminal non-throw result if the loop should stop, otherwise
+*   `undefined` to schedule another attempt.
+* @throws {Error} Any error thrown by `next`, `onExhausted`, or a custom `sleep` when
+*   the error is not an abort.
+*/
+const handleFailure = async (policy, params) => {
+	const { attempt, error, sleep, signal } = params;
+	const abortResult = buildAbortResult(signal, attempt);
+	if (abortResult !== void 0) return abortResult;
+	const decision = policy.next({
+		attempt,
+		error
+	});
+	if (!decision.shouldRetry) return {
+		attempts: attempt,
+		error: policy.onExhausted({
+			attempts: attempt,
+			error
+		}),
+		ok: false
+	};
+	if (decision.delayMs > 0) {
+		const delayAbortResult = await waitForDelay(sleep, decision.delayMs, signal, attempt);
+		if (delayAbortResult !== void 0) return delayAbortResult;
+	}
+};
+/**
+* Runs the non-throw retry loop, returning
+* `RetryRunResult`.
+*
+* @param policy - Resolved retry policy providing `next` and `onExhausted`.
+* @param execute - Async work callback per attempt.
+* @param sleep - Delay function between retries.
+* @param signal - Optional cancel signal.
+* @returns Terminal success or failure object. When `policy.isKnownError`
+*   rejects a caught value as outside this policy's error domain, the
+*   original value is wrapped in a `RetryError` and returned on
+*   `result.error` immediately, bypassing retry — never thrown.
+* @throws {Error} Any error thrown by `next`, `onExhausted`, or a non-abort `sleep`
+*   failure.
+*/
+const runResultMode = async (policy, execute, sleep, signal) => {
+	let attempt = 1;
+	while (true) {
+		const abortResult = buildAbortResult(signal, Math.max(0, attempt - 1));
+		if (abortResult !== void 0) return abortResult;
+		const execution = await runAttempt(execute, attempt);
+		if (execution.ok) return {
+			ok: true,
+			value: execution.value
+		};
+		const attemptAbortResult = buildAbortResult(signal, attempt);
+		if (attemptAbortResult !== void 0) return attemptAbortResult;
+		if (!policy.isKnownError(execution.error)) return {
+			attempts: attempt,
+			error: new RetryError("Retry policy encountered an unknown error.", {
+				attempts: attempt,
+				lastError: execution.error
+			}),
+			ok: false
+		};
+		const failure = await handleFailure(policy, {
+			attempt,
+			error: execution.error,
+			signal,
+			sleep
+		});
+		if (failure !== void 0) return failure;
+		attempt += 1;
+	}
+};
+/**
+* Default `onExhausted` used when a policy omits it: wraps the exhaustion
+* context in a generic `RetryError`.
+*/
+const defaultOnExhausted = (input) => new RetryError("Retry policy exhausted all attempts.", {
+	attempts: input.attempts,
+	lastData: input.data,
+	lastError: input.error
+});
+/**
+* Default `isKnownError` used when a policy omits it: accepts any `Error`
+* instance and rejects everything else.
+*/
+const defaultIsKnownError = (error) => error instanceof Error;
+/**
+* Runs retry orchestration in non-throw mode.
+*
+* When `throwOnExhausted` is `false`, returns a discriminated result union.
+*
+* @param policy - Retry policy: `next` is required, `onExhausted` and
+*   `isKnownError` fall back to their defaults when omitted.
+* @param execute - Async function to execute per attempt.
+* @param options - Runner settings.
+* @returns Success value or terminal result object based on option mode.
+* @throws {Error} Any error thrown by `next`, by `onExhausted`, or by a custom `sleep`
+*   function. When `throwOnExhausted` is `false`, exhaustion itself is returned
+*   as `{ ok: false }` instead of thrown.
+*   Cancellation is returned as `{ ok: false, error: AbortError }` in non-throw
+*   mode. A value rejected by `policy.isKnownError` is wrapped in a
+*   `RetryError` and returned the same way in non-throw mode; in throw mode
+*   it is rethrown as-is.
+*
+* @example
+* const result = await runRetryPolicy(policy, doWork, { throwOnExhausted: false });
+* if (!result.ok) console.error(result.error);
+*/
+async function runRetryPolicy(policy, execute, options = {}) {
+	const sleep = options.sleep ?? defaultSleep;
+	const { signal } = options;
+	const resolvedPolicy = {
+		isKnownError: (error) => policy.isKnownError ? policy.isKnownError(error) : defaultIsKnownError(error),
+		next: (input) => policy.next(input),
+		onExhausted: (input) => policy.onExhausted ? policy.onExhausted(input) : defaultOnExhausted(input)
+	};
+	if (options.throwOnExhausted === false) return await runResultMode(resolvedPolicy, execute, sleep, signal);
+	return await runThrowMode(resolvedPolicy, execute, sleep, signal);
+}
+//#endregion
+export { defaultSleep, runRetryPolicy };
+
+//# sourceMappingURL=base-policy.js.map

package/dist/base-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-policy.js","names":[],"sources":["../src/base-policy.ts"],"sourcesContent":["/**\n * Retry runner base class and shared orchestration implementation.\n *\n * @module @zap-studio/retry/base-policy\n */\n\nimport { AbortError, RetryError } from \"./errors.js\";\nimport type {\n  ResolvedRetryPolicy,\n  RetryExhaustedInput,\n  RetryPolicy,\n  RetryRunOptions,\n  RetryRunResult,\n} from \"./types.js\";\n\n/**\n * Awaits a timer-based delay, unless `delayMs` is non-positive.\n *\n * @param delayMs - Milliseconds to wait before resolving.\n * @returns Promise that resolves when the delay completes.\n *\n * @example\n * ```ts\n * import { defaultSleep } from \"@zap-studio/retry\";\n *\n * await defaultSleep(250); // waits 250ms\n * ```\n */\nexport const defaultSleep = async (delayMs: number): Promise<void> => {\n  if (delayMs <= 0) {\n    return;\n  }\n\n  // oxlint-disable-next-line promise/avoid-new -- Timer sleep requires adapting callback API to a promise.\n  await new Promise<void>((resolve) => {\n    setTimeout(resolve, delayMs);\n  });\n};\n\n/**\n * Normalizes an abort `reason` into an `AbortError`.\n */\nconst toAbortError = (reason: unknown): AbortError => {\n  if (reason instanceof AbortError) {\n    return reason;\n  }\n\n  if (reason instanceof Error) {\n    return new AbortError(reason.message, { cause: reason });\n  }\n\n  if (typeof reason === \"string\" && reason.length > 0) {\n    return new AbortError(reason);\n  }\n\n  if (reason === undefined) {\n    return new AbortError(\"Retry aborted.\");\n  }\n\n  try {\n    return new AbortError(`Retry aborted: ${JSON.stringify(reason)}`);\n  } catch {\n    return new AbortError(\"Retry aborted.\");\n  }\n};\n\n/**\n * Throws when the provided abort signal is already aborted.\n *\n * @param signal - Optional abort signal to inspect.\n * @throws {AbortError} When the signal is aborted.\n */\nconst throwIfAborted = (signal?: AbortSignal): void => {\n  if (signal?.aborted !== true) {\n    return;\n  }\n\n  throw toAbortError(signal.reason);\n};\n\n/**\n * Waits for delay sleep while observing cancellation through an abort signal.\n *\n * @param sleep - Sleep function used to await `delayMs`.\n * @param delayMs - Delay duration in milliseconds.\n * @param signal - Abort signal to observe while waiting.\n * @returns Promise that resolves when delay finishes.\n * @throws {AbortError} When the signal aborts before or during wait.\n */\nconst sleepWithAbortSignal = async (\n  sleep: (delayMs: number) => Promise<void>,\n  delayMs: number,\n  signal: AbortSignal\n): Promise<void> => {\n  if (signal.aborted) {\n    throw toAbortError(signal.reason);\n  }\n\n  let onAbort: (() => void) | undefined;\n\n  try {\n    await Promise.race([\n      sleep(delayMs),\n      // oxlint-disable-next-line promise/avoid-new -- AbortSignal callback is adapted into the race promise.\n      new Promise<never>((_resolve, reject) => {\n        onAbort = (): void => {\n          reject(toAbortError(signal.reason));\n        };\n\n        signal.addEventListener(\"abort\", onAbort, { once: true });\n      }),\n    ]);\n  } finally {\n    if (onAbort) {\n      signal.removeEventListener(\"abort\", onAbort);\n    }\n  }\n};\n\n/**\n * Runs the throw-mode retry loop: throws `RetryError` on exhaustion and\n * `AbortError` when `signal` aborts.\n *\n * @param policy - Resolved retry policy providing `next` and `onExhausted`.\n * @param execute - Async work callback per attempt.\n * @param sleep - Delay function between retries.\n * @param signal - Optional cancel signal.\n * @returns Resolves to the first successful return value.\n * @throws {RetryError} When retries are exhausted and `onExhausted` returns\n *   the terminal error.\n * @throws {AbortError} When `signal` is already aborted or aborts while waiting.\n * @throws {Error} Any error thrown by `next`, `onExhausted`, or `sleep`. Also\n *   rethrows the original caught value immediately, bypassing retry, when\n *   `policy.isKnownError` rejects it as outside this policy's error domain.\n */\nconst runThrowMode = async <T, TError extends Error, TData>(\n  policy: ResolvedRetryPolicy<TError, TData>,\n  execute: (attempt: number) => Promise<T>,\n  sleep: (delayMs: number) => Promise<void>,\n  signal?: AbortSignal\n): Promise<T> => {\n  let attempt = 1;\n\n  while (true) {\n    throwIfAborted(signal);\n\n    try {\n      // oxlint-disable-next-line no-await-in-loop -- Retry attempts must run sequentially.\n      return await execute(attempt);\n    } catch (error) {\n      throwIfAborted(signal);\n\n      if (!policy.isKnownError(error)) {\n        throw error;\n      }\n\n      const decision = policy.next({\n        attempt,\n        error,\n      });\n\n      if (!decision.shouldRetry) {\n        throw policy.onExhausted({\n          attempts: attempt,\n          error,\n        });\n      }\n\n      if (decision.delayMs > 0) {\n        // oxlint-disable-next-line no-await-in-loop -- Delay belongs between sequential retry attempts.\n        await (signal === undefined\n          ? sleep(decision.delayMs)\n          : sleepWithAbortSignal(sleep, decision.delayMs, signal));\n      }\n\n      attempt += 1;\n    }\n  }\n};\n\n/**\n * When `signal` is already aborted, builds the terminal `{ ok: false }` object\n * with a normalized `AbortError` on `error`.\n *\n * @param signal - Optional abort signal; only acts when `aborted` is set.\n * @param attempts - Number of finished attempts to report in the result.\n * @returns Failure result or `undefined` if not aborted.\n */\nconst buildAbortResult = (\n  signal: AbortSignal | undefined,\n  attempts: number\n): RetryRunResult<never> | undefined => {\n  if (signal?.aborted !== true) {\n    return undefined;\n  }\n\n  return {\n    attempts,\n    error: toAbortError(signal.reason),\n    ok: false,\n  };\n};\n\n/**\n * Runs one `execute(attempt)` call and returns either a success value or a\n * captured error without rethrowing.\n *\n * @param execute - User work callback.\n * @param attempt - One-based attempt number passed to `execute`.\n * @returns A tagged success with `value` or a tagged failure with `error`.\n */\nconst runAttempt = async <T>(\n  execute: (attempt: number) => Promise<T>,\n  attempt: number\n): Promise<{ ok: true; value: T } | { ok: false; error: unknown }> => {\n  try {\n    return {\n      ok: true,\n      value: await execute(attempt),\n    };\n  } catch (error) {\n    return {\n      error,\n      ok: false,\n    };\n  }\n};\n\n/**\n * Awaits inter-attempt delay in result mode, mapping an abort during wait to\n * a terminal result instead of throwing when `throwOnExhausted` is false.\n *\n * @param sleep - Custom or default sleep implementation.\n * @param delayMs - Milliseconds to wait.\n * @param signal - If set, `sleep` is raced with the abort signal.\n * @param attempts - Attempt count to attach if the wait ends in abort.\n * @returns A terminal result when canceled during the wait, otherwise\n *   `undefined`.\n * @throws {Error} The underlying `sleep` rejection when it is not an abort.\n */\nconst waitForDelay = async (\n  sleep: (delayMs: number) => Promise<void>,\n  delayMs: number,\n  signal: AbortSignal | undefined,\n  attempts: number\n): Promise<RetryRunResult<never> | undefined> => {\n  if (signal === undefined) {\n    await sleep(delayMs);\n    return undefined;\n  }\n\n  try {\n    await sleepWithAbortSignal(sleep, delayMs, signal);\n    return undefined;\n  } catch (error) {\n    const aborted = buildAbortResult(signal, attempts);\n    if (aborted !== undefined) {\n      return aborted;\n    }\n    throw error;\n  }\n};\n\n/**\n * After a failed attempt, applies abort rules, `next`, optional delay, and\n * either returns a terminal `RetryRunResult` or `undefined` to continue.\n *\n * @param policy - Resolved retry policy hooks (`next`, `onExhausted`).\n * @param params - Failure context for the current attempt.\n * @param params.attempt - Current attempt number.\n * @param params.error - Error thrown by the attempt.\n * @param params.sleep - Delay function between retries.\n * @param params.signal - Optional abort signal.\n * @returns Terminal non-throw result if the loop should stop, otherwise\n *   `undefined` to schedule another attempt.\n * @throws {Error} Any error thrown by `next`, `onExhausted`, or a custom `sleep` when\n *   the error is not an abort.\n */\nconst handleFailure = async <TError extends Error, TData>(\n  policy: ResolvedRetryPolicy<TError, TData>,\n  params: {\n    attempt: number;\n    error: TError;\n    sleep: (delayMs: number) => Promise<void>;\n    signal: AbortSignal | undefined;\n  }\n): Promise<RetryRunResult<never> | undefined> => {\n  const { attempt, error, sleep, signal } = params;\n  const abortResult = buildAbortResult(signal, attempt);\n  if (abortResult !== undefined) {\n    return abortResult;\n  }\n\n  const decision = policy.next({\n    attempt,\n    error,\n  });\n\n  if (!decision.shouldRetry) {\n    const terminalError = policy.onExhausted({\n      attempts: attempt,\n      error,\n    });\n\n    return {\n      attempts: attempt,\n      error: terminalError,\n      ok: false,\n    };\n  }\n\n  if (decision.delayMs > 0) {\n    const delayAbortResult = await waitForDelay(\n      sleep,\n      decision.delayMs,\n      signal,\n      attempt\n    );\n    if (delayAbortResult !== undefined) {\n      return delayAbortResult;\n    }\n  }\n\n  return undefined;\n};\n\n/**\n * Runs the non-throw retry loop, returning\n * `RetryRunResult`.\n *\n * @param policy - Resolved retry policy providing `next` and `onExhausted`.\n * @param execute - Async work callback per attempt.\n * @param sleep - Delay function between retries.\n * @param signal - Optional cancel signal.\n * @returns Terminal success or failure object. When `policy.isKnownError`\n *   rejects a caught value as outside this policy's error domain, the\n *   original value is wrapped in a `RetryError` and returned on\n *   `result.error` immediately, bypassing retry — never thrown.\n * @throws {Error} Any error thrown by `next`, `onExhausted`, or a non-abort `sleep`\n *   failure.\n */\nconst runResultMode = async <T, TError extends Error, TData>(\n  policy: ResolvedRetryPolicy<TError, TData>,\n  execute: (attempt: number) => Promise<T>,\n  sleep: (delayMs: number) => Promise<void>,\n  signal?: AbortSignal\n): Promise<RetryRunResult<T>> => {\n  let attempt = 1;\n\n  while (true) {\n    const abortResult = buildAbortResult(signal, Math.max(0, attempt - 1));\n    if (abortResult !== undefined) {\n      return abortResult;\n    }\n\n    // oxlint-disable-next-line no-await-in-loop -- Retry attempts must run sequentially.\n    const execution = await runAttempt(execute, attempt);\n    if (execution.ok) {\n      return { ok: true, value: execution.value };\n    }\n\n    const attemptAbortResult = buildAbortResult(signal, attempt);\n    if (attemptAbortResult !== undefined) {\n      return attemptAbortResult;\n    }\n\n    if (!policy.isKnownError(execution.error)) {\n      return {\n        attempts: attempt,\n        error: new RetryError(\"Retry policy encountered an unknown error.\", {\n          attempts: attempt,\n          lastError: execution.error,\n        }),\n        ok: false,\n      };\n    }\n\n    // oxlint-disable-next-line no-await-in-loop -- Failure handling belongs to the current sequential attempt.\n    const failure = await handleFailure(policy, {\n      attempt,\n      error: execution.error,\n      signal,\n      sleep,\n    });\n    if (failure !== undefined) {\n      return failure;\n    }\n\n    attempt += 1;\n  }\n};\n\n/**\n * Default `onExhausted` used when a policy omits it: wraps the exhaustion\n * context in a generic `RetryError`.\n */\nconst defaultOnExhausted = <TError extends Error, TData>(\n  input: RetryExhaustedInput<TError, TData>\n): RetryError =>\n  new RetryError(\"Retry policy exhausted all attempts.\", {\n    attempts: input.attempts,\n    lastData: input.data,\n    lastError: input.error,\n  });\n\n/**\n * Default `isKnownError` used when a policy omits it: accepts any `Error`\n * instance and rejects everything else.\n */\n// oxlint-disable-next-line typescript/no-unnecessary-type-parameters -- TError only appears in the return predicate; needed so callers infer the right narrowed type.\nconst defaultIsKnownError = <TError extends Error>(\n  error: unknown\n): error is TError => error instanceof Error;\n\n/**\n * Runs retry orchestration in non-throw mode.\n *\n * @param policy - Retry policy: `next` is required, `onExhausted` and\n *   `isKnownError` fall back to their defaults when omitted.\n * @param execute - Async function to execute per attempt.\n * @param options - Runner settings with `throwOnExhausted: false`.\n * @returns A discriminated result union containing success value or terminal error.\n *   When `policy.isKnownError` rejects a caught value, it is wrapped in a\n *   `RetryError` and returned as the terminal failure instead of thrown.\n * @throws {Error} Any error thrown by `next`, `onExhausted`, or a custom `sleep`.\n */\nexport function runRetryPolicy<\n  T,\n  TError extends Error = Error,\n  TData = unknown,\n>(\n  policy: RetryPolicy<TError, TData>,\n  execute: (attempt: number) => Promise<T>,\n  options: RetryRunOptions & { throwOnExhausted: false }\n): Promise<RetryRunResult<T>>;\n\n/**\n * Runs retry orchestration and throws terminal error on exhaustion.\n *\n * @param policy - Retry policy: `next` is required, `onExhausted` and\n *   `isKnownError` fall back to their defaults when omitted.\n * @param execute - Async function to execute per attempt.\n * @param options - Optional runner settings.\n * @returns The successful execution value.\n * @throws {RetryError} When retries are exhausted and `onExhausted` returns the\n *   terminal retry error. The default implementation returns `RetryError` with the last\n *   execution failure available on `RetryError.lastError`.\n * @throws {AbortError} When `options.signal` is already aborted or aborts while retrying.\n * @throws {Error} Any error thrown by `next`, by `onExhausted`, or by a custom `sleep`\n *   function.\n *\n * @example\n * ```ts\n * import { runRetryPolicy } from \"@zap-studio/retry\";\n * import type { RetryPolicy } from \"@zap-studio/retry\";\n *\n * const linearBackoff: RetryPolicy = {\n *   next: ({ attempt }) =>\n *     attempt < 3\n *       ? { shouldRetry: true, delayMs: attempt * 100, reason: \"retry\" }\n *       : { shouldRetry: false, delayMs: 0, reason: \"max-attempts-reached\" },\n * };\n *\n * const data = await runRetryPolicy(linearBackoff, async () => fetchFlakyResource());\n * ```\n */\nexport function runRetryPolicy<\n  T,\n  TError extends Error = Error,\n  TData = unknown,\n>(\n  policy: RetryPolicy<TError, TData>,\n  execute: (attempt: number) => Promise<T>,\n  options?: RetryRunOptions & { throwOnExhausted?: true }\n): Promise<T>;\n\n/**\n * Runs retry orchestration in non-throw mode.\n *\n * When `throwOnExhausted` is `false`, returns a discriminated result union.\n *\n * @param policy - Retry policy: `next` is required, `onExhausted` and\n *   `isKnownError` fall back to their defaults when omitted.\n * @param execute - Async function to execute per attempt.\n * @param options - Runner settings.\n * @returns Success value or terminal result object based on option mode.\n * @throws {Error} Any error thrown by `next`, by `onExhausted`, or by a custom `sleep`\n *   function. When `throwOnExhausted` is `false`, exhaustion itself is returned\n *   as `{ ok: false }` instead of thrown.\n *   Cancellation is returned as `{ ok: false, error: AbortError }` in non-throw\n *   mode. A value rejected by `policy.isKnownError` is wrapped in a\n *   `RetryError` and returned the same way in non-throw mode; in throw mode\n *   it is rethrown as-is.\n *\n * @example\n * const result = await runRetryPolicy(policy, doWork, { throwOnExhausted: false });\n * if (!result.ok) console.error(result.error);\n */\nexport async function runRetryPolicy<\n  T,\n  TError extends Error = Error,\n  TData = unknown,\n>(\n  policy: RetryPolicy<TError, TData>,\n  execute: (attempt: number) => Promise<T>,\n  options: RetryRunOptions = {}\n): Promise<T | RetryRunResult<T>> {\n  const sleep = options.sleep ?? defaultSleep;\n  const { signal } = options;\n  const resolvedPolicy: ResolvedRetryPolicy<TError, TData> = {\n    isKnownError: (error): error is TError =>\n      policy.isKnownError\n        ? policy.isKnownError(error)\n        : defaultIsKnownError(error),\n    next: (input) => policy.next(input),\n    onExhausted: (input) =>\n      policy.onExhausted\n        ? policy.onExhausted(input)\n        : defaultOnExhausted(input),\n  };\n\n  if (options.throwOnExhausted === false) {\n    return await runResultMode(resolvedPolicy, execute, sleep, signal);\n  }\n\n  return await runThrowMode(resolvedPolicy, execute, sleep, signal);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,eAAe,OAAO,YAAmC;CACpE,IAAI,WAAW,GACb;CAIF,MAAM,IAAI,SAAe,YAAY;EACnC,WAAW,SAAS,OAAO;CAC7B,CAAC;AACH;;;;AAKA,MAAM,gBAAgB,WAAgC;CACpD,IAAI,kBAAkB,YACpB,OAAO;CAGT,IAAI,kBAAkB,OACpB,OAAO,IAAI,WAAW,OAAO,SAAS,EAAE,OAAO,OAAO,CAAC;CAGzD,IAAI,OAAO,WAAW,YAAY,OAAO,SAAS,GAChD,OAAO,IAAI,WAAW,MAAM;CAG9B,IAAI,WAAW,KAAA,GACb,OAAO,IAAI,WAAW,gBAAgB;CAGxC,IAAI;EACF,OAAO,IAAI,WAAW,kBAAkB,KAAK,UAAU,MAAM,GAAG;CAClE,QAAQ;EACN,OAAO,IAAI,WAAW,gBAAgB;CACxC;AACF;;;;;;;AAQA,MAAM,kBAAkB,WAA+B;CACrD,IAAI,QAAQ,YAAY,MACtB;CAGF,MAAM,aAAa,OAAO,MAAM;AAClC;;;;;;;;;;AAWA,MAAM,uBAAuB,OAC3B,OACA,SACA,WACkB;CAClB,IAAI,OAAO,SACT,MAAM,aAAa,OAAO,MAAM;CAGlC,IAAI;CAEJ,IAAI;EACF,MAAM,QAAQ,KAAK,CACjB,MAAM,OAAO,GAEb,IAAI,SAAgB,UAAU,WAAW;GACvC,gBAAsB;IACpB,OAAO,aAAa,OAAO,MAAM,CAAC;GACpC;GAEA,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EAC1D,CAAC,CACH,CAAC;CACH,UAAU;EACR,IAAI,SACF,OAAO,oBAAoB,SAAS,OAAO;CAE/C;AACF;;;;;;;;;;;;;;;;;AAkBA,MAAM,eAAe,OACnB,QACA,SACA,OACA,WACe;CACf,IAAI,UAAU;CAEd,OAAO,MAAM;EACX,eAAe,MAAM;EAErB,IAAI;GAEF,OAAO,MAAM,QAAQ,OAAO;EAC9B,SAAS,OAAO;GACd,eAAe,MAAM;GAErB,IAAI,CAAC,OAAO,aAAa,KAAK,GAC5B,MAAM;GAGR,MAAM,WAAW,OAAO,KAAK;IAC3B;IACA;GACF,CAAC;GAED,IAAI,CAAC,SAAS,aACZ,MAAM,OAAO,YAAY;IACvB,UAAU;IACV;GACF,CAAC;GAGH,IAAI,SAAS,UAAU,GAErB,OAAO,WAAW,KAAA,IACd,MAAM,SAAS,OAAO,IACtB,qBAAqB,OAAO,SAAS,SAAS,MAAM;GAG1D,WAAW;EACb;CACF;AACF;;;;;;;;;AAUA,MAAM,oBACJ,QACA,aACsC;CACtC,IAAI,QAAQ,YAAY,MACtB;CAGF,OAAO;EACL;EACA,OAAO,aAAa,OAAO,MAAM;EACjC,IAAI;CACN;AACF;;;;;;;;;AAUA,MAAM,aAAa,OACjB,SACA,YACoE;CACpE,IAAI;EACF,OAAO;GACL,IAAI;GACJ,OAAO,MAAM,QAAQ,OAAO;EAC9B;CACF,SAAS,OAAO;EACd,OAAO;GACL;GACA,IAAI;EACN;CACF;AACF;;;;;;;;;;;;;AAcA,MAAM,eAAe,OACnB,OACA,SACA,QACA,aAC+C;CAC/C,IAAI,WAAW,KAAA,GAAW;EACxB,MAAM,MAAM,OAAO;EACnB;CACF;CAEA,IAAI;EACF,MAAM,qBAAqB,OAAO,SAAS,MAAM;EACjD;CACF,SAAS,OAAO;EACd,MAAM,UAAU,iBAAiB,QAAQ,QAAQ;EACjD,IAAI,YAAY,KAAA,GACd,OAAO;EAET,MAAM;CACR;AACF;;;;;;;;;;;;;;;;AAiBA,MAAM,gBAAgB,OACpB,QACA,WAM+C;CAC/C,MAAM,EAAE,SAAS,OAAO,OAAO,WAAW;CAC1C,MAAM,cAAc,iBAAiB,QAAQ,OAAO;CACpD,IAAI,gBAAgB,KAAA,GAClB,OAAO;CAGT,MAAM,WAAW,OAAO,KAAK;EAC3B;EACA;CACF,CAAC;CAED,IAAI,CAAC,SAAS,aAMZ,OAAO;EACL,UAAU;EACV,OAPoB,OAAO,YAAY;GACvC,UAAU;GACV;EACF,CAIqB;EACnB,IAAI;CACN;CAGF,IAAI,SAAS,UAAU,GAAG;EACxB,MAAM,mBAAmB,MAAM,aAC7B,OACA,SAAS,SACT,QACA,OACF;EACA,IAAI,qBAAqB,KAAA,GACvB,OAAO;CAEX;AAGF;;;;;;;;;;;;;;;;AAiBA,MAAM,gBAAgB,OACpB,QACA,SACA,OACA,WAC+B;CAC/B,IAAI,UAAU;CAEd,OAAO,MAAM;EACX,MAAM,cAAc,iBAAiB,QAAQ,KAAK,IAAI,GAAG,UAAU,CAAC,CAAC;EACrE,IAAI,gBAAgB,KAAA,GAClB,OAAO;EAIT,MAAM,YAAY,MAAM,WAAW,SAAS,OAAO;EACnD,IAAI,UAAU,IACZ,OAAO;GAAE,IAAI;GAAM,OAAO,UAAU;EAAM;EAG5C,MAAM,qBAAqB,iBAAiB,QAAQ,OAAO;EAC3D,IAAI,uBAAuB,KAAA,GACzB,OAAO;EAGT,IAAI,CAAC,OAAO,aAAa,UAAU,KAAK,GACtC,OAAO;GACL,UAAU;GACV,OAAO,IAAI,WAAW,8CAA8C;IAClE,UAAU;IACV,WAAW,UAAU;GACvB,CAAC;GACD,IAAI;EACN;EAIF,MAAM,UAAU,MAAM,cAAc,QAAQ;GAC1C;GACA,OAAO,UAAU;GACjB;GACA;EACF,CAAC;EACD,IAAI,YAAY,KAAA,GACd,OAAO;EAGT,WAAW;CACb;AACF;;;;;AAMA,MAAM,sBACJ,UAEA,IAAI,WAAW,wCAAwC;CACrD,UAAU,MAAM;CAChB,UAAU,MAAM;CAChB,WAAW,MAAM;AACnB,CAAC;;;;;AAOH,MAAM,uBACJ,UACoB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;AAsFvC,eAAsB,eAKpB,QACA,SACA,UAA2B,CAAC,GACI;CAChC,MAAM,QAAQ,QAAQ,SAAS;CAC/B,MAAM,EAAE,WAAW;CACnB,MAAM,iBAAqD;EACzD,eAAe,UACb,OAAO,eACH,OAAO,aAAa,KAAK,IACzB,oBAAoB,KAAK;EAC/B,OAAO,UAAU,OAAO,KAAK,KAAK;EAClC,cAAc,UACZ,OAAO,cACH,OAAO,YAAY,KAAK,IACxB,mBAAmB,KAAK;CAChC;CAEA,IAAI,QAAQ,qBAAqB,OAC/B,OAAO,MAAM,cAAc,gBAAgB,SAAS,OAAO,MAAM;CAGnE,OAAO,MAAM,aAAa,gBAAgB,SAAS,OAAO,MAAM;AAClE"}

package/dist/{errors-BVZjP1Q5.d.mts → errors-CS5UPJWs.d.ts}

@@ -6,6 +6,9 @@
  */
 /**
  * Context payload attached to `RetryError`.
+ *
+ * @example
+ * const context: RetryErrorContext = { attempts: 3, lastError: new Error("network") };
  */
 interface RetryErrorContext {
   /**
@@ -23,6 +26,9 @@ interface RetryErrorContext {
 }
 /**
  * Context payload attached to `AbortError`.
+ *
+ * @example
+ * const context: AbortErrorContext = { cause: new Error("shutting down") };
  */
 interface AbortErrorContext {
   /**
@@ -59,6 +65,22 @@ declare class RetryError extends Error {
 }
 /**
  * Error thrown when retry orchestration is canceled through `AbortSignal`.
+ *
+ * @example
+ * ```ts
+ * import { AbortError, runRetryPolicy } from "@zap-studio/retry";
+ *
+ * const controller = new AbortController();
+ * controller.abort("shutting down");
+ *
+ * try {
+ *   await runRetryPolicy(policy, doWork, { signal: controller.signal });
+ * } catch (error) {
+ *   if (error instanceof AbortError) {
+ *     console.error("Retry canceled:", error.message);
+ *   }
+ * }
+ * ```
  */
 declare class AbortError extends Error {
   /**
@@ -66,6 +88,8 @@ declare class AbortError extends Error {
    */
   override readonly cause?: unknown;
   /**
+   * Creates an AbortError with an optional diagnostic cause.
+   *
    * @param message - Human-readable abort description.
    * @param context - Optional `cause` link for diagnostic chaining.
    */
@@ -73,4 +97,4 @@ declare class AbortError extends Error {
 }
 //#endregion
 export { RetryErrorContext as i, AbortErrorContext as n, RetryError as r, AbortError as t };
-//# sourceMappingURL=errors-BVZjP1Q5.d.mts.map
+//# sourceMappingURL=errors-CS5UPJWs.d.ts.map

package/dist/errors-CS5UPJWs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-CS5UPJWs.d.ts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;;;;;;;;;UAciB;;;;WAIN;;;;WAIA;;;;WAIA;;;;;;;;UASM;;;;WAIN;;;;;;;;;;;cAYE,mBAAmB;;;;WAId;;;;WAIA;;;;WAIA;;;;EAKhB,YAAY,iBAAiB,SAAS;;;;;;;;;;;;;;;;;;;;;cA4B3B,mBAAmB;;;;oBAIL;;;;;;;EAQzB,YAAY,iBAAiB,UAAS"}

package/dist/{errors.d.mts → errors.d.ts}

@@ -1,2 +1,2 @@
-import { i as RetryErrorContext, n as AbortErrorContext, r as RetryError, t as AbortError } from "./errors-BVZjP1Q5.mjs";
+import { i as RetryErrorContext, n as AbortErrorContext, r as RetryError, t as AbortError } from "./errors-CS5UPJWs.js";
 export { AbortError, AbortErrorContext, RetryError, RetryErrorContext };

package/dist/{errors.mjs → errors.js}

@@ -34,6 +34,22 @@ var RetryError = class extends Error {
 };
 /**
 * Error thrown when retry orchestration is canceled through `AbortSignal`.
+*
+* @example
+* ```ts
+* import { AbortError, runRetryPolicy } from "@zap-studio/retry";
+*
+* const controller = new AbortController();
+* controller.abort("shutting down");
+*
+* try {
+*   await runRetryPolicy(policy, doWork, { signal: controller.signal });
+* } catch (error) {
+*   if (error instanceof AbortError) {
+*     console.error("Retry canceled:", error.message);
+*   }
+* }
+* ```
 */
 var AbortError = class extends Error {
 	/**
@@ -41,6 +57,8 @@ var AbortError = class extends Error {
 	*/
 	cause;
 	/**
+	* Creates an AbortError with an optional diagnostic cause.
+	*
 	* @param message - Human-readable abort description.
 	* @param context - Optional `cause` link for diagnostic chaining.
 	*/
@@ -53,4 +71,4 @@ var AbortError = class extends Error {
 //#endregion
 export { AbortError, RetryError };
 
-//# sourceMappingURL=errors.mjs.map
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["// oxlint-disable max-classes-per-file -- Public retry error types are intentionally colocated.\n\n/**\n * Terminal error types used by retry policies and runners.\n *\n * @module @zap-studio/retry/errors\n */\n\n/**\n * Context payload attached to `RetryError`.\n *\n * @example\n * const context: RetryErrorContext = { attempts: 3, lastError: new Error(\"network\") };\n */\nexport interface RetryErrorContext {\n  /**\n   * Count of completed attempts at exhaustion.\n   */\n  readonly attempts: number;\n  /**\n   * The last error object raised by a failed `execute` attempt.\n   */\n  readonly lastError?: unknown;\n  /**\n   * Optional data captured from the last attempt when provided by a policy.\n   */\n  readonly lastData?: unknown;\n}\n\n/**\n * Context payload attached to `AbortError`.\n *\n * @example\n * const context: AbortErrorContext = { cause: new Error(\"shutting down\") };\n */\nexport interface AbortErrorContext {\n  /**\n   * When the abort `reason` was an `Error`, the optional wrapped cause.\n   */\n  readonly cause?: unknown;\n}\n\n/**\n * Error thrown when retries are exhausted.\n *\n * @example\n * throw new RetryError(\"Retry exhausted\", {\n *   attempts: 3,\n *   lastError: new Error(\"network\"),\n * });\n */\nexport class RetryError extends Error {\n  /**\n   * Total attempts performed before exhaustion.\n   */\n  public readonly attempts: number;\n  /**\n   * Last captured error from execution.\n   */\n  public readonly lastError?: unknown;\n  /**\n   * Last captured data value, when available.\n   */\n  public readonly lastData?: unknown;\n\n  /**\n   * Creates a RetryError with structured terminal context.\n   */\n  constructor(message: string, context: RetryErrorContext) {\n    super(message);\n    this.name = \"RetryError\";\n    this.attempts = context.attempts;\n    this.lastError = context.lastError;\n    this.lastData = context.lastData;\n  }\n}\n\n/**\n * Error thrown when retry orchestration is canceled through `AbortSignal`.\n *\n * @example\n * ```ts\n * import { AbortError, runRetryPolicy } from \"@zap-studio/retry\";\n *\n * const controller = new AbortController();\n * controller.abort(\"shutting down\");\n *\n * try {\n *   await runRetryPolicy(policy, doWork, { signal: controller.signal });\n * } catch (error) {\n *   if (error instanceof AbortError) {\n *     console.error(\"Retry canceled:\", error.message);\n *   }\n * }\n * ```\n */\nexport class AbortError extends Error {\n  /**\n   * Optional wrapped cause when the native abort `reason` was an `Error`.\n   */\n  public override readonly cause?: unknown;\n\n  /**\n   * Creates an AbortError with an optional diagnostic cause.\n   *\n   * @param message - Human-readable abort description.\n   * @param context - Optional `cause` link for diagnostic chaining.\n   */\n  constructor(message: string, context: AbortErrorContext = {}) {\n    super(message);\n    this.name = \"AbortError\";\n    this.cause = context.cause;\n  }\n}\n"],"mappings":";;;;;;;;;;AAmDA,IAAa,aAAb,cAAgC,MAAM;;;;CAIpC;;;;CAIA;;;;CAIA;;;;CAKA,YAAY,SAAiB,SAA4B;EACvD,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,WAAW,QAAQ;EACxB,KAAK,YAAY,QAAQ;EACzB,KAAK,WAAW,QAAQ;CAC1B;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,aAAb,cAAgC,MAAM;;;;CAIpC;;;;;;;CAQA,YAAY,SAAiB,UAA6B,CAAC,GAAG;EAC5D,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,QAAQ,QAAQ;CACvB;AACF"}

package/dist/exponential-backoff.d.ts

@@ -0,0 +1,40 @@
+import { RetryPolicy } from "./types.js";
+//#region src/exponential-backoff.d.ts
+/**
+ * Configuration for `exponentialBackoff(...)`.
+ *
+ * @example
+ * const options: ExponentialBackoffOptions = {
+ *   maxAttempts: 5,
+ *   baseDelayMs: 100,
+ *   maxDelayMs: 2_000,
+ * };
+ */
+interface ExponentialBackoffOptions {
+  /**
+   * Maximum number of attempts (including the first) before giving up.
+   */
+  maxAttempts: number;
+  /**
+   * Initial delay in milliseconds, doubled each retry until capped.
+   */
+  baseDelayMs: number;
+  /**
+   * Hard upper bound in milliseconds for computed exponential delay.
+   */
+  maxDelayMs: number;
+}
+/**
+ * Creates a retry policy with exponential delay growth up to a max cap.
+ *
+ * @example
+ * const policy = exponentialBackoff({
+ *   maxAttempts: 5,
+ *   baseDelayMs: 100,
+ *   maxDelayMs: 2_000,
+ * });
+ */
+declare const exponentialBackoff: (options: ExponentialBackoffOptions) => RetryPolicy;
+//#endregion
+export { ExponentialBackoffOptions, exponentialBackoff };
+//# sourceMappingURL=exponential-backoff.d.ts.map

package/dist/exponential-backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponential-backoff.d.ts","names":[],"sources":["../src/exponential-backoff.ts"],"mappings":";;;;;;;;;;;;UAsBiB;;;;EAIf;;;;EAIA;;;;EAIA;;;;;;;;;;;;cAaW,qBACX,SAAS,8BACR"}

package/dist/exponential-backoff.js

@@ -0,0 +1,35 @@
+//#region src/exponential-backoff.ts
+/**
+* Creates a retry policy with exponential delay growth up to a max cap.
+*
+* @example
+* const policy = exponentialBackoff({
+*   maxAttempts: 5,
+*   baseDelayMs: 100,
+*   maxDelayMs: 2_000,
+* });
+*/
+const exponentialBackoff = (options) => {
+	const { maxAttempts, baseDelayMs, maxDelayMs } = options;
+	return { 
+	/**
+	* Computes retry decision for the current attempt.
+	*/
+next(input) {
+		if (input.attempt >= maxAttempts) return {
+			delayMs: 0,
+			reason: "max-attempts-reached",
+			shouldRetry: false
+		};
+		const exponent = Math.max(0, input.attempt - 1);
+		return {
+			delayMs: Math.min(maxDelayMs, baseDelayMs * 2 ** exponent),
+			reason: "retry",
+			shouldRetry: true
+		};
+	} };
+};
+//#endregion
+export { exponentialBackoff };
+
+//# sourceMappingURL=exponential-backoff.js.map

package/dist/exponential-backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponential-backoff.js","names":[],"sources":["../src/exponential-backoff.ts"],"sourcesContent":["/**\n * Exponential backoff retry strategy.\n *\n * @module @zap-studio/retry/exponential-backoff\n */\n\nimport type {\n  RetryDecision,\n  RetryDecisionInput,\n  RetryPolicy,\n} from \"./types.js\";\n\n/**\n * Configuration for `exponentialBackoff(...)`.\n *\n * @example\n * const options: ExponentialBackoffOptions = {\n *   maxAttempts: 5,\n *   baseDelayMs: 100,\n *   maxDelayMs: 2_000,\n * };\n */\nexport interface ExponentialBackoffOptions {\n  /**\n   * Maximum number of attempts (including the first) before giving up.\n   */\n  maxAttempts: number;\n  /**\n   * Initial delay in milliseconds, doubled each retry until capped.\n   */\n  baseDelayMs: number;\n  /**\n   * Hard upper bound in milliseconds for computed exponential delay.\n   */\n  maxDelayMs: number;\n}\n\n/**\n * Creates a retry policy with exponential delay growth up to a max cap.\n *\n * @example\n * const policy = exponentialBackoff({\n *   maxAttempts: 5,\n *   baseDelayMs: 100,\n *   maxDelayMs: 2_000,\n * });\n */\nexport const exponentialBackoff = (\n  options: ExponentialBackoffOptions\n): RetryPolicy => {\n  const { maxAttempts, baseDelayMs, maxDelayMs } = options;\n\n  return {\n    /**\n     * Computes retry decision for the current attempt.\n     */\n    next(input: RetryDecisionInput): RetryDecision {\n      if (input.attempt >= maxAttempts) {\n        return {\n          delayMs: 0,\n          reason: \"max-attempts-reached\",\n          shouldRetry: false,\n        };\n      }\n\n      const exponent = Math.max(0, input.attempt - 1);\n      const delayMs = Math.min(maxDelayMs, baseDelayMs * 2 ** exponent);\n\n      return { delayMs, reason: \"retry\", shouldRetry: true };\n    },\n  };\n};\n"],"mappings":";;;;;;;;;;;AA+CA,MAAa,sBACX,YACgB;CAChB,MAAM,EAAE,aAAa,aAAa,eAAe;CAEjD,OAAO;;;;AAIL,KAAK,OAA0C;EAC7C,IAAI,MAAM,WAAW,aACnB,OAAO;GACL,SAAS;GACT,QAAQ;GACR,aAAa;EACf;EAGF,MAAM,WAAW,KAAK,IAAI,GAAG,MAAM,UAAU,CAAC;EAG9C,OAAO;GAAE,SAFO,KAAK,IAAI,YAAY,cAAc,KAAK,QAEzC;GAAG,QAAQ;GAAS,aAAa;EAAK;CACvD,EACF;AACF"}

package/dist/fixed-delay.d.ts

@@ -0,0 +1,31 @@
+import { RetryPolicy } from "./types.js";
+//#region src/fixed-delay.d.ts
+/**
+ * Configuration for `fixedDelay(...)`.
+ *
+ * @example
+ * const options: FixedDelayOptions = { maxAttempts: 3, delayMs: 250 };
+ */
+interface FixedDelayOptions {
+  /**
+   * Maximum number of attempts (including the first) before giving up.
+   */
+  maxAttempts: number;
+  /**
+   * Constant delay in milliseconds before each retry after a failure.
+   */
+  delayMs: number;
+}
+/**
+ * Creates a retry policy with a constant delay between attempts.
+ *
+ * @example
+ * const policy = fixedDelay({
+ *   maxAttempts: 3,
+ *   delayMs: 250,
+ * });
+ */
+declare const fixedDelay: (options: FixedDelayOptions) => RetryPolicy;
+//#endregion
+export { FixedDelayOptions, fixedDelay };
+//# sourceMappingURL=fixed-delay.d.ts.map

package/dist/fixed-delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-delay.d.ts","names":[],"sources":["../src/fixed-delay.ts"],"mappings":";;;;;;;;UAkBiB;;;;EAIf;;;;EAIA;;;;;;;;;;;cAYW,aAAc,SAAS,sBAAoB"}

package/dist/fixed-delay.js

@@ -0,0 +1,33 @@
+//#region src/fixed-delay.ts
+/**
+* Creates a retry policy with a constant delay between attempts.
+*
+* @example
+* const policy = fixedDelay({
+*   maxAttempts: 3,
+*   delayMs: 250,
+* });
+*/
+const fixedDelay = (options) => {
+	const { maxAttempts, delayMs } = options;
+	return { 
+	/**
+	* Computes retry decision for the current attempt.
+	*/
+next(input) {
+		if (input.attempt >= maxAttempts) return {
+			delayMs: 0,
+			reason: "max-attempts-reached",
+			shouldRetry: false
+		};
+		return {
+			delayMs,
+			reason: "retry",
+			shouldRetry: true
+		};
+	} };
+};
+//#endregion
+export { fixedDelay };
+
+//# sourceMappingURL=fixed-delay.js.map

package/dist/fixed-delay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-delay.js","names":[],"sources":["../src/fixed-delay.ts"],"sourcesContent":["/**\n * Fixed-delay retry strategy.\n *\n * @module @zap-studio/retry/fixed-delay\n */\n\nimport type {\n  RetryDecision,\n  RetryDecisionInput,\n  RetryPolicy,\n} from \"./types.js\";\n\n/**\n * Configuration for `fixedDelay(...)`.\n *\n * @example\n * const options: FixedDelayOptions = { maxAttempts: 3, delayMs: 250 };\n */\nexport interface FixedDelayOptions {\n  /**\n   * Maximum number of attempts (including the first) before giving up.\n   */\n  maxAttempts: number;\n  /**\n   * Constant delay in milliseconds before each retry after a failure.\n   */\n  delayMs: number;\n}\n\n/**\n * Creates a retry policy with a constant delay between attempts.\n *\n * @example\n * const policy = fixedDelay({\n *   maxAttempts: 3,\n *   delayMs: 250,\n * });\n */\nexport const fixedDelay = (options: FixedDelayOptions): RetryPolicy => {\n  const { maxAttempts, delayMs } = options;\n\n  return {\n    /**\n     * Computes retry decision for the current attempt.\n     */\n    next(input: RetryDecisionInput): RetryDecision {\n      if (input.attempt >= maxAttempts) {\n        return {\n          delayMs: 0,\n          reason: \"max-attempts-reached\",\n          shouldRetry: false,\n        };\n      }\n\n      return { delayMs, reason: \"retry\", shouldRetry: true };\n    },\n  };\n};\n"],"mappings":";;;;;;;;;;AAsCA,MAAa,cAAc,YAA4C;CACrE,MAAM,EAAE,aAAa,YAAY;CAEjC,OAAO;;;;AAIL,KAAK,OAA0C;EAC7C,IAAI,MAAM,WAAW,aACnB,OAAO;GACL,SAAS;GACT,QAAQ;GACR,aAAa;EACf;EAGF,OAAO;GAAE;GAAS,QAAQ;GAAS,aAAa;EAAK;CACvD,EACF;AACF"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { i as RetryErrorContext, n as AbortErrorContext, r as RetryError, t as AbortError } from "./errors-CS5UPJWs.js";
+import { RetryDecision, RetryDecisionInput, RetryExhaustedInput, RetryPolicy, RetryRunOptions, RetryRunResult } from "./types.js";
+import { defaultSleep, runRetryPolicy } from "./base-policy.js";
+import { ExponentialBackoffOptions, exponentialBackoff } from "./exponential-backoff.js";
+import { FixedDelayOptions, fixedDelay } from "./fixed-delay.js";
+import { LinearBackoffOptions, linearBackoff } from "./linear-backoff.js";
+export { AbortError, type AbortErrorContext, type ExponentialBackoffOptions, type FixedDelayOptions, type LinearBackoffOptions, type RetryDecision, type RetryDecisionInput, RetryError, type RetryErrorContext, type RetryExhaustedInput, type RetryPolicy, type RetryRunOptions, type RetryRunResult, defaultSleep, exponentialBackoff, fixedDelay, linearBackoff, runRetryPolicy };

package/dist/index.js

@@ -0,0 +1,6 @@
+import { AbortError, RetryError } from "./errors.js";
+import { defaultSleep, runRetryPolicy } from "./base-policy.js";
+import { exponentialBackoff } from "./exponential-backoff.js";
+import { fixedDelay } from "./fixed-delay.js";
+import { linearBackoff } from "./linear-backoff.js";
+export { AbortError, RetryError, defaultSleep, exponentialBackoff, fixedDelay, linearBackoff, runRetryPolicy };