@zap-studio/retry 2.1.0 → 2.1.2

package/CHANGELOG.md

@@ -4,39 +4,52 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.1.0]
+
+## 2.1.2
+<sub>2026-09-13</sub>
+
+- [#613](https://github.com/zap-studio/monorepo/pull/613)  *(patch)* Thanks [@alexandretrotel](https://github.com/alexandretrotel)!
+  Widen internal peer dependency ranges from an exact pin to a caret range, so consumers no longer resolve a duplicate copy of the peer on version skew.
+
+## [2.1.1]
+
+### Changed
+
+We removed the `@zap-studio/monads` dependency and the `runRetryPolicyResult` export from 2.1.0. They added a dependency and more bundle size, for something you can already do yourself: wrap `runRetryPolicy` with `@zap-studio/monads`'s `fromPromise`. See the README section "Using with `@zap-studio/monads`". 2.1.0 is deprecated on npm — use this release instead.
+
+## [2.1.0] (deprecated — see 2.1.1)
 
 ### Added
 
-- Added `runRetryPolicyResult(policy, execute, options?)`, a `ResultAsync`-returning alternative to `runRetryPolicy`, backed by the new `@zap-studio/monads` dependency. Additive and opt-in — `runRetryPolicy` (both throw and non-throw modes) is unchanged. No `throwOnExhausted` option; it always returns a `Result`. `Err`'s payload is the same `RetryError`/`AbortError` object `runRetryPolicy`'s throw mode would throw, preserving `RetryError.attempts`/`lastError`/`lastData` and `AbortError.cause`.
+- Added `runRetryPolicyResult(policy, execute, options?)`. It is like `runRetryPolicy`, but returns a `ResultAsync` instead, using the new `@zap-studio/monads` dependency. This is new and optional — `runRetryPolicy` (both throw and non-throw modes) stays the same. `runRetryPolicyResult` has no `throwOnExhausted` option; it always returns a `Result`. The `Err` value is the same `RetryError`/`AbortError` object that `runRetryPolicy`'s throw mode would throw, so `RetryError.attempts`/`lastError`/`lastData` and `AbortError.cause` are kept.
 
 ## [2.0.0]
 
 ### Added
 
-Native OpenTelemetry support. Unlike `fetch`, `webhooks`, and `permit`, this package never creates its own span — a retry loop wraps someone else's operation, so each decision is recorded as an event (`retry.scheduled`/`retry.exhausted`) on whatever span is already active, plus a `retry.attempts` counter tagged by outcome. See [OpenTelemetry](https://www.zapstudio.dev/retry/opentelemetry).
+Added native OpenTelemetry support. `fetch`, `webhooks`, and `permit` each create their own span. This package does not, because a retry loop wraps someone else's work. Instead, each decision is recorded as an event (`retry.scheduled`/`retry.exhausted`) on whatever span is already active, plus a `retry.attempts` counter tagged by outcome. See [OpenTelemetry](https://www.zapstudio.dev/retry/opentelemetry).
 
 ### Changed
 
-**Breaking:** `@opentelemetry/api` is now a required peer dependency. It's tiny, side-effect-free, and a no-op until an app registers a real SDK, so nothing changes at runtime for consumers who don't set one up — but the package won't resolve without it installed: `npm install @opentelemetry/api`.
+**Breaking:** `@opentelemetry/api` is now a required peer dependency. It is small, has no side effects, and does nothing until an app sets up a real SDK, so nothing changes at runtime if you don't set one up. But the package won't resolve without it installed: `npm install @opentelemetry/api`.
 
 ## [1.2.1]
 
 ### Changed
 
-`@zap-studio/logger` is now an optional peer dependency instead of a regular dependency. Every import from it is type-only (`import type { Logger }`), so it was never pulled in at runtime — pass any object matching the `Logger` shape (including `pino`) with no install required. Existing consumers of `logger?: Logger` are unaffected.
+`@zap-studio/logger` is now an optional peer dependency, not a regular one. Every import from it is type-only (`import type { Logger }`), so it was never loaded at runtime — you can pass any object with the `Logger` shape (including `pino`), with no install needed. If you already use `logger?: Logger`, nothing changes for you.
 
 ## [1.2.0]
 
 ### Added
 
-`runRetryPolicy(...)` gains an optional `logger?: Logger` option (from `@zap-studio/logger`). When provided, it logs each retry decision at `debug` (attempt, delay, reason), exhaustion at `warn`, and cancellation at `debug`. Omitting it keeps zero logging overhead. See [Logging](https://www.zapstudio.dev/retry/logging).
+`runRetryPolicy(...)` now takes an optional `logger?: Logger` option (from `@zap-studio/logger`). If you pass it, it logs each retry decision at `debug` level (attempt, delay, reason), exhaustion at `warn`, and cancellation at `debug`. If you don't pass it, there is no extra logging cost. See [Logging](https://www.zapstudio.dev/retry/logging).
 
 ## [1.1.0]
 
 ### Added
 
-`exponentialBackoff(...)` and `linearBackoff(...)` gain an optional `jitter?: "full" | "equal" | JitterOptions` option, applied to the computed delay after it's capped at `maxDelayMs`. `"full"` randomizes across `[0, delayMs]`; `"equal"` keeps a floor at half the delay, randomizing across `[delayMs/2, delayMs]`. Pass `{ mode, random }` to override the random source, useful for deterministic tests.
+`exponentialBackoff(...)` and `linearBackoff(...)` now take an optional `jitter?: "full" | "equal" | JitterOptions` option. It changes the delay after the delay is capped at `maxDelayMs`. `"full"` picks a random value in `[0, delayMs]`. `"equal"` keeps at least half the delay, and picks a random value in `[delayMs/2, delayMs]`. Pass `{ mode, random }` to use your own random source — useful for tests that need the same result every time.
 
 New export: `applyJitter(delayMs, jitter?)`, also available from the `./jitter` subpath. See [Jitter](https://www.zapstudio.dev/retry/jitter).
 
@@ -44,44 +57,44 @@ New export: `applyJitter(delayMs, jitter?)`, also available from the `./jitter`
 
 ### Added
 
-`RetryPolicy` gains an optional `isKnownError?: (error: unknown) => error is TError` hook that `BaseRetryPolicy.run(...)` now calls before handing a caught value to `next(...)`/`onExhausted(...)`. `BaseRetryPolicy.isKnownError` default checks `error instanceof Error`.
+`RetryPolicy` now has an optional `isKnownError?: (error: unknown) => error is TError` hook. `BaseRetryPolicy.run(...)` calls it before it hands a caught value to `next(...)`/`onExhausted(...)`. By default, `BaseRetryPolicy.isKnownError` checks `error instanceof Error`.
 
-- Override `isKnownError` when `TError` is a narrower subclass (an HTTP error, a domain-specific error) to get real narrowing instead of an `instanceof Error` assumption, and to stop unrelated `Error` types from being retried as if they belonged to your domain.
+- Override `isKnownError` when `TError` is a narrower subclass, like an HTTP error or a domain-specific error. This gives you real type narrowing, instead of just assuming `instanceof Error`, and stops unrelated `Error` types from being retried as if they belonged to your domain.
 
-See [Narrow the Error Domain](https://www.zapstudio.dev/retry/custom-policies#narrow-the-error-domain) for the override pattern.
+See [Narrow the Error Domain](https://www.zapstudio.dev/retry/custom-policies#narrow-the-error-domain) for how to override it.
 
-New built-in policy: `linearBackoff(options)` adds a fixed `incrementMs` to the delay after each failed attempt, capped at `maxDelayMs` — steadier growth than `exponentialBackoff`, more spacing than `fixedDelay`. See [linearBackoff](https://www.zapstudio.dev/retry/linear-backoff).
+New built-in policy: `linearBackoff(options)`. It adds a fixed `incrementMs` to the delay after each failed attempt, up to `maxDelayMs` — steadier growth than `exponentialBackoff`, bigger gaps than `fixedDelay`. See [linearBackoff](https://www.zapstudio.dev/retry/linear-backoff).
 
 ### Changed
 
-- **Breaking:** `TError` is now constrained to `TError extends Error` and defaults to `Error` (was `TError = unknown`) on `RetryPolicy`, `RetryDecisionInput`, `RetryExhaustedInput`, and `BaseRetryPolicy`.
-- **Breaking behavior change:** a rejection with a non-`Error` value (a thrown string, plain object, `undefined`, ...) now bypasses retry entirely on the attempt that produced it — it no longer reaches `next(...)`, and no delay/backoff is applied. Previously any thrown value was passed through to the policy unchanged. In throw mode, `run(...)` rethrows the value as-is; with `throwOnExhausted: false`, it's wrapped in a `RetryError` and returned on `result.error` — `run(...)` never throws in that mode.
-- **Breaking:** Policies are plain objects instead of classes, for tree-shaking — bundlers can drop an unused policy factory and its defaults entirely, which isn't possible across a shared class hierarchy. `ExponentialBackoff`/`FixedDelay` classes are replaced by `exponentialBackoff(options)`/`fixedDelay(options)` factory functions that return a `RetryPolicy`. Migrate `new ExponentialBackoff(opts)` to `exponentialBackoff(opts)`, and `new FixedDelay(opts)` to `fixedDelay(opts)`.
-- **Breaking:** `RetryPolicy.onExhausted` is now optional (previously required); omit it to use the same default `RetryError` that `BaseRetryPolicy.onExhausted` used to build.
+- **Breaking:** `TError` must now extend `Error`, and defaults to `Error` (before, it was `TError = unknown`). This applies to `RetryPolicy`, `RetryDecisionInput`, `RetryExhaustedInput`, and `BaseRetryPolicy`.
+- **Breaking behavior change:** if a rejection has a non-`Error` value (a thrown string, a plain object, `undefined`, and so on), that attempt now skips retry completely — it no longer reaches `next(...)`, and no delay or backoff is applied. Before, any thrown value went to the policy unchanged. In throw mode, `run(...)` now rethrows the value as-is. With `throwOnExhausted: false`, it wraps the value in a `RetryError` and returns it on `result.error` — `run(...)` never throws in that mode.
+- **Breaking:** Policies are now plain objects, not classes. This helps tree-shaking: a bundler can drop an unused policy factory and its defaults completely, which it could not do with a shared class hierarchy. `ExponentialBackoff`/`FixedDelay` classes are gone — use the `exponentialBackoff(options)`/`fixedDelay(options)` factory functions instead, both returning a `RetryPolicy`. Change `new ExponentialBackoff(opts)` to `exponentialBackoff(opts)`, and `new FixedDelay(opts)` to `fixedDelay(opts)`.
+- **Breaking:** `RetryPolicy.onExhausted` is now optional (before, it was required). Leave it out to get the same default `RetryError` that `BaseRetryPolicy.onExhausted` used to build.
 
 ### Removed
 
-- **Breaking:** `BaseRetryPolicy` is removed. Retry orchestration is now the standalone function `runRetryPolicy(policy, execute, options?)`, which accepts any object satisfying `RetryPolicy` — no subclassing required. Migrate `policy.run(execute, options)` to `runRetryPolicy(policy, execute, options)`. A custom policy that previously extended `BaseRetryPolicy` and overrode `next`/`onExhausted`/`isKnownError` becomes an object literal implementing the same members; see [Custom Policies](https://www.zapstudio.dev/retry/custom-policies).
+- **Breaking:** `BaseRetryPolicy` is removed. Retry runs now go through the standalone function `runRetryPolicy(policy, execute, options?)`, which accepts any object matching `RetryPolicy` — no subclass needed. Change `policy.run(execute, options)` to `runRetryPolicy(policy, execute, options)`. If your custom policy extended `BaseRetryPolicy` and overrode `next`/`onExhausted`/`isKnownError`, turn it into a plain object with the same members instead; see [Custom Policies](https://www.zapstudio.dev/retry/custom-policies).
 
 ### Removed
 
-Collapsed abort/sleep orchestration internals out of the public API.
+Moved abort/sleep internals out of the public API.
 
 - Removed the `./abort` and `./sleep` subpath exports.
-- Removed the public `sleepWithAbortSignal`, `throwIfAborted`, and `toAbortError` exports — they were orchestration internals with no consumer outside the retry loop, not standalone utilities.
-- `defaultSleep` is unaffected and still exported from `@zap-studio/retry` (no dedicated subpath).
+- Removed the public `sleepWithAbortSignal`, `throwIfAborted`, and `toAbortError` exports — they were internal parts of the retry loop, not standalone tools, and nothing outside the retry loop used them.
+- `defaultSleep` is not affected. It is still exported from `@zap-studio/retry` (no separate subpath).
 
 ## [0.3.2]
 
 ### Added
 
-The package root now re-exports the full public API, so everything can be imported from `@zap-studio/retry` directly (`BaseRetryPolicy`, `ExponentialBackoff`, `FixedDelay`, `RetryError`, `AbortError`, abort helpers, `defaultSleep`, and all public types). All exports are side-effect free and tree-shakeable; granular subpath imports keep working.
+The package root now re-exports the full public API, so you can import everything straight from `@zap-studio/retry` (`BaseRetryPolicy`, `ExponentialBackoff`, `FixedDelay`, `RetryError`, `AbortError`, abort helpers, `defaultSleep`, and all public types). Every export has no side effects and supports tree-shaking; the smaller subpath imports still work too.
 
-- `BaseRetryPolicy` moved from the entrypoint into its own module, available as the new `./base-policy` subpath.
+- `BaseRetryPolicy` moved out of the main entrypoint. It now has its own module, at the new `./base-policy` subpath.
 
 ### Removed
 
-- Removed the `./result-mode` and `./throw-mode` subpath exports. Both were orchestration internals (`runResultMode`, `runThrowMode`) and are no longer part of the public API.
+- Removed the `./result-mode` and `./throw-mode` subpath exports. Both held internal code (`runResultMode`, `runThrowMode`) that is no longer part of the public API.
 
 ## [0.3.1]
 
@@ -93,32 +106,32 @@ Internal formatting and lint cleanup only. No public API or behavior change.
 
 ### Changed
 
-- **Breaking:** Subpath for error types: use `@zap-studio/retry/errors` (plural) for `RetryError`, `AbortError`, and related types. A prior JSR `error` subpath that pointed at a non-existent `error.ts` entry is removed; update deep imports from `@zap-studio/retry/error` to `@zap-studio/retry/errors`.
-- Add dedicated `AbortError` and normalize cancellation paths so retry internals throw/return `RetryError` or `AbortError` instead of plain `Error`.
-- Expose `defaultSleep` from the `@zap-studio/retry/sleep` subpath only (the main entry does not re-export it; `run` still uses it internally when `sleep` is omitted).
-- Align non-throw exhaustion metadata so `result.attempts` and `result.error.attempts` stay consistent for `RetryError` outcomes.
-- In non-throw mode, return a normalized `AbortError` on `result.error` for cancellation; `result.attempts` still reports completed attempts.
-- Refactor result-mode internals into smaller helpers for lower complexity and cleaner maintainability.
-- Expand docs across README and package docs pages to explain `AbortError` behavior in throw and non-throw modes.
-- Split the retry runner into dedicated modules: `throw-mode` (throwing execution path), `result-mode` (non-throw `RetryRunResult` path), and `sleep` (the default `defaultSleep` implementation). `BaseRetryPolicy` in `index` now delegates to these modules without changing public behavior.
-- Add exhaustive TSDoc for `result-mode` and other `src` modules, including private helpers, policy option and state fields, and `RetryRunResult` union members.
-- Rework test layout into `sleep`, `throw-mode`, `result-mode`, and `index` test files with a shared `sequence-policy` fixture, replacing the prior combined `index` and `abort` test files.
+- **Breaking:** New subpath for error types: use `@zap-studio/retry/errors` (plural) for `RetryError`, `AbortError`, and related types. The old JSR `error` subpath pointed at an `error.ts` file that did not exist, so it is removed — change deep imports from `@zap-studio/retry/error` to `@zap-studio/retry/errors`.
+- Added a dedicated `AbortError` type. Cancellation is now consistent: retry internals throw or return `RetryError` or `AbortError`, not a plain `Error`.
+- `defaultSleep` is now only exposed from the `@zap-studio/retry/sleep` subpath — the main entry does not re-export it. `run` still uses it inside, when you don't pass your own `sleep`.
+- Made non-throw exhaustion data consistent: `result.attempts` and `result.error.attempts` now always match for `RetryError` outcomes.
+- In non-throw mode, cancellation now returns a normalized `AbortError` on `result.error`. `result.attempts` still shows the number of completed attempts.
+- Split the result-mode internals into smaller helper functions, to make the code simpler and easier to keep up.
+- Added more docs in the README and the package docs pages about `AbortError` behavior, in both throw and non-throw modes.
+- Split the retry runner into separate modules: `throw-mode` (the throwing path), `result-mode` (the non-throw `RetryRunResult` path), and `sleep` (the default `defaultSleep` code). `BaseRetryPolicy` in `index` now calls these modules, with no change in public behavior.
+- Added full TSDoc for `result-mode` and other `src` modules: private helpers, policy option and state fields, and every `RetryRunResult` union member.
+- Reworked the test layout into `sleep`, `throw-mode`, `result-mode`, and `index` test files, with one shared `sequence-policy` fixture, replacing the old combined `index` and `abort` test files.
 
 ## [0.2.0]
 
 ### Changed
 
-- Optimize retry runner hot paths by splitting throw/non-throw execution flows and skipping sleep calls when delay is non-positive.
-- Add `AbortSignal` support to `run(...)` so retry orchestration can be canceled before or between attempts.
-- Add retry benchmarking coverage with core and ecosystem scenarios, including real-world and fair-mode comparisons.
-- Add abort-focused ecosystem benchmarks comparing signal overhead and immediate cancellation behavior.
-- Expand TSDoc coverage for new runner internals added in this release.
+- Made the retry runner's hot paths faster: throw and non-throw modes now run separately, and a sleep call is skipped when the delay is zero or less.
+- Added `AbortSignal` support to `run(...)`, so you can cancel a retry before or between attempts.
+- Added retry benchmarks, with core and ecosystem scenarios, including real-world and fair-mode comparisons.
+- Added abort-focused benchmarks that compare signal overhead and instant cancellation.
+- Added more TSDoc for the new runner internals in this release.
 
 ## [0.1.2]
 
 ### Changed
 
-- Expand TSDoc coverage across retry modules and exported contracts for stronger JSR documentation completeness.
+- Added more TSDoc across retry modules and exported types, for more complete JSR docs.
 
 ## [0.1.1]
 
@@ -134,12 +147,12 @@ Internal formatting and lint cleanup only. No public API or behavior change.
 
 ### Added
 
-- Introduced a transport-agnostic `RetryPolicy` contract with `RetryDecisionInput` and `RetryDecision`.
-- Added required `onExhausted` hook to `RetryPolicy` for policy-specific terminal error shaping.
-- Added shared `BaseRetryPolicy` abstract class to centralize default `onExhausted` behavior.
-- Added `BaseRetryPolicy.run(execute, options)` runner method to execute retry policies with minimal boilerplate.
-- Added `throwOnExhausted` runner option with non-throw `RetryRunResult<T>` mode.
-- Added `ExponentialBackoff` policy with bounded exponential delay via `baseDelayMs`, `maxDelayMs`, and `maxAttempts`.
-- Added `FixedDelay` policy with constant delay and bounded attempts.
-- Added `RetryError` for exhausted-retry failures with structured attempt/error/data context.
-- Documented throwable behavior on `RetryPolicy`, `BaseRetryPolicy.run`, and related contracts with explicit `@throws` tags for policy, exhaustion, and custom `sleep` failures.
+- Added a transport-agnostic `RetryPolicy` contract, with `RetryDecisionInput` and `RetryDecision`.
+- Added a required `onExhausted` hook on `RetryPolicy`, so each policy can shape its own final error.
+- Added a shared `BaseRetryPolicy` abstract class, to hold the default `onExhausted` behavior in one place.
+- Added a `BaseRetryPolicy.run(execute, options)` method, to run a retry policy with little setup code.
+- Added a `throwOnExhausted` option, plus a non-throw `RetryRunResult<T>` mode.
+- Added an `ExponentialBackoff` policy. Its delay grows with `baseDelayMs`, up to `maxDelayMs`, and stops at `maxAttempts`.
+- Added a `FixedDelay` policy, with a fixed delay and a limited number of attempts.
+- Added `RetryError` for a failure after retries run out, holding the attempt count, the last error, and the last data.
+- Documented when `RetryPolicy`, `BaseRetryPolicy.run`, and related types throw, with `@throws` tags for policy errors, exhaustion, and custom `sleep` failures.

package/README.md

@@ -27,7 +27,6 @@ npm install @zap-studio/retry
 - **A shared runner** via `runRetryPolicy(policy, execute, options?)` with attempt-aware callbacks and custom sleep injection.
 - **Structured terminal errors**: `RetryError` on exhaustion, `AbortError` on cancellation.
 - **Non-throw mode** (`throwOnExhausted: false`) returns a `RetryRunResult` instead of throwing.
-- **`Result`-returning variant** via `runRetryPolicyResult(policy, execute, options?)`, for explicit error handling with [`@zap-studio/monads`](https://www.npmjs.com/package/@zap-studio/monads) instead of throw/catch.
 - **Cancellation** through `AbortSignal`, checked before, between, and during retries.
 - **Custom policies** as plain objects implementing `RetryPolicy` — just a `next(...)` function, no subclassing.
 - **Optional logging** via a `logger?: Logger` option ([`@zap-studio/logger`](https://www.npmjs.com/package/@zap-studio/logger)) — omit it and there's zero logging overhead.
@@ -135,25 +134,6 @@ if (!result.ok) {
 }
 ```
 
-## Result-Returning Variant
-
-`runRetryPolicyResult(policy, execute, options?)` — additive alternative to `runRetryPolicy` for consumers who prefer explicit [`Result`](https://www.zapstudio.dev/monads/result)/[`ResultAsync`](https://www.zapstudio.dev/monads/result-async) values over throw/catch. There's no `throwOnExhausted` option — it always returns a `Result`.
-
-```ts
-import { isOk } from "@zap-studio/monads";
-import { runRetryPolicyResult } from "@zap-studio/retry";
-
-const result = await runRetryPolicyResult(policy, execute);
-
-if (isOk(result)) {
-  console.log(result.value);
-} else {
-  console.error(result.error); // RetryError | AbortError, same as runRetryPolicy's throw mode
-}
-```
-
-For exhaustion and cancellation, `Err` contains the same `RetryError`/`AbortError` object `runRetryPolicy`'s throw mode would throw — `RetryError.attempts`/`lastError`/`lastData` and `AbortError.cause` are preserved. A value rejected by `policy.isKnownError` is instead wrapped in a new `RetryError`, because throw mode rethrows that value as-is.
-
 ## Cancellation
 
 Through `AbortSignal`, checked before, between, and during retries.
@@ -228,6 +208,23 @@ const policy = exponentialBackoff({ maxAttempts: 5, baseDelayMs: 100 });
 await runRetryPolicy(policy, execute);
 ```
 
+## Using with `@zap-studio/monads`
+
+This package has no dependency on `@zap-studio/monads` — nothing is added to your
+bundle unless you install it yourself. If you want a `Result` instead of throw/catch,
+wrap the call with `@zap-studio/monads`'s `fromPromise`, mapping the rejection into
+your error type:
+
+```ts
+import { fromPromise } from "@zap-studio/monads";
+import { runRetryPolicy } from "@zap-studio/retry";
+
+const result = fromPromise(
+  runRetryPolicy(policy, execute, { throwOnExhausted: true }),
+  (error) => error,
+);
+```
+
 ## Runtime Support
 
 | Runtime            | Minimum version                         |

package/dist/{base-policy-DkxBg9dh.js → base-policy-ROp4XL19.js}

@@ -1,9 +1,8 @@
 import { AbortError, RetryError } from "./errors.js";
 import { metrics, trace } from "@opentelemetry/api";
-import { ResultAsync, err, ok } from "@zap-studio/monads";
 //#region package.json
 var name = "@zap-studio/retry";
-var version = "2.1.0";
+var version = "2.1.2";
 //#endregion
 //#region src/_otel.ts
 /**
@@ -368,15 +367,6 @@ const defaultOnExhausted = (input) => new RetryError("Retry policy exhausted all
 */
 const defaultIsKnownError = (error) => error instanceof Error;
 /**
-* Applies `runRetryPolicy`/`runRetryPolicyResult`'s shared defaults
-* (`onExhausted`, `isKnownError`) to a caller-supplied `RetryPolicy`.
-*/
-const resolvePolicy = (policy) => ({
-	isKnownError: (error) => policy.isKnownError ? policy.isKnownError(error) : defaultIsKnownError(error),
-	next: (input) => policy.next(input),
-	onExhausted: (input) => policy.onExhausted ? policy.onExhausted(input) : defaultOnExhausted(input)
-});
-/**
 * Runs retry orchestration in non-throw mode.
 *
 * When `throwOnExhausted` is `false`, returns a discriminated result union.
@@ -401,54 +391,15 @@ const resolvePolicy = (policy) => ({
 async function runRetryPolicy(policy, execute, options = {}) {
 	const sleep = options.sleep ?? defaultSleep;
 	const { signal, logger } = options;
-	const resolvedPolicy = resolvePolicy(policy);
+	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);
 }
-/**
-* 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);
-* }
-* ```
-*/
-const runRetryPolicyResult = (policy, execute, options = {}) => new ResultAsync((async () => {
-	const sleep = options.sleep ?? defaultSleep;
-	const { signal, logger } = options;
-	const resolvedPolicy = resolvePolicy(policy);
-	const result = await runResultMode(resolvedPolicy, execute, sleep, signal, logger);
-	return result.ok ? ok(result.value) : err(result.error);
-})());
 //#endregion
-export { runRetryPolicy as n, runRetryPolicyResult as r, defaultSleep as t };
+export { runRetryPolicy as n, defaultSleep as t };
 
-//# sourceMappingURL=base-policy-DkxBg9dh.js.map
+//# sourceMappingURL=base-policy-ROp4XL19.js.map

package/dist/base-policy-ROp4XL19.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-policy-ROp4XL19.js","names":["pkg.name","pkg.version"],"sources":["../package.json","../src/_otel.ts","../src/base-policy.ts"],"sourcesContent":["","/**\n * Internal OpenTelemetry wiring for the retry package: the attempts counter.\n * Kept out of `base-policy.ts` so retry orchestration doesn't get tangled\n * with metrics concerns. Span events are added directly to whatever span is\n * already active (e.g. a caller's fetch span), so this package never\n * creates its own tracer.\n *\n * @module @zap-studio/retry/otel\n */\n\nimport { metrics } from \"@opentelemetry/api\";\n\nimport pkg from \"../package.json\" with { type: \"json\" };\n\n/**\n * Records one retry decision, tagged with `retry.decision: \"retry\" |\n * \"exhausted\"`.\n *\n * Resolves the meter and counter fresh on every call instead of caching\n * them at module scope: unlike `trace.getTracer()`, `metrics.getMeter()`\n * has no proxy indirection — a reference grabbed before an app registers\n * its `MeterProvider` (the common case, since ESM imports resolve before\n * the importing module's own SDK-bootstrap code runs) would stay a no-op\n * forever. Repeated `createCounter` calls with the same name are cheap and\n * idempotent, so this costs nothing meaningful.\n */\nexport const recordRetryAttempt = (decision: \"exhausted\" | \"retry\"): void => {\n  metrics\n    .getMeter(pkg.name, pkg.version)\n    .createCounter(\"retry.attempts\", {\n      description: \"Number of retry decisions made, tagged by outcome.\",\n    })\n    .add(1, { \"retry.decision\": decision });\n};\n","/**\n * Retry runner base class and shared orchestration implementation.\n *\n * @module @zap-studio/retry/base-policy\n */\n\nimport type { Logger } from \"@zap-studio/logger\";\n\nimport { trace } from \"@opentelemetry/api\";\n\nimport type {\n  ResolvedRetryPolicy,\n  RetryDecision,\n  RetryExhaustedInput,\n  RetryPolicy,\n  RetryRunOptions,\n  RetryRunResult,\n} from \"./types.ts\";\n\nimport { recordRetryAttempt } from \"./_otel.ts\";\nimport { AbortError, RetryError } from \"./errors.ts\";\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  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 * @param logger - Optional logger; logs the abort at `debug` before throwing.\n * @throws {AbortError} When the signal is aborted.\n */\nconst throwIfAborted = (signal?: AbortSignal, logger?: Logger): void => {\n  if (signal?.aborted !== true) {\n    return;\n  }\n\n  logger?.debug(\"retry aborted\", { reason: signal.reason });\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      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 * Logs a `next(...)` decision: `debug` when retrying, `warn` when exhausted.\n * Shared by both the throw-mode and non-throw retry loops.\n */\nconst logRetryDecision = (\n  logger: Logger | undefined,\n  attempt: number,\n  decision: RetryDecision,\n  error: unknown,\n): void => {\n  if (decision.shouldRetry) {\n    logger?.debug(\"retry scheduled\", {\n      attempt,\n      delayMs: decision.delayMs,\n      reason: decision.reason,\n    });\n    trace.getActiveSpan()?.addEvent(\"retry.scheduled\", {\n      attempt,\n      \"retry.delay_ms\": decision.delayMs,\n      \"retry.reason\": decision.reason ?? \"\",\n    });\n    recordRetryAttempt(\"retry\");\n    return;\n  }\n\n  logger?.warn(\"retry policy exhausted\", {\n    attempts: attempt,\n    error,\n    reason: decision.reason,\n  });\n  trace.getActiveSpan()?.addEvent(\"retry.exhausted\", {\n    attempt,\n    \"retry.reason\": decision.reason ?? \"\",\n  });\n  recordRetryAttempt(\"exhausted\");\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 * @param logger - Optional logger; logs each retry decision at `debug` and\n *   exhaustion at `warn`.\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  logger?: Logger,\n): Promise<T> => {\n  let attempt = 1;\n\n  while (true) {\n    throwIfAborted(signal, logger);\n\n    try {\n      return await execute(attempt);\n    } catch (error) {\n      throwIfAborted(signal, logger);\n\n      if (!policy.isKnownError(error)) {\n        throw error;\n      }\n\n      await handleThrowModeRetry(policy, { attempt, error, logger, signal, sleep });\n      attempt += 1;\n    }\n  }\n};\n\n/**\n * After a failed, known-domain attempt in throw mode, applies the policy's\n * retry decision: throws the terminal error from `onExhausted` on\n * exhaustion, otherwise waits out the retry delay so the caller's loop can\n * continue.\n *\n * @param policy - Resolved retry policy providing `next` and `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, already known to the policy's domain.\n * @param params.sleep - Delay function between retries.\n * @param params.signal - Optional abort signal.\n * @param params.logger - Optional logger; logs each retry decision at `debug`\n *   and exhaustion at `warn`.\n * @throws {RetryError} When retries are exhausted and `onExhausted` returns\n *   the terminal error.\n * @throws {AbortError} When `signal` aborts while waiting for the retry delay.\n * @throws {Error} Any error thrown by `next`, `onExhausted`, or `sleep`.\n */\nconst handleThrowModeRetry = 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    logger: Logger | undefined;\n  },\n): Promise<void> => {\n  const { attempt, error, sleep, signal, logger } = params;\n  const decision = policy.next({\n    attempt,\n    error,\n  });\n  logRetryDecision(logger, attempt, decision, error);\n\n  if (!decision.shouldRetry) {\n    throw policy.onExhausted({\n      attempts: attempt,\n      error,\n    });\n  }\n\n  if (decision.delayMs > 0) {\n    await (signal === undefined\n      ? sleep(decision.delayMs)\n      : sleepWithAbortSignal(sleep, decision.delayMs, signal));\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 * @param logger - Optional logger; logs the abort at `debug`.\n * @returns Failure result or `undefined` if not aborted.\n */\nconst buildAbortResult = (\n  signal: AbortSignal | undefined,\n  attempts: number,\n  logger?: Logger,\n): RetryRunResult<never> | undefined => {\n  if (signal?.aborted !== true) {\n    return undefined;\n  }\n\n  logger?.debug(\"retry aborted\", { reason: signal.reason });\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 * @param logger - Optional logger; logs an abort ending the wait at `debug`.\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  logger?: Logger,\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, logger);\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 * @param params.logger - Optional logger; logs each retry decision at\n *   `debug`, exhaustion at `warn`, and cancellation at `debug`.\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    logger: Logger | undefined;\n  },\n): Promise<RetryRunResult<never> | undefined> => {\n  const { attempt, error, sleep, signal, logger } = params;\n  const abortResult = buildAbortResult(signal, attempt, logger);\n  if (abortResult !== undefined) {\n    return abortResult;\n  }\n\n  const decision = policy.next({\n    attempt,\n    error,\n  });\n  logRetryDecision(logger, attempt, decision, error);\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(sleep, decision.delayMs, signal, attempt, logger);\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 * @param logger - Optional logger; logs each retry decision at `debug`,\n *   exhaustion at `warn`, and cancellation at `debug`.\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  logger?: Logger,\n): Promise<RetryRunResult<T>> => {\n  let attempt = 1;\n\n  while (true) {\n    const abortResult = buildAbortResult(signal, Math.max(0, attempt - 1), logger);\n    if (abortResult !== undefined) {\n      return abortResult;\n    }\n\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, logger);\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    const failure = await handleFailure(policy, {\n      attempt,\n      error: execution.error,\n      logger,\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 */\nconst defaultIsKnownError = <TError extends Error>(error: unknown): error is TError =>\n  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<T, TError extends Error = Error, TData = unknown>(\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<T, TError extends Error = Error, TData = unknown>(\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<T, TError extends Error = Error, TData = unknown>(\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, logger } = options;\n  const resolvedPolicy: ResolvedRetryPolicy<TError, TData> = {\n    isKnownError: (error): error is TError =>\n      policy.isKnownError ? policy.isKnownError(error) : defaultIsKnownError(error),\n    next: (input) => policy.next(input),\n    onExhausted: (input) =>\n      policy.onExhausted ? policy.onExhausted(input) : defaultOnExhausted(input),\n  };\n\n  if (options.throwOnExhausted === false) {\n    return await runResultMode(resolvedPolicy, execute, sleep, signal, logger);\n  }\n\n  return await runThrowMode(resolvedPolicy, execute, sleep, signal, logger);\n}\n"],"mappings":"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"}

package/dist/base-policy.d.ts

@@ -1,6 +1,4 @@
-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";
+import { RetryPolicy, RetryRunOptions, RetryRunResult } from "./types.js";
 //#region src/base-policy.d.ts
 /**
  * Awaits a timer-based delay, unless `delayMs` is non-positive.
@@ -15,7 +13,7 @@ import { ResultAsync } from "@zap-studio/monads";
  * await defaultSleep(250); // waits 250ms
  * ```
  */
-declare const defaultSleep: (delayMs: number) => Promise<void>;
+export declare const defaultSleep: (delayMs: number) => Promise<void>;
 /**
  * Runs retry orchestration in non-throw mode.
  *
@@ -28,7 +26,7 @@ declare const defaultSleep: (delayMs: number) => Promise<void>;
  *   `RetryError` and returned as the terminal failure instead of thrown.
  * @throws {Error} Any error thrown by `next`, `onExhausted`, or a custom `sleep`.
  */
-declare function runRetryPolicy<T, TError extends Error = Error, TData = unknown>(policy: RetryPolicy<TError, TData>, execute: (attempt: number) => Promise<T>, options: RetryRunOptions & {
+export declare function runRetryPolicy<T, TError extends Error = Error, TData = unknown>(policy: RetryPolicy<TError, TData>, execute: (attempt: number) => Promise<T>, options: RetryRunOptions & {
   throwOnExhausted: false;
 }): Promise<RetryRunResult<T>>;
 /**
@@ -61,46 +59,8 @@ declare function runRetryPolicy<T, TError extends Error = Error, TData = unknown
  * const data = await runRetryPolicy(linearBackoff, async () => fetchFlakyResource());
  * ```
  */
-declare function runRetryPolicy<T, TError extends Error = Error, TData = unknown>(policy: RetryPolicy<TError, TData>, execute: (attempt: number) => Promise<T>, options?: RetryRunOptions & {
+export 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, 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":";;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"base-policy.d.ts","names":[],"sources":["../src/base-policy.ts"],"mappings":";;;;;;;;;;;;;;;qBAmCa,eAAsB,oBAAkB;;;;;;;;;;;;;wBA0drC,eAAe,GAAG,eAAe,QAAQ,OAAO,iBAC9D,QAAQ,YAAY,QAAQ,QAC5B,UAAU,oBAAoB,QAAQ,IACtC,SAAS;EAAoB;IAC5B,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgCV,eAAe,GAAG,eAAe,QAAQ,OAAO,iBAC9D,QAAQ,YAAY,QAAQ,QAC5B,UAAU,oBAAoB,QAAQ,IACtC,UAAU;EAAoB;IAC7B,QAAQ"}

package/dist/base-policy.js

@@ -1,3 +1,3 @@
-import { n as runRetryPolicy, r as runRetryPolicyResult, t as defaultSleep } from "./base-policy-DkxBg9dh.js";
+import { n as runRetryPolicy, t as defaultSleep } from "./base-policy-ROp4XL19.js";
 import "./errors.js";
-export { defaultSleep, runRetryPolicy, runRetryPolicyResult };
+export { defaultSleep, runRetryPolicy };

package/dist/exponential-backoff.d.ts

@@ -12,7 +12,7 @@ import { JitterMode, JitterOptions } from "./jitter.js";
  *   jitter: "full",
  * };
  */
-interface ExponentialBackoffOptions {
+export interface ExponentialBackoffOptions {
   /**
    * Maximum number of attempts (including the first) before giving up.
    */
@@ -41,7 +41,6 @@ interface ExponentialBackoffOptions {
  *   maxDelayMs: 2_000,
  * });
  */
-declare const exponentialBackoff: (options: ExponentialBackoffOptions) => RetryPolicy;
+export declare const exponentialBackoff: (options: ExponentialBackoffOptions) => RetryPolicy;
 //#endregion
-export { ExponentialBackoffOptions, exponentialBackoff };
 //# sourceMappingURL=exponential-backoff.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"exponential-backoff.d.ts","names":[],"sources":["../src/exponential-backoff.ts"],"mappings":";;;;;;;;;;;;;;iBAsBiB;;;;EAIf;;;;EAIA;;;;EAIA;;;;;EAKA,SAAS,aAAa;;;;;;;;;;;;qBAaX,qBAAsB,SAAS,8BAA4B"}

package/dist/fixed-delay.d.ts

@@ -6,7 +6,7 @@ import { RetryPolicy } from "./types.js";
  * @example
  * const options: FixedDelayOptions = { maxAttempts: 3, delayMs: 250 };
  */
-interface FixedDelayOptions {
+export interface FixedDelayOptions {
   /**
    * Maximum number of attempts (including the first) before giving up.
    */
@@ -25,7 +25,6 @@ interface FixedDelayOptions {
  *   delayMs: 250,
  * });
  */
-declare const fixedDelay: (options: FixedDelayOptions) => RetryPolicy;
+export declare const fixedDelay: (options: FixedDelayOptions) => RetryPolicy;
 //#endregion
-export { FixedDelayOptions, fixedDelay };
 //# sourceMappingURL=fixed-delay.d.ts.map

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

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

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, RetryRunResultOptions } from "./types.js";
-import { defaultSleep, runRetryPolicy, runRetryPolicyResult } from "./base-policy.js";
+import { RetryDecision, RetryDecisionInput, RetryExhaustedInput, RetryPolicy, RetryRunOptions, RetryRunResult } from "./types.js";
+import { defaultSleep, runRetryPolicy } 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, type RetryRunResultOptions, applyJitter, defaultSleep, exponentialBackoff, fixedDelay, linearBackoff, runRetryPolicy, runRetryPolicyResult };
+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 };

package/dist/index.js

@@ -1,7 +1,7 @@
-import { n as runRetryPolicy, r as runRetryPolicyResult, t as defaultSleep } from "./base-policy-DkxBg9dh.js";
+import { n as runRetryPolicy, t as defaultSleep } from "./base-policy-ROp4XL19.js";
 import { AbortError, RetryError } from "./errors.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, runRetryPolicyResult };
+export { AbortError, RetryError, applyJitter, defaultSleep, exponentialBackoff, fixedDelay, linearBackoff, runRetryPolicy };

package/dist/jitter.d.ts

@@ -12,14 +12,14 @@
  * - `"equal"`: `delayMs/2 + random(0, delayMs/2)` — keeps a floor at half
  *   the computed delay, less spread than full jitter.
  */
-type JitterMode = "equal" | "full";
+export type JitterMode = "equal" | "full";
 /**
  * Configuration for jitter application.
  *
  * @example
  * const jitter: JitterOptions = { mode: "full" };
  */
-interface JitterOptions {
+export interface JitterOptions {
   /**
    * Jitter strategy to apply.
    */
@@ -42,7 +42,6 @@ interface JitterOptions {
  * @example
  * const delayMs = applyJitter(1000, "full"); // 0-1000
  */
-declare const applyJitter: (delayMs: number, jitter?: JitterMode | JitterOptions) => number;
+export declare const applyJitter: (delayMs: number, jitter?: JitterMode | JitterOptions) => number;
 //#endregion
-export { JitterMode, JitterOptions, applyJitter };
 //# sourceMappingURL=jitter.d.ts.map

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,cAAe,iBAAiB,SAAS,aAAa"}
+{"version":3,"file":"jitter.d.ts","names":[],"sources":["../src/jitter.ts"],"mappings":";;;;;;;;;;;;;;YAcY;;;;;;;iBAQK;;;;EAIf,MAAM;;;;;;EAMN;;;;;;;;;;;;;qBAcW,cAAe,iBAAiB,SAAS,aAAa"}

package/dist/linear-backoff.d.ts

@@ -13,7 +13,7 @@ import { JitterMode, JitterOptions } from "./jitter.js";
  *   jitter: "equal",
  * };
  */
-interface LinearBackoffOptions {
+export interface LinearBackoffOptions {
   /**
    * Maximum number of attempts (including the first) before giving up.
    */
@@ -47,7 +47,6 @@ interface LinearBackoffOptions {
  *   maxDelayMs: 2_000,
  * });
  */
-declare const linearBackoff: (options: LinearBackoffOptions) => RetryPolicy;
+export declare const linearBackoff: (options: LinearBackoffOptions) => RetryPolicy;
 //#endregion
-export { LinearBackoffOptions, linearBackoff };
 //# sourceMappingURL=linear-backoff.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"linear-backoff.d.ts","names":[],"sources":["../src/linear-backoff.ts"],"mappings":";;;;;;;;;;;;;;;iBAuBiB;;;;EAIf;;;;EAIA;;;;EAIA;;;;EAIA;;;;;EAKA,SAAS,aAAa;;;;;;;;;;;;;qBAcX,gBAAiB,SAAS,yBAAuB"}

package/dist/types.d.ts

@@ -14,7 +14,7 @@ import { Logger } from "@zap-studio/logger";
  *   onExhausted: ({ attempts }) => new RetryError("done", { attempts }),
  * };
  */
-interface RetryPolicy<TError extends Error = Error, TData = unknown> {
+export interface RetryPolicy<TError extends Error = Error, TData = unknown> {
   /**
    * Returns the retry decision for a failed attempt.
    *
@@ -47,7 +47,7 @@ interface RetryPolicy<TError extends Error = Error, TData = unknown> {
  * `RetryPolicy` with `onExhausted` and `isKnownError` resolved to concrete
  * functions, used internally once `runRetryPolicy` has applied defaults.
  */
-interface ResolvedRetryPolicy<TError extends Error, TData> {
+export interface ResolvedRetryPolicy<TError extends Error, TData> {
   /**
    * Returns the retry decision for a failed attempt.
    */
@@ -69,7 +69,7 @@ interface ResolvedRetryPolicy<TError extends Error, TData> {
  * @example
  * const decision: RetryDecision = { shouldRetry: true, delayMs: 200, reason: "retry" };
  */
-interface RetryDecision {
+export interface RetryDecision {
   /**
    * When `true`, the runner may schedule another attempt (subject to
    * `delayMs` and the runner's abort rules).
@@ -90,7 +90,7 @@ interface RetryDecision {
  * @example
  * const input: RetryDecisionInput = { attempt: 2, error: new Error("timeout") };
  */
-interface RetryDecisionInput<TError extends Error = Error, TData = unknown> {
+export interface RetryDecisionInput<TError extends Error = Error, TData = unknown> {
   /**
    * One-based attempt number for the current failure.
    */
@@ -117,7 +117,7 @@ interface RetryDecisionInput<TError extends Error = Error, TData = unknown> {
  * @example
  * const input: RetryExhaustedInput = { attempts: 5, error: new Error("timeout") };
  */
-interface RetryExhaustedInput<TError extends Error = Error, TData = unknown> {
+export interface RetryExhaustedInput<TError extends Error = Error, TData = unknown> {
   /**
    * Count of completed attempts that led to stopping retries.
    */
@@ -137,7 +137,7 @@ interface RetryExhaustedInput<TError extends Error = Error, TData = unknown> {
  * @example
  * const options: RetryRunOptions = { throwOnExhausted: false, signal: controller.signal };
  */
-interface RetryRunOptions {
+export interface RetryRunOptions {
   /**
    * Delay function used between retry attempts.
    *
@@ -166,17 +166,6 @@ 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.
  *
@@ -188,7 +177,7 @@ type RetryRunResultOptions = Omit<RetryRunOptions, "throwOnExhausted">;
  * const result: RetryRunResult<string> = await runRetryPolicy(policy, doWork, { throwOnExhausted: false });
  * if (!result.ok) console.error(result.error);
  */
-type RetryRunResult<T> = {
+export type RetryRunResult<T> = {
   /**
    * Discriminator for a successful run.
    */
@@ -213,5 +202,4 @@ type RetryRunResult<T> = {
   attempts: number;
 };
 //#endregion
-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,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"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;;;iBAuBiB,YAAY,eAAe,QAAQ,OAAO;;;;;;EAMzD,OAAO,OAAO,mBAAmB,QAAQ,WAAW;;;;;;;;EAQpD,eAAe,OAAO,oBAAoB,QAAQ,WAAW;;;;;;;;;;;;;EAa7D,gBAAgB,mBAAmB,SAAS;;;;;;iBAO7B,oBAAoB,eAAe,OAAO;;;;EAIzD,MAAM,YAAY,QAAQ;;;;;EAK1B,cAAc,OAAO,oBAAoB,QAAQ,WAAW;;;;;EAK5D,eAAe,mBAAmB,SAAS;;;;;;;;iBAS5B;;;;;WAKN;;;;WAIA;;;;WAIA;;;;;;;;iBASM,mBAAmB,eAAe,QAAQ,OAAO;;;;WAIvD;;;;;WAKA;;;;;WAKA,QAAQ;;;;;WAKR,OAAO;;;;;;;;iBASD,oBAAoB,eAAe,QAAQ,OAAO;;;;WAIxD;;;;WAIA,QAAQ;;;;WAIR,OAAO;;;;;;;;iBASD;;;;;;WAMN,SAAS,oBAAoB;;;;;;WAM7B,SAAS;;;;;;;;WAQT;;;;;;;WAOA,SAAS;;;;;;;;;;;;;YAcR,eAAe;;;;EAKrB;;;;EAIA,OAAO;;;;;EAMP;;;;;EAKA,OAAO,aAAa;;;;EAIpB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-studio/retry",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "private": false,
   "description": "Composable, tree-shakeable retry policies for resilient async operations.",
   "keywords": [
@@ -43,23 +43,20 @@
   "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",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/context-async-hooks": "^2.11.0",
+    "@opentelemetry/sdk-metrics": "^2.11.0",
+    "@opentelemetry/sdk-trace-base": "^2.11.0",
+    "@zap-studio/logger": "2.1.0",
     "@zap-studio/typescript": "0.0.0",
-    "@zap-studio/logger": "2.0.0"
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
   },
   "peerDependencies": {
-    "@opentelemetry/api": "^1.9.0",
-    "@zap-studio/logger": "2.0.0"
+    "@opentelemetry/api": "^1.9.1",
+    "@zap-studio/logger": "^2.1.0"
   },
   "peerDependenciesMeta": {
     "@zap-studio/logger": {
@@ -68,5 +65,6 @@
   },
   "engines": {
     "node": ">=18.0.0"
-  }
+  },
+  "scripts": {}
 }

package/dist/base-policy-DkxBg9dh.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-policy-DkxBg9dh.js","names":["pkg.name","pkg.version"],"sources":["../package.json","../src/_otel.ts","../src/base-policy.ts"],"sourcesContent":["","/**\n * Internal OpenTelemetry wiring for the retry package: the attempts counter.\n * Kept out of `base-policy.ts` so retry orchestration doesn't get tangled\n * with metrics concerns. Span events are added directly to whatever span is\n * already active (e.g. a caller's fetch span), so this package never\n * creates its own tracer.\n *\n * @module @zap-studio/retry/otel\n */\n\nimport { metrics } from \"@opentelemetry/api\";\n\nimport pkg from \"../package.json\" with { type: \"json\" };\n\n/**\n * Records one retry decision, tagged with `retry.decision: \"retry\" |\n * \"exhausted\"`.\n *\n * Resolves the meter and counter fresh on every call instead of caching\n * them at module scope: unlike `trace.getTracer()`, `metrics.getMeter()`\n * has no proxy indirection — a reference grabbed before an app registers\n * its `MeterProvider` (the common case, since ESM imports resolve before\n * the importing module's own SDK-bootstrap code runs) would stay a no-op\n * forever. Repeated `createCounter` calls with the same name are cheap and\n * idempotent, so this costs nothing meaningful.\n */\nexport const recordRetryAttempt = (decision: \"exhausted\" | \"retry\"): void => {\n  metrics\n    .getMeter(pkg.name, pkg.version)\n    .createCounter(\"retry.attempts\", {\n      description: \"Number of retry decisions made, tagged by outcome.\",\n    })\n    .add(1, { \"retry.decision\": decision });\n};\n","/**\n * Retry runner base class and shared orchestration implementation.\n *\n * @module @zap-studio/retry/base-policy\n */\n\nimport type { Logger } from \"@zap-studio/logger\";\nimport type { Result } from \"@zap-studio/monads\";\n\nimport { trace } from \"@opentelemetry/api\";\nimport { err, ok, ResultAsync } from \"@zap-studio/monads\";\n\nimport type {\n  ResolvedRetryPolicy,\n  RetryDecision,\n  RetryExhaustedInput,\n  RetryPolicy,\n  RetryRunOptions,\n  RetryRunResult,\n  RetryRunResultOptions,\n} from \"./types.ts\";\n\nimport { recordRetryAttempt } from \"./_otel.ts\";\nimport { AbortError, RetryError } from \"./errors.ts\";\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  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 * @param logger - Optional logger; logs the abort at `debug` before throwing.\n * @throws {AbortError} When the signal is aborted.\n */\nconst throwIfAborted = (signal?: AbortSignal, logger?: Logger): void => {\n  if (signal?.aborted !== true) {\n    return;\n  }\n\n  logger?.debug(\"retry aborted\", { reason: signal.reason });\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      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 * Logs a `next(...)` decision: `debug` when retrying, `warn` when exhausted.\n * Shared by both the throw-mode and non-throw retry loops.\n */\nconst logRetryDecision = (\n  logger: Logger | undefined,\n  attempt: number,\n  decision: RetryDecision,\n  error: unknown,\n): void => {\n  if (decision.shouldRetry) {\n    logger?.debug(\"retry scheduled\", {\n      attempt,\n      delayMs: decision.delayMs,\n      reason: decision.reason,\n    });\n    trace.getActiveSpan()?.addEvent(\"retry.scheduled\", {\n      attempt,\n      \"retry.delay_ms\": decision.delayMs,\n      \"retry.reason\": decision.reason ?? \"\",\n    });\n    recordRetryAttempt(\"retry\");\n    return;\n  }\n\n  logger?.warn(\"retry policy exhausted\", {\n    attempts: attempt,\n    error,\n    reason: decision.reason,\n  });\n  trace.getActiveSpan()?.addEvent(\"retry.exhausted\", {\n    attempt,\n    \"retry.reason\": decision.reason ?? \"\",\n  });\n  recordRetryAttempt(\"exhausted\");\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 * @param logger - Optional logger; logs each retry decision at `debug` and\n *   exhaustion at `warn`.\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  logger?: Logger,\n): Promise<T> => {\n  let attempt = 1;\n\n  while (true) {\n    throwIfAborted(signal, logger);\n\n    try {\n      return await execute(attempt);\n    } catch (error) {\n      throwIfAborted(signal, logger);\n\n      if (!policy.isKnownError(error)) {\n        throw error;\n      }\n\n      await handleThrowModeRetry(policy, { attempt, error, logger, signal, sleep });\n      attempt += 1;\n    }\n  }\n};\n\n/**\n * After a failed, known-domain attempt in throw mode, applies the policy's\n * retry decision: throws the terminal error from `onExhausted` on\n * exhaustion, otherwise waits out the retry delay so the caller's loop can\n * continue.\n *\n * @param policy - Resolved retry policy providing `next` and `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, already known to the policy's domain.\n * @param params.sleep - Delay function between retries.\n * @param params.signal - Optional abort signal.\n * @param params.logger - Optional logger; logs each retry decision at `debug`\n *   and exhaustion at `warn`.\n * @throws {RetryError} When retries are exhausted and `onExhausted` returns\n *   the terminal error.\n * @throws {AbortError} When `signal` aborts while waiting for the retry delay.\n * @throws {Error} Any error thrown by `next`, `onExhausted`, or `sleep`.\n */\nconst handleThrowModeRetry = 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    logger: Logger | undefined;\n  },\n): Promise<void> => {\n  const { attempt, error, sleep, signal, logger } = params;\n  const decision = policy.next({\n    attempt,\n    error,\n  });\n  logRetryDecision(logger, attempt, decision, error);\n\n  if (!decision.shouldRetry) {\n    throw policy.onExhausted({\n      attempts: attempt,\n      error,\n    });\n  }\n\n  if (decision.delayMs > 0) {\n    await (signal === undefined\n      ? sleep(decision.delayMs)\n      : sleepWithAbortSignal(sleep, decision.delayMs, signal));\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 * @param logger - Optional logger; logs the abort at `debug`.\n * @returns Failure result or `undefined` if not aborted.\n */\nconst buildAbortResult = (\n  signal: AbortSignal | undefined,\n  attempts: number,\n  logger?: Logger,\n): RetryRunResult<never> | undefined => {\n  if (signal?.aborted !== true) {\n    return undefined;\n  }\n\n  logger?.debug(\"retry aborted\", { reason: signal.reason });\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 * @param logger - Optional logger; logs an abort ending the wait at `debug`.\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  logger?: Logger,\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, logger);\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 * @param params.logger - Optional logger; logs each retry decision at\n *   `debug`, exhaustion at `warn`, and cancellation at `debug`.\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    logger: Logger | undefined;\n  },\n): Promise<RetryRunResult<never> | undefined> => {\n  const { attempt, error, sleep, signal, logger } = params;\n  const abortResult = buildAbortResult(signal, attempt, logger);\n  if (abortResult !== undefined) {\n    return abortResult;\n  }\n\n  const decision = policy.next({\n    attempt,\n    error,\n  });\n  logRetryDecision(logger, attempt, decision, error);\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(sleep, decision.delayMs, signal, attempt, logger);\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 * @param logger - Optional logger; logs each retry decision at `debug`,\n *   exhaustion at `warn`, and cancellation at `debug`.\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  logger?: Logger,\n): Promise<RetryRunResult<T>> => {\n  let attempt = 1;\n\n  while (true) {\n    const abortResult = buildAbortResult(signal, Math.max(0, attempt - 1), logger);\n    if (abortResult !== undefined) {\n      return abortResult;\n    }\n\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, logger);\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    const failure = await handleFailure(policy, {\n      attempt,\n      error: execution.error,\n      logger,\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 */\nconst defaultIsKnownError = <TError extends Error>(error: unknown): error is TError =>\n  error instanceof Error;\n\n/**\n * Applies `runRetryPolicy`/`runRetryPolicyResult`'s shared defaults\n * (`onExhausted`, `isKnownError`) to a caller-supplied `RetryPolicy`.\n */\nconst resolvePolicy = <TError extends Error, TData>(\n  policy: RetryPolicy<TError, TData>,\n): ResolvedRetryPolicy<TError, TData> => ({\n  isKnownError: (error): error is TError =>\n    policy.isKnownError ? policy.isKnownError(error) : defaultIsKnownError(error),\n  next: (input) => policy.next(input),\n  onExhausted: (input) =>\n    policy.onExhausted ? policy.onExhausted(input) : defaultOnExhausted(input),\n});\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<T, TError extends Error = Error, TData = unknown>(\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<T, TError extends Error = Error, TData = unknown>(\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<T, TError extends Error = Error, TData = unknown>(\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, logger } = options;\n  const resolvedPolicy = resolvePolicy(policy);\n\n  if (options.throwOnExhausted === false) {\n    return await runResultMode(resolvedPolicy, execute, sleep, signal, logger);\n  }\n\n  return await runThrowMode(resolvedPolicy, execute, sleep, signal, logger);\n}\n\n/**\n * Runs retry orchestration, returning a `ResultAsync` instead of throwing or\n * returning the hand-rolled {@link RetryRunResult} union.\n *\n * Additive alternative to `runRetryPolicy` for consumers who prefer explicit\n * `Result`/`ResultAsync` values (from `@zap-studio/monads`) over throw/catch.\n * There's no `throwOnExhausted` option — this function always returns a\n * `Result`, so the flag doesn't apply.\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, same as {@link RetryRunOptions} minus\n *   `throwOnExhausted`.\n * @returns A `ResultAsync` resolving to `Ok` with the successful value, or `Err`\n *   with a `RetryError` (exhaustion) or `AbortError` (cancellation) — the same\n *   error object `runRetryPolicy`'s throw mode would throw. When\n *   `policy.isKnownError` rejects a caught value, it is wrapped in a new\n *   `RetryError` and returned on `Err` instead — in throw mode that same value\n *   is rethrown unchanged, not wrapped.\n * @throws {Error} Any error thrown by `next`, `onExhausted`, or a custom `sleep`\n *   function.\n *\n * @example\n * ```ts\n * import { runRetryPolicyResult } from \"@zap-studio/retry\";\n *\n * const result = await runRetryPolicyResult(policy, async () => fetchFlakyResource());\n *\n * if (isOk(result)) {\n *   console.log(result.value);\n * } else {\n *   console.error(result.error);\n * }\n * ```\n */\nexport const runRetryPolicyResult = <T, TError extends Error = Error, TData = unknown>(\n  policy: RetryPolicy<TError, TData>,\n  execute: (attempt: number) => Promise<T>,\n  options: RetryRunResultOptions = {},\n): ResultAsync<T, RetryError | AbortError> =>\n  new ResultAsync(\n    (async (): Promise<Result<T, RetryError | AbortError>> => {\n      const sleep = options.sleep ?? defaultSleep;\n      const { signal, logger } = options;\n      const resolvedPolicy = resolvePolicy(policy);\n\n      const result = await runResultMode(resolvedPolicy, execute, sleep, signal, logger);\n\n      return result.ok ? ok(result.value) : err(result.error);\n    })(),\n  );\n"],"mappings":"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"}