@zap-studio/retry 1.2.1 → 2.1.0

package/dist/base-policy.d.ts

@@ -1,4 +1,6 @@
-import { RetryPolicy, RetryRunOptions, RetryRunResult } from "./types.js";
+import { r as RetryError, t as AbortError } from "./errors-CS5UPJWs.js";
+import { RetryPolicy, RetryRunOptions, RetryRunResult, RetryRunResultOptions } from "./types.js";
+import { ResultAsync } from "@zap-studio/monads";
 //#region src/base-policy.d.ts
 /**
  * Awaits a timer-based delay, unless `delayMs` is non-positive.
@@ -62,6 +64,43 @@ declare function runRetryPolicy<T, TError extends Error = Error, TData = unknown
 declare function runRetryPolicy<T, TError extends Error = Error, TData = unknown>(policy: RetryPolicy<TError, TData>, execute: (attempt: number) => Promise<T>, options?: RetryRunOptions & {
   throwOnExhausted?: true;
 }): Promise<T>;
+/**
+ * Runs retry orchestration, returning a `ResultAsync` instead of throwing or
+ * returning the hand-rolled {@link RetryRunResult} union.
+ *
+ * Additive alternative to `runRetryPolicy` for consumers who prefer explicit
+ * `Result`/`ResultAsync` values (from `@zap-studio/monads`) over throw/catch.
+ * There's no `throwOnExhausted` option — this function always returns a
+ * `Result`, so the flag doesn't apply.
+ *
+ * @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, same as {@link RetryRunOptions} minus
+ *   `throwOnExhausted`.
+ * @returns A `ResultAsync` resolving to `Ok` with the successful value, or `Err`
+ *   with a `RetryError` (exhaustion) or `AbortError` (cancellation) — the same
+ *   error object `runRetryPolicy`'s throw mode would throw. When
+ *   `policy.isKnownError` rejects a caught value, it is wrapped in a new
+ *   `RetryError` and returned on `Err` instead — in throw mode that same value
+ *   is rethrown unchanged, not wrapped.
+ * @throws {Error} Any error thrown by `next`, `onExhausted`, or a custom `sleep`
+ *   function.
+ *
+ * @example
+ * ```ts
+ * import { runRetryPolicyResult } from "@zap-studio/retry";
+ *
+ * const result = await runRetryPolicyResult(policy, async () => fetchFlakyResource());
+ *
+ * if (isOk(result)) {
+ *   console.log(result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare const runRetryPolicyResult: <T, TError extends Error = Error, TData = unknown>(policy: RetryPolicy<TError, TData>, execute: (attempt: number) => Promise<T>, options?: RetryRunResultOptions) => ResultAsync<T, RetryError | AbortError>;
 //#endregion
-export { defaultSleep, runRetryPolicy };
+export { defaultSleep, runRetryPolicy, runRetryPolicyResult };
 //# sourceMappingURL=base-policy.d.ts.map

package/dist/base-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-policy.d.ts","names":[],"sources":["../src/base-policy.ts"],"mappings":";;;;;;;;;;;;;;;cA+Ba,eAAsB,oBAAkB;;;;;;;;;;;;;iBAicrC,eACd,GACA,eAAe,QAAQ,OACvB,iBAEA,QAAQ,YAAY,QAAQ,QAC5B,UAAU,oBAAoB,QAAQ,IACtC,SAAS;EAAoB;IAC5B,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCV,eACd,GACA,eAAe,QAAQ,OACvB,iBAEA,QAAQ,YAAY,QAAQ,QAC5B,UAAU,oBAAoB,QAAQ,IACtC,UAAU;EAAoB;IAC7B,QAAQ"}
+{"version":3,"file":"base-policy.d.ts","names":[],"sources":["../src/base-policy.ts"],"mappings":";;;;;;;;;;;;;;;;;cAsCa,eAAsB,oBAAkB;;;;;;;;;;;;;iBAwerC,eAAe,GAAG,eAAe,QAAQ,OAAO,iBAC9D,QAAQ,YAAY,QAAQ,QAC5B,UAAU,oBAAoB,QAAQ,IACtC,SAAS;EAAoB;IAC5B,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCV,eAAe,GAAG,eAAe,QAAQ,OAAO,iBAC9D,QAAQ,YAAY,QAAQ,QAC5B,UAAU,oBAAoB,QAAQ,IACtC,UAAU;EAAoB;IAC7B,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4EE,uBAAwB,GAAG,eAAe,QAAQ,OAAO,iBACpE,QAAQ,YAAY,QAAQ,QAC5B,UAAU,oBAAoB,QAAQ,IACtC,UAAS,0BACR,YAAY,GAAG,aAAa"}

package/dist/base-policy.js

@@ -1,334 +1,3 @@
-import { AbortError, RetryError } from "./errors.js";
-//#region src/base-policy.ts
-/**
-* 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.
-* @param logger - Optional logger; logs the abort at `debug` before throwing.
-* @throws {AbortError} When the signal is aborted.
-*/
-const throwIfAborted = (signal, logger) => {
-	if (signal?.aborted !== true) return;
-	logger?.debug("retry aborted", { reason: signal.reason });
-	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);
-	}
-};
-/**
-* Logs a `next(...)` decision: `debug` when retrying, `warn` when exhausted.
-* Shared by both the throw-mode and non-throw retry loops.
-*/
-const logRetryDecision = (logger, attempt, decision, error) => {
-	if (decision.shouldRetry) {
-		logger?.debug("retry scheduled", {
-			attempt,
-			delayMs: decision.delayMs,
-			reason: decision.reason
-		});
-		return;
-	}
-	logger?.warn("retry policy exhausted", {
-		attempts: attempt,
-		error,
-		reason: decision.reason
-	});
-};
-/**
-* 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.
-* @param logger - Optional logger; logs each retry decision at `debug` and
-*   exhaustion at `warn`.
-* @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, logger) => {
-	let attempt = 1;
-	while (true) {
-		throwIfAborted(signal, logger);
-		try {
-			return await execute(attempt);
-		} catch (error) {
-			throwIfAborted(signal, logger);
-			if (!policy.isKnownError(error)) throw error;
-			const decision = policy.next({
-				attempt,
-				error
-			});
-			logRetryDecision(logger, attempt, decision, 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.
-* @param logger - Optional logger; logs the abort at `debug`.
-* @returns Failure result or `undefined` if not aborted.
-*/
-const buildAbortResult = (signal, attempts, logger) => {
-	if (signal?.aborted !== true) return;
-	logger?.debug("retry aborted", { reason: signal.reason });
-	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.
-* @param logger - Optional logger; logs an abort ending the wait at `debug`.
-* @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, logger) => {
-	if (signal === void 0) {
-		await sleep(delayMs);
-		return;
-	}
-	try {
-		await sleepWithAbortSignal(sleep, delayMs, signal);
-		return;
-	} catch (error) {
-		const aborted = buildAbortResult(signal, attempts, logger);
-		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.
-* @param params.logger - Optional logger; logs each retry decision at
-*   `debug`, exhaustion at `warn`, and cancellation at `debug`.
-* @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, logger } = params;
-	const abortResult = buildAbortResult(signal, attempt, logger);
-	if (abortResult !== void 0) return abortResult;
-	const decision = policy.next({
-		attempt,
-		error
-	});
-	logRetryDecision(logger, attempt, decision, 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, logger);
-		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.
-* @param logger - Optional logger; logs each retry decision at `debug`,
-*   exhaustion at `warn`, and cancellation at `debug`.
-* @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, logger) => {
-	let attempt = 1;
-	while (true) {
-		const abortResult = buildAbortResult(signal, Math.max(0, attempt - 1), logger);
-		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, logger);
-		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,
-			logger,
-			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, logger } = 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, logger);
-	return await runThrowMode(resolvedPolicy, execute, sleep, signal, logger);
-}
-//#endregion
-export { defaultSleep, runRetryPolicy };
-
-//# sourceMappingURL=base-policy.js.map
+import { n as runRetryPolicy, r as runRetryPolicyResult, t as defaultSleep } from "./base-policy-DkxBg9dh.js";
+import "./errors.js";
+export { defaultSleep, runRetryPolicy, runRetryPolicyResult };

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

@@ -1 +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"}
+{"version":3,"file":"errors-CS5UPJWs.d.ts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;;;;;;;;;UAYiB;;;;WAIN;;;;WAIA;;;;WAIA;;;;;;;;UASM;;;;WAIN;;;;;;;;;;;cAYE,mBAAmB;;;;WAId;;;;WAIA;;;;WAIA;;;;EAKhB,YAAY,iBAAiB,SAAS;;;;;;;;;;;;;;;;;;;;;cA4B3B,mBAAmB;;;;oBAIL;;;;;;;EAQzB,YAAY,iBAAiB,UAAS"}

package/dist/errors.js.map

@@ -1 +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"}
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\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":";;;;;;;;;;AAiDA,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.map

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

package/dist/exponential-backoff.js

@@ -1,11 +1,6 @@
 import { applyJitter } from "./jitter.js";
 //#region src/exponential-backoff.ts
 /**
-* Exponential backoff retry strategy.
-*
-* @module @zap-studio/retry/exponential-backoff
-*/
-/**
 * Creates a retry policy with exponential delay growth up to a max cap.
 *
 * @example

package/dist/exponential-backoff.js.map

@@ -1 +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 { applyJitter } from \"./jitter.js\";\nimport type { JitterMode, JitterOptions } from \"./jitter.js\";\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 *   jitter: \"full\",\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   * Optional jitter applied to the computed delay, after capping at\n   * `maxDelayMs`.\n   */\n  jitter?: JitterMode | JitterOptions;\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, jitter } = 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 cappedDelayMs = Math.min(maxDelayMs, baseDelayMs * 2 ** exponent);\n      const delayMs = applyJitter(cappedDelayMs, jitter);\n\n      return { delayMs, reason: \"retry\", shouldRetry: true };\n    },\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAuDA,MAAa,sBACX,YACgB;CAChB,MAAM,EAAE,aAAa,aAAa,YAAY,WAAW;CAEzD,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;EAC9C,MAAM,gBAAgB,KAAK,IAAI,YAAY,cAAc,KAAK,QAAQ;EAGtE,OAAO;GAAE,SAFO,YAAY,eAAe,MAE5B;GAAG,QAAQ;GAAS,aAAa;EAAK;CACvD,EACF;AACF"}
+{"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 { JitterMode, JitterOptions } from \"./jitter.ts\";\nimport type { RetryDecision, RetryDecisionInput, RetryPolicy } from \"./types.ts\";\n\nimport { applyJitter } from \"./jitter.ts\";\n\n/**\n * Configuration for `exponentialBackoff(...)`.\n *\n * @example\n * const options: ExponentialBackoffOptions = {\n *   maxAttempts: 5,\n *   baseDelayMs: 100,\n *   maxDelayMs: 2_000,\n *   jitter: \"full\",\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   * Optional jitter applied to the computed delay, after capping at\n   * `maxDelayMs`.\n   */\n  jitter?: JitterMode | JitterOptions;\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 = (options: ExponentialBackoffOptions): RetryPolicy => {\n  const { maxAttempts, baseDelayMs, maxDelayMs, jitter } = 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 cappedDelayMs = Math.min(maxDelayMs, baseDelayMs * 2 ** exponent);\n      const delayMs = applyJitter(cappedDelayMs, jitter);\n\n      return { delayMs, reason: \"retry\", shouldRetry: true };\n    },\n  };\n};\n"],"mappings":";;;;;;;;;;;;AAoDA,MAAa,sBAAsB,YAAoD;CACrF,MAAM,EAAE,aAAa,aAAa,YAAY,WAAW;CAEzD,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;EAC9C,MAAM,gBAAgB,KAAK,IAAI,YAAY,cAAc,KAAK,QAAQ;EAGtE,OAAO;GAAE,SAFO,YAAY,eAAe,MAE5B;GAAG,QAAQ;GAAS,aAAa;EAAK;CACvD,EACF;AACF"}

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

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

package/dist/fixed-delay.js.map

@@ -1 +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"}
+{"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 { RetryDecision, RetryDecisionInput, RetryPolicy } from \"./types.ts\";\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":";;;;;;;;;;AAkCA,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

@@ -1,8 +1,8 @@
 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 { RetryDecision, RetryDecisionInput, RetryExhaustedInput, RetryPolicy, RetryRunOptions, RetryRunResult, RetryRunResultOptions } from "./types.js";
+import { defaultSleep, runRetryPolicy, runRetryPolicyResult } from "./base-policy.js";
 import { JitterMode, JitterOptions, applyJitter } from "./jitter.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 JitterMode, type JitterOptions, type LinearBackoffOptions, type RetryDecision, type RetryDecisionInput, RetryError, type RetryErrorContext, type RetryExhaustedInput, type RetryPolicy, type RetryRunOptions, type RetryRunResult, applyJitter, defaultSleep, exponentialBackoff, fixedDelay, linearBackoff, runRetryPolicy };
+export { AbortError, type AbortErrorContext, type ExponentialBackoffOptions, type FixedDelayOptions, type JitterMode, type JitterOptions, type LinearBackoffOptions, type RetryDecision, type RetryDecisionInput, RetryError, type RetryErrorContext, type RetryExhaustedInput, type RetryPolicy, type RetryRunOptions, type RetryRunResult, type RetryRunResultOptions, applyJitter, defaultSleep, exponentialBackoff, fixedDelay, linearBackoff, runRetryPolicy, runRetryPolicyResult };

package/dist/index.js

@@ -1,7 +1,7 @@
+import { n as runRetryPolicy, r as runRetryPolicyResult, t as defaultSleep } from "./base-policy-DkxBg9dh.js";
 import { AbortError, RetryError } from "./errors.js";
-import { defaultSleep, runRetryPolicy } from "./base-policy.js";
 import { applyJitter } from "./jitter.js";
 import { exponentialBackoff } from "./exponential-backoff.js";
 import { fixedDelay } from "./fixed-delay.js";
 import { linearBackoff } from "./linear-backoff.js";
-export { AbortError, RetryError, applyJitter, defaultSleep, exponentialBackoff, fixedDelay, linearBackoff, runRetryPolicy };
+export { AbortError, RetryError, applyJitter, defaultSleep, exponentialBackoff, fixedDelay, linearBackoff, runRetryPolicy, runRetryPolicyResult };

package/dist/jitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jitter.d.ts","names":[],"sources":["../src/jitter.ts"],"mappings":";;;;;;;;;;;;;;KAcY;;;;;;;UAQK;;;;EAIf,MAAM;;;;;;EAMN;;;;;;;;;;;;;cAcW,cACX,iBACA,SAAS,aAAa"}
+{"version":3,"file":"jitter.d.ts","names":[],"sources":["../src/jitter.ts"],"mappings":";;;;;;;;;;;;;;KAcY;;;;;;;UAQK;;;;EAIf,MAAM;;;;;;EAMN;;;;;;;;;;;;;cAcW,cAAe,iBAAiB,SAAS,aAAa"}

package/dist/jitter.js.map

@@ -1 +1 @@
-{"version":3,"file":"jitter.js","names":[],"sources":["../src/jitter.ts"],"sourcesContent":["/**\n * Jitter strategies applied to a computed backoff delay.\n *\n * @module @zap-studio/retry/jitter\n */\n\n/**\n * Supported jitter strategies.\n *\n * - `\"full\"`: `random(0, delayMs)` — max spread, best thundering-herd\n *   protection.\n * - `\"equal\"`: `delayMs/2 + random(0, delayMs/2)` — keeps a floor at half\n *   the computed delay, less spread than full jitter.\n */\nexport type JitterMode = \"equal\" | \"full\";\n\n/**\n * Configuration for jitter application.\n *\n * @example\n * const jitter: JitterOptions = { mode: \"full\" };\n */\nexport interface JitterOptions {\n  /**\n   * Jitter strategy to apply.\n   */\n  mode: JitterMode;\n  /**\n   * Random source in `[0, 1)`, overridable for deterministic tests.\n   *\n   * @default Math.random\n   */\n  random?: () => number;\n}\n\n/**\n * Applies a jitter strategy to a computed delay.\n *\n * @param delayMs - Delay in milliseconds before jitter.\n * @param jitter - Jitter mode shorthand, full `JitterOptions`, or `undefined`\n *   to leave `delayMs` untouched.\n * @returns Jittered delay in milliseconds, rounded to the nearest integer.\n *\n * @example\n * const delayMs = applyJitter(1000, \"full\"); // 0-1000\n */\nexport const applyJitter = (\n  delayMs: number,\n  jitter?: JitterMode | JitterOptions\n): number => {\n  if (jitter === undefined) {\n    return delayMs;\n  }\n\n  const mode = typeof jitter === \"string\" ? jitter : jitter.mode;\n  const random =\n    (typeof jitter === \"string\" ? undefined : jitter.random) ?? Math.random;\n\n  if (mode === \"full\") {\n    return Math.round(random() * delayMs);\n  }\n\n  const half = delayMs / 2;\n  return Math.round(half + random() * half);\n};\n"],"mappings":";;;;;;;;;;;;AA8CA,MAAa,eACX,SACA,WACW;CACX,IAAI,WAAW,KAAA,GACb,OAAO;CAGT,MAAM,OAAO,OAAO,WAAW,WAAW,SAAS,OAAO;CAC1D,MAAM,UACH,OAAO,WAAW,WAAW,KAAA,IAAY,OAAO,WAAW,KAAK;CAEnE,IAAI,SAAS,QACX,OAAO,KAAK,MAAM,OAAO,IAAI,OAAO;CAGtC,MAAM,OAAO,UAAU;CACvB,OAAO,KAAK,MAAM,OAAO,OAAO,IAAI,IAAI;AAC1C"}
+{"version":3,"file":"jitter.js","names":[],"sources":["../src/jitter.ts"],"sourcesContent":["/**\n * Jitter strategies applied to a computed backoff delay.\n *\n * @module @zap-studio/retry/jitter\n */\n\n/**\n * Supported jitter strategies.\n *\n * - `\"full\"`: `random(0, delayMs)` — max spread, best thundering-herd\n *   protection.\n * - `\"equal\"`: `delayMs/2 + random(0, delayMs/2)` — keeps a floor at half\n *   the computed delay, less spread than full jitter.\n */\nexport type JitterMode = \"equal\" | \"full\";\n\n/**\n * Configuration for jitter application.\n *\n * @example\n * const jitter: JitterOptions = { mode: \"full\" };\n */\nexport interface JitterOptions {\n  /**\n   * Jitter strategy to apply.\n   */\n  mode: JitterMode;\n  /**\n   * Random source in `[0, 1)`, overridable for deterministic tests.\n   *\n   * @default Math.random\n   */\n  random?: () => number;\n}\n\n/**\n * Applies a jitter strategy to a computed delay.\n *\n * @param delayMs - Delay in milliseconds before jitter.\n * @param jitter - Jitter mode shorthand, full `JitterOptions`, or `undefined`\n *   to leave `delayMs` untouched.\n * @returns Jittered delay in milliseconds, rounded to the nearest integer.\n *\n * @example\n * const delayMs = applyJitter(1000, \"full\"); // 0-1000\n */\nexport const applyJitter = (delayMs: number, jitter?: JitterMode | JitterOptions): number => {\n  if (jitter === undefined) {\n    return delayMs;\n  }\n\n  const mode = typeof jitter === \"string\" ? jitter : jitter.mode;\n  const random = (typeof jitter === \"string\" ? undefined : jitter.random) ?? Math.random;\n\n  if (mode === \"full\") {\n    return Math.round(random() * delayMs);\n  }\n\n  const half = delayMs / 2;\n  return Math.round(half + random() * half);\n};\n"],"mappings":";;;;;;;;;;;;AA8CA,MAAa,eAAe,SAAiB,WAAgD;CAC3F,IAAI,WAAW,KAAA,GACb,OAAO;CAGT,MAAM,OAAO,OAAO,WAAW,WAAW,SAAS,OAAO;CAC1D,MAAM,UAAU,OAAO,WAAW,WAAW,KAAA,IAAY,OAAO,WAAW,KAAK;CAEhF,IAAI,SAAS,QACX,OAAO,KAAK,MAAM,OAAO,IAAI,OAAO;CAGtC,MAAM,OAAO,UAAU;CACvB,OAAO,KAAK,MAAM,OAAO,OAAO,IAAI,IAAI;AAC1C"}

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

@@ -1 +1 @@
-{"version":3,"file":"linear-backoff.d.ts","names":[],"sources":["../src/linear-backoff.ts"],"mappings":";;;;;;;;;;;;;;;UA0BiB;;;;EAIf;;;;EAIA;;;;EAIA;;;;EAIA;;;;;EAKA,SAAS,aAAa;;;;;;;;;;;;;cAcX,gBAAiB,SAAS,yBAAuB"}
+{"version":3,"file":"linear-backoff.d.ts","names":[],"sources":["../src/linear-backoff.ts"],"mappings":";;;;;;;;;;;;;;;UAuBiB;;;;EAIf;;;;EAIA;;;;EAIA;;;;EAIA;;;;;EAKA,SAAS,aAAa;;;;;;;;;;;;;cAcX,gBAAiB,SAAS,yBAAuB"}

package/dist/linear-backoff.js

@@ -1,11 +1,6 @@
 import { applyJitter } from "./jitter.js";
 //#region src/linear-backoff.ts
 /**
-* Linear backoff retry strategy.
-*
-* @module @zap-studio/retry/linear-backoff
-*/
-/**
 * Creates a retry policy with linear delay growth up to a max cap.
 *
 * @example

package/dist/linear-backoff.js.map

@@ -1 +1 @@
-{"version":3,"file":"linear-backoff.js","names":[],"sources":["../src/linear-backoff.ts"],"sourcesContent":["/**\n * Linear backoff retry strategy.\n *\n * @module @zap-studio/retry/linear-backoff\n */\n\nimport { applyJitter } from \"./jitter.js\";\nimport type { JitterMode, JitterOptions } from \"./jitter.js\";\nimport type {\n  RetryDecision,\n  RetryDecisionInput,\n  RetryPolicy,\n} from \"./types.js\";\n\n/**\n * Configuration for `linearBackoff(...)`.\n *\n * @example\n * const options: LinearBackoffOptions = {\n *   maxAttempts: 5,\n *   baseDelayMs: 100,\n *   incrementMs: 100,\n *   maxDelayMs: 2_000,\n *   jitter: \"equal\",\n * };\n */\nexport interface LinearBackoffOptions {\n  /**\n   * Maximum number of attempts (including the first) before giving up.\n   */\n  maxAttempts: number;\n  /**\n   * Delay in milliseconds after the first failed attempt.\n   */\n  baseDelayMs: number;\n  /**\n   * Amount added to the delay for each subsequent retry.\n   */\n  incrementMs: number;\n  /**\n   * Hard upper bound in milliseconds for computed linear delay.\n   */\n  maxDelayMs: number;\n  /**\n   * Optional jitter applied to the computed delay, after capping at\n   * `maxDelayMs`.\n   */\n  jitter?: JitterMode | JitterOptions;\n}\n\n/**\n * Creates a retry policy with linear delay growth up to a max cap.\n *\n * @example\n * const policy = linearBackoff({\n *   maxAttempts: 5,\n *   baseDelayMs: 100,\n *   incrementMs: 100,\n *   maxDelayMs: 2_000,\n * });\n */\nexport const linearBackoff = (options: LinearBackoffOptions): RetryPolicy => {\n  const { maxAttempts, baseDelayMs, incrementMs, maxDelayMs, jitter } = 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 cappedDelayMs = Math.min(\n        maxDelayMs,\n        baseDelayMs + incrementMs * (input.attempt - 1)\n      );\n      const delayMs = applyJitter(cappedDelayMs, jitter);\n\n      return { delayMs, reason: \"retry\", shouldRetry: true };\n    },\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AA6DA,MAAa,iBAAiB,YAA+C;CAC3E,MAAM,EAAE,aAAa,aAAa,aAAa,YAAY,WAAW;CAEtE,OAAO;;;;AAIL,KAAK,OAA0C;EAC7C,IAAI,MAAM,WAAW,aACnB,OAAO;GACL,SAAS;GACT,QAAQ;GACR,aAAa;EACf;EAGF,MAAM,gBAAgB,KAAK,IACzB,YACA,cAAc,eAAe,MAAM,UAAU,EAC/C;EAGA,OAAO;GAAE,SAFO,YAAY,eAAe,MAE5B;GAAG,QAAQ;GAAS,aAAa;EAAK;CACvD,EACF;AACF"}
+{"version":3,"file":"linear-backoff.js","names":[],"sources":["../src/linear-backoff.ts"],"sourcesContent":["/**\n * Linear backoff retry strategy.\n *\n * @module @zap-studio/retry/linear-backoff\n */\n\nimport type { JitterMode, JitterOptions } from \"./jitter.ts\";\nimport type { RetryDecision, RetryDecisionInput, RetryPolicy } from \"./types.ts\";\n\nimport { applyJitter } from \"./jitter.ts\";\n\n/**\n * Configuration for `linearBackoff(...)`.\n *\n * @example\n * const options: LinearBackoffOptions = {\n *   maxAttempts: 5,\n *   baseDelayMs: 100,\n *   incrementMs: 100,\n *   maxDelayMs: 2_000,\n *   jitter: \"equal\",\n * };\n */\nexport interface LinearBackoffOptions {\n  /**\n   * Maximum number of attempts (including the first) before giving up.\n   */\n  maxAttempts: number;\n  /**\n   * Delay in milliseconds after the first failed attempt.\n   */\n  baseDelayMs: number;\n  /**\n   * Amount added to the delay for each subsequent retry.\n   */\n  incrementMs: number;\n  /**\n   * Hard upper bound in milliseconds for computed linear delay.\n   */\n  maxDelayMs: number;\n  /**\n   * Optional jitter applied to the computed delay, after capping at\n   * `maxDelayMs`.\n   */\n  jitter?: JitterMode | JitterOptions;\n}\n\n/**\n * Creates a retry policy with linear delay growth up to a max cap.\n *\n * @example\n * const policy = linearBackoff({\n *   maxAttempts: 5,\n *   baseDelayMs: 100,\n *   incrementMs: 100,\n *   maxDelayMs: 2_000,\n * });\n */\nexport const linearBackoff = (options: LinearBackoffOptions): RetryPolicy => {\n  const { maxAttempts, baseDelayMs, incrementMs, maxDelayMs, jitter } = 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 cappedDelayMs = Math.min(maxDelayMs, baseDelayMs + incrementMs * (input.attempt - 1));\n      const delayMs = applyJitter(cappedDelayMs, jitter);\n\n      return { delayMs, reason: \"retry\", shouldRetry: true };\n    },\n  };\n};\n"],"mappings":";;;;;;;;;;;;;AA0DA,MAAa,iBAAiB,YAA+C;CAC3E,MAAM,EAAE,aAAa,aAAa,aAAa,YAAY,WAAW;CAEtE,OAAO;;;;AAIL,KAAK,OAA0C;EAC7C,IAAI,MAAM,WAAW,aACnB,OAAO;GACL,SAAS;GACT,QAAQ;GACR,aAAa;EACf;EAGF,MAAM,gBAAgB,KAAK,IAAI,YAAY,cAAc,eAAe,MAAM,UAAU,EAAE;EAG1F,OAAO;GAAE,SAFO,YAAY,eAAe,MAE5B;GAAG,QAAQ;GAAS,aAAa;EAAK;CACvD,EACF;AACF"}

package/dist/types.d.ts

@@ -166,6 +166,17 @@ interface RetryRunOptions {
    */
   readonly logger?: Logger;
 }
+/**
+ * Options for `runRetryPolicyResult(...)`.
+ *
+ * Same as {@link RetryRunOptions} minus `throwOnExhausted`, which doesn't
+ * apply — `runRetryPolicyResult` always returns a `Result`, never throws for
+ * exhaustion or abort.
+ *
+ * @example
+ * const options: RetryRunResultOptions = { signal: controller.signal };
+ */
+type RetryRunResultOptions = Omit<RetryRunOptions, "throwOnExhausted">;
 /**
  * Result union returned by non-throw runner mode.
  *
@@ -202,5 +213,5 @@ type RetryRunResult<T> = {
   attempts: number;
 };
 //#endregion
-export { ResolvedRetryPolicy, RetryDecision, RetryDecisionInput, RetryExhaustedInput, RetryPolicy, RetryRunOptions, RetryRunResult };
+export { ResolvedRetryPolicy, RetryDecision, RetryDecisionInput, RetryExhaustedInput, RetryPolicy, RetryRunOptions, RetryRunResult, RetryRunResultOptions };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;;;UAuBiB,YAAY,eAAe,QAAQ,OAAO;;;;;;EAMzD,OAAO,OAAO,mBAAmB,QAAQ,WAAW;;;;;;;;EAQpD,eAAe,OAAO,oBAAoB,QAAQ,WAAW;;;;;;;;;;;;;EAa7D,gBAAgB,mBAAmB,SAAS;;;;;;UAO7B,oBAAoB,eAAe,OAAO;;;;EAIzD,MAAM,YAAY,QAAQ;;;;;EAK1B,cAAc,OAAO,oBAAoB,QAAQ,WAAW;;;;;EAK5D,eAAe,mBAAmB,SAAS;;;;;;;;UAS5B;;;;;WAKN;;;;WAIA;;;;WAIA;;;;;;;;UASM,mBACf,eAAe,QAAQ,OACvB;;;;WAKS;;;;;WAKA;;;;;WAKA,QAAQ;;;;;WAKR,OAAO;;;;;;;;UASD,oBACf,eAAe,QAAQ,OACvB;;;;WAKS;;;;WAIA,QAAQ;;;;WAIR,OAAO;;;;;;;;UASD;;;;;;WAMN,SAAS,oBAAoB;;;;;;WAM7B,SAAS;;;;;;;;WAQT;;;;;;;WAOA,SAAS;;;;;;;;;;;;;KAcR,eAAe;;;;EAKrB;;;;EAIA,OAAO;;;;;EAMP;;;;;EAKA,OAAO,aAAa;;;;EAIpB"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;;;UAuBiB,YAAY,eAAe,QAAQ,OAAO;;;;;;EAMzD,OAAO,OAAO,mBAAmB,QAAQ,WAAW;;;;;;;;EAQpD,eAAe,OAAO,oBAAoB,QAAQ,WAAW;;;;;;;;;;;;;EAa7D,gBAAgB,mBAAmB,SAAS;;;;;;UAO7B,oBAAoB,eAAe,OAAO;;;;EAIzD,MAAM,YAAY,QAAQ;;;;;EAK1B,cAAc,OAAO,oBAAoB,QAAQ,WAAW;;;;;EAK5D,eAAe,mBAAmB,SAAS;;;;;;;;UAS5B;;;;;WAKN;;;;WAIA;;;;WAIA;;;;;;;;UASM,mBAAmB,eAAe,QAAQ,OAAO;;;;WAIvD;;;;;WAKA;;;;;WAKA,QAAQ;;;;;WAKR,OAAO;;;;;;;;UASD,oBAAoB,eAAe,QAAQ,OAAO;;;;WAIxD;;;;WAIA,QAAQ;;;;WAIR,OAAO;;;;;;;;UASD;;;;;;WAMN,SAAS,oBAAoB;;;;;;WAM7B,SAAS;;;;;;;;WAQT;;;;;;;WAOA,SAAS;;;;;;;;;;;;KAaR,wBAAwB,KAAK;;;;;;;;;;;;KAa7B,eAAe;;;;EAKrB;;;;EAIA,OAAO;;;;;EAMP;;;;;EAKA,OAAO,aAAa;;;;EAIpB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-studio/retry",
-  "version": "1.2.1",
+  "version": "2.1.0",
   "private": false,
   "description": "Composable, tree-shakeable retry policies for resilient async operations.",
   "keywords": [
@@ -43,15 +43,23 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@zap-studio/monads": "1.0.0"
+  },
   "devDependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/context-async-hooks": "^2.10.0",
+    "@opentelemetry/sdk-metrics": "^2.10.0",
+    "@opentelemetry/sdk-trace-base": "^2.10.0",
     "tsdown": "^0.22.14",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10",
-    "@zap-studio/logger": "1.0.0",
-    "@zap-studio/typescript": "0.0.0"
+    "@zap-studio/typescript": "0.0.0",
+    "@zap-studio/logger": "2.0.0"
   },
   "peerDependencies": {
-    "@zap-studio/logger": "1.0.0"
+    "@opentelemetry/api": "^1.9.0",
+    "@zap-studio/logger": "2.0.0"
   },
   "peerDependenciesMeta": {
     "@zap-studio/logger": {