@zap-studio/retry 0.3.1 → 1.0.0

package/dist/linear-backoff.d.ts

@@ -0,0 +1,46 @@
+import { RetryPolicy } from "./types.js";
+//#region src/linear-backoff.d.ts
+/**
+ * Configuration for `linearBackoff(...)`.
+ *
+ * @example
+ * const options: LinearBackoffOptions = {
+ *   maxAttempts: 5,
+ *   baseDelayMs: 100,
+ *   incrementMs: 100,
+ *   maxDelayMs: 2_000,
+ * };
+ */
+interface LinearBackoffOptions {
+  /**
+   * Maximum number of attempts (including the first) before giving up.
+   */
+  maxAttempts: number;
+  /**
+   * Delay in milliseconds after the first failed attempt.
+   */
+  baseDelayMs: number;
+  /**
+   * Amount added to the delay for each subsequent retry.
+   */
+  incrementMs: number;
+  /**
+   * Hard upper bound in milliseconds for computed linear delay.
+   */
+  maxDelayMs: number;
+}
+/**
+ * Creates a retry policy with linear delay growth up to a max cap.
+ *
+ * @example
+ * const policy = linearBackoff({
+ *   maxAttempts: 5,
+ *   baseDelayMs: 100,
+ *   incrementMs: 100,
+ *   maxDelayMs: 2_000,
+ * });
+ */
+declare const linearBackoff: (options: LinearBackoffOptions) => RetryPolicy;
+//#endregion
+export { LinearBackoffOptions, linearBackoff };
+//# sourceMappingURL=linear-backoff.d.ts.map

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

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

package/dist/linear-backoff.js

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

package/dist/linear-backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear-backoff.js","names":[],"sources":["../src/linear-backoff.ts"],"sourcesContent":["/**\n * Linear backoff retry strategy.\n *\n * @module @zap-studio/retry/linear-backoff\n */\n\nimport type {\n  RetryDecision,\n  RetryDecisionInput,\n  RetryPolicy,\n} from \"./types.js\";\n\n/**\n * Configuration for `linearBackoff(...)`.\n *\n * @example\n * const options: LinearBackoffOptions = {\n *   maxAttempts: 5,\n *   baseDelayMs: 100,\n *   incrementMs: 100,\n *   maxDelayMs: 2_000,\n * };\n */\nexport interface LinearBackoffOptions {\n  /**\n   * Maximum number of attempts (including the first) before giving up.\n   */\n  maxAttempts: number;\n  /**\n   * Delay in milliseconds after the first failed attempt.\n   */\n  baseDelayMs: number;\n  /**\n   * Amount added to the delay for each subsequent retry.\n   */\n  incrementMs: number;\n  /**\n   * Hard upper bound in milliseconds for computed linear delay.\n   */\n  maxDelayMs: number;\n}\n\n/**\n * Creates a retry policy with linear delay growth up to a max cap.\n *\n * @example\n * const policy = linearBackoff({\n *   maxAttempts: 5,\n *   baseDelayMs: 100,\n *   incrementMs: 100,\n *   maxDelayMs: 2_000,\n * });\n */\nexport const linearBackoff = (options: LinearBackoffOptions): RetryPolicy => {\n  const { maxAttempts, baseDelayMs, incrementMs, maxDelayMs } = options;\n\n  return {\n    /**\n     * Computes retry decision for the current attempt.\n     */\n    next(input: RetryDecisionInput): RetryDecision {\n      if (input.attempt >= maxAttempts) {\n        return {\n          delayMs: 0,\n          reason: \"max-attempts-reached\",\n          shouldRetry: false,\n        };\n      }\n\n      const delayMs = Math.min(\n        maxDelayMs,\n        baseDelayMs + incrementMs * (input.attempt - 1)\n      );\n\n      return { delayMs, reason: \"retry\", shouldRetry: true };\n    },\n  };\n};\n"],"mappings":";;;;;;;;;;;;AAqDA,MAAa,iBAAiB,YAA+C;CAC3E,MAAM,EAAE,aAAa,aAAa,aAAa,eAAe;CAE9D,OAAO;;;;AAIL,KAAK,OAA0C;EAC7C,IAAI,MAAM,WAAW,aACnB,OAAO;GACL,SAAS;GACT,QAAQ;GACR,aAAa;EACf;EAQF,OAAO;GAAE,SALO,KAAK,IACnB,YACA,cAAc,eAAe,MAAM,UAAU,EAGhC;GAAG,QAAQ;GAAS,aAAa;EAAK;CACvD,EACF;AACF"}

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

@@ -1,7 +1,11 @@
-import { r as RetryError, t as AbortError } from "./errors-BVZjP1Q5.mjs";
+import { r as RetryError, t as AbortError } from "./errors-CS5UPJWs.js";
 //#region src/types.d.ts
 /**
- * Retry policy contract used by `BaseRetryPolicy`.
+ * Retry policy contract consumed by `runRetryPolicy(...)`.
+ *
+ * Only `next` is required. `onExhausted` and `isKnownError` fall back to
+ * `runRetryPolicy`'s defaults when omitted, so a policy can be a plain
+ * object literal.
  *
  * @example
  * const policy: RetryPolicy = {
@@ -9,7 +13,7 @@ import { r as RetryError, t as AbortError } from "./errors-BVZjP1Q5.mjs";
  *   onExhausted: ({ attempts }) => new RetryError("done", { attempts }),
  * };
  */
-interface RetryPolicy<TError = unknown, TData = unknown> {
+interface RetryPolicy<TError extends Error = Error, TData = unknown> {
   /**
    * Returns the retry decision for a failed attempt.
    *
@@ -19,12 +23,39 @@ interface RetryPolicy<TError = unknown, TData = unknown> {
   /**
    * Builds the terminal error used when retries are exhausted.
    *
+   * Defaults to a `RetryError` built by `runRetryPolicy` when omitted.
+   *
    * @throws {Error} Any error thrown by the policy implementation.
    */
+  onExhausted?: (input: RetryExhaustedInput<TError, TData>) => RetryError;
+  /**
+   * Narrows a caught `unknown` value into `TError`.
+   *
+   * The runner calls this before handing an error to `next`/`onExhausted`.
+   * When it returns `false`, the value is treated as outside this policy's
+   * error domain instead of a retryable failure — `runRetryPolicy(...)`
+   * rethrows it immediately in throw mode, or wraps it in a `RetryError` on
+   * `result.error` in non-throw mode. The default (used when omitted) checks
+   * `error instanceof Error`; supply your own when `TError` is a narrower
+   * subclass (e.g. a specific HTTP or domain error) to get real narrowing
+   * instead of an assumption.
+   */
+  isKnownError?: (error: unknown) => error is TError;
+}
+/**
+ * `RetryPolicy` with `onExhausted` and `isKnownError` resolved to concrete
+ * functions, used internally once `runRetryPolicy` has applied defaults.
+ */
+interface ResolvedRetryPolicy<TError extends Error, TData> {
+  next: RetryPolicy<TError, TData>["next"];
   onExhausted: (input: RetryExhaustedInput<TError, TData>) => RetryError;
+  isKnownError: (error: unknown) => error is TError;
 }
 /**
  * Decision returned by a retry policy for a specific attempt.
+ *
+ * @example
+ * const decision: RetryDecision = { shouldRetry: true, delayMs: 200, reason: "retry" };
  */
 interface RetryDecision {
   /**
@@ -43,8 +74,11 @@ interface RetryDecision {
 }
 /**
  * Input passed to `RetryPolicy.next(...)` for each failed attempt.
+ *
+ * @example
+ * const input: RetryDecisionInput = { attempt: 2, error: new Error("timeout") };
  */
-interface RetryDecisionInput<TError = unknown, TData = unknown> {
+interface RetryDecisionInput<TError extends Error = Error, TData = unknown> {
   /**
    * One-based attempt number for the current failure.
    */
@@ -67,8 +101,11 @@ interface RetryDecisionInput<TError = unknown, TData = unknown> {
 }
 /**
  * Input passed to `RetryPolicy.onExhausted(...)` when retries stop.
+ *
+ * @example
+ * const input: RetryExhaustedInput = { attempts: 5, error: new Error("timeout") };
  */
-interface RetryExhaustedInput<TError = unknown, TData = unknown> {
+interface RetryExhaustedInput<TError extends Error = Error, TData = unknown> {
   /**
    * Count of completed attempts that led to stopping retries.
    */
@@ -83,7 +120,10 @@ interface RetryExhaustedInput<TError = unknown, TData = unknown> {
   readonly data?: TData;
 }
 /**
- * Options for `BaseRetryPolicy.run(...)`.
+ * Options for `runRetryPolicy(...)`.
+ *
+ * @example
+ * const options: RetryRunOptions = { throwOnExhausted: false, signal: controller.signal };
  */
 interface RetryRunOptions {
   /**
@@ -113,6 +153,10 @@ interface RetryRunOptions {
  * - Success: `ok: true` with the resolved `value`.
  * - Failure: `ok: false` with terminal `error` and completed `attempts` count
  *   (exhaustion or abort).
+ *
+ * @example
+ * const result: RetryRunResult<string> = await runRetryPolicy(policy, doWork, { throwOnExhausted: false });
+ * if (!result.ok) console.error(result.error);
  */
 type RetryRunResult<T> = {
   /**
@@ -139,5 +183,5 @@ type RetryRunResult<T> = {
   attempts: number;
 };
 //#endregion
-export { RetryDecision, RetryDecisionInput, RetryExhaustedInput, RetryPolicy, RetryRunOptions, RetryRunResult };
-//# sourceMappingURL=types.d.mts.map
+export { ResolvedRetryPolicy, RetryDecision, RetryDecisionInput, RetryExhaustedInput, RetryPolicy, RetryRunOptions, RetryRunResult };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;;UAqBiB,YAAY,eAAe,QAAQ,OAAO;;;;;;EAMzD,OAAO,OAAO,mBAAmB,QAAQ,WAAW;;;;;;;;EAQpD,eAAe,OAAO,oBAAoB,QAAQ,WAAW;;;;;;;;;;;;;EAa7D,gBAAgB,mBAAmB,SAAS;;;;;;UAO7B,oBAAoB,eAAe,OAAO;EACzD,MAAM,YAAY,QAAQ;EAC1B,cAAc,OAAO,oBAAoB,QAAQ,WAAW;EAC5D,eAAe,mBAAmB,SAAS;;;;;;;;UAS5B;;;;;WAKN;;;;WAIA;;;;WAIA;;;;;;;;UASM,mBACf,eAAe,QAAQ,OACvB;;;;WAKS;;;;;WAKA;;;;;WAKA,QAAQ;;;;;WAKR,OAAO;;;;;;;;UASD,oBACf,eAAe,QAAQ,OACvB;;;;WAKS;;;;WAIA,QAAQ;;;;WAIR,OAAO;;;;;;;;UASD;;;;;;WAMN,SAAS,oBAAoB;;;;;;WAM7B,SAAS;;;;;;;;WAQT;;;;;;;;;;;;;KAcC,eAAe;;;;EAKrB;;;;EAIA,OAAO;;;;;EAMP;;;;;EAKA,OAAO,aAAa;;;;EAIpB"}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@zap-studio/retry",
-  "version": "0.3.1",
+  "version": "1.0.0",
   "private": false,
-  "description": "Composable retry policies for resilient async operations.",
+  "description": "Composable, tree-shakeable retry policies for resilient async operations.",
   "keywords": [
     "backoff",
     "exponential backoff",
     "fetch",
     "http",
+    "linear backoff",
     "resilience",
     "retry",
     "typescript"
@@ -27,38 +28,27 @@
   ],
   "type": "module",
   "sideEffects": false,
-  "types": "./dist/index.d.mts",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.mjs",
-    "./abort": "./dist/abort.mjs",
-    "./errors": "./dist/errors.mjs",
-    "./exponential-backoff": "./dist/exponential-backoff.mjs",
-    "./fixed-delay": "./dist/fixed-delay.mjs",
-    "./result-mode": "./dist/result-mode.mjs",
-    "./sleep": "./dist/sleep.mjs",
-    "./throw-mode": "./dist/throw-mode.mjs",
-    "./types": "./dist/types.mjs",
+    ".": "./dist/index.js",
+    "./base-policy": "./dist/base-policy.js",
+    "./errors": "./dist/errors.js",
+    "./exponential-backoff": "./dist/exponential-backoff.js",
+    "./fixed-delay": "./dist/fixed-delay.js",
+    "./linear-backoff": "./dist/linear-backoff.js",
+    "./types": "./dist/types.js",
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@types/async-retry": "^1.4.9",
-    "@types/promise-retry": "^1.1.6",
-    "async-retry": "^1.3.3",
-    "exponential-backoff": "^3.1.3",
-    "p-retry": "^8.0.0",
-    "promise-retry": "^2.0.1",
-    "tsdown": "^0.22.4",
+    "tsdown": "^0.22.14",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10",
     "@zap-studio/typescript": "0.0.0"
   },
   "engines": {
     "node": ">=18.0.0"
-  },
-  "scripts": {
-    "build": "tsdown --config ./tsdown.config.ts"
   }
 }

package/dist/abort.d.mts

@@ -1,29 +0,0 @@
-import { t as AbortError } from "./errors-BVZjP1Q5.mjs";
-//#region src/abort.d.ts
-/**
- * Throws when the provided abort signal is already aborted.
- *
- * @param signal - Optional abort signal to inspect.
- * @throws {AbortError} When the signal is aborted.
- */
-declare const toAbortError: (reason: unknown) => AbortError;
-/**
- * Throws when the provided abort signal is already aborted.
- *
- * @param signal - Optional abort signal to inspect.
- * @throws {AbortError} When the signal is aborted.
- */
-declare const throwIfAborted: (signal?: AbortSignal) => void;
-/**
- * Waits for delay sleep while observing cancellation through an abort signal.
- *
- * @param sleep - Sleep function used to await `delayMs`.
- * @param delayMs - Delay duration in milliseconds.
- * @param signal - Abort signal to observe while waiting.
- * @returns Promise that resolves when delay finishes.
- * @throws {AbortError} When the signal aborts before or during wait.
- */
-declare const sleepWithAbortSignal: (sleep: (delayMs: number) => Promise<void>, delayMs: number, signal: AbortSignal) => Promise<void>;
-//#endregion
-export { sleepWithAbortSignal, throwIfAborted, toAbortError };
-//# sourceMappingURL=abort.d.mts.map

package/dist/abort.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"abort.d.mts","names":[],"sources":["../src/abort.ts"],"mappings":";;;;;;;;cAca,eAAgB,oBAAkB;;;;;;;cA8BlC,iBAAkB,SAAS;;;;;;;;;;cAiB3B,uBACX,QAAQ,oBAAoB,eAC5B,iBACA,QAAQ,gBACP"}

package/dist/abort.mjs

@@ -1,61 +0,0 @@
-import { AbortError } from "./errors.mjs";
-//#region src/abort.ts
-/**
-* Abort-signal helpers for retry orchestration internals.
-*
-* @module @zap-studio/retry/abort
-*/
-/**
-* Throws when the provided abort signal is already aborted.
-*
-* @param signal - Optional abort signal to inspect.
-* @throws {AbortError} When the signal is aborted.
-*/
-const toAbortError = (reason) => {
-	if (reason instanceof AbortError) return reason;
-	if (reason instanceof Error) return new AbortError(reason.message, { cause: reason });
-	if (typeof reason === "string" && reason.length > 0) return new AbortError(reason);
-	if (reason === void 0) return new AbortError("Retry aborted.");
-	try {
-		return new AbortError(`Retry aborted: ${JSON.stringify(reason)}`);
-	} catch {
-		return new AbortError("Retry aborted.");
-	}
-};
-/**
-* Throws when the provided abort signal is already aborted.
-*
-* @param signal - Optional abort signal to inspect.
-* @throws {AbortError} When the signal is aborted.
-*/
-const throwIfAborted = (signal) => {
-	if (signal?.aborted !== true) return;
-	throw toAbortError(signal.reason);
-};
-/**
-* Waits for delay sleep while observing cancellation through an abort signal.
-*
-* @param sleep - Sleep function used to await `delayMs`.
-* @param delayMs - Delay duration in milliseconds.
-* @param signal - Abort signal to observe while waiting.
-* @returns Promise that resolves when delay finishes.
-* @throws {AbortError} When the signal aborts before or during wait.
-*/
-const sleepWithAbortSignal = async (sleep, delayMs, signal) => {
-	if (signal.aborted) throw toAbortError(signal.reason);
-	let onAbort;
-	try {
-		await Promise.race([sleep(delayMs), new Promise((_resolve, reject) => {
-			onAbort = () => {
-				reject(toAbortError(signal.reason));
-			};
-			signal.addEventListener("abort", onAbort, { once: true });
-		})]);
-	} finally {
-		if (onAbort) signal.removeEventListener("abort", onAbort);
-	}
-};
-//#endregion
-export { sleepWithAbortSignal, throwIfAborted, toAbortError };
-
-//# sourceMappingURL=abort.mjs.map

package/dist/abort.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"abort.mjs","names":[],"sources":["../src/abort.ts"],"sourcesContent":["/**\n * Abort-signal helpers for retry orchestration internals.\n *\n * @module @zap-studio/retry/abort\n */\n\nimport { AbortError } from \"./errors.js\";\n\n/**\n * Throws when the provided abort signal is already aborted.\n *\n * @param signal - Optional abort signal to inspect.\n * @throws {AbortError} When the signal is aborted.\n */\nexport const toAbortError = (reason: unknown): AbortError => {\n  if (reason instanceof AbortError) {\n    return reason;\n  }\n\n  if (reason instanceof Error) {\n    return new AbortError(reason.message, { cause: reason });\n  }\n\n  if (typeof reason === \"string\" && reason.length > 0) {\n    return new AbortError(reason);\n  }\n\n  if (reason === undefined) {\n    return new AbortError(\"Retry aborted.\");\n  }\n\n  try {\n    return new AbortError(`Retry aborted: ${JSON.stringify(reason)}`);\n  } catch {\n    return new AbortError(\"Retry aborted.\");\n  }\n};\n\n/**\n * Throws when the provided abort signal is already aborted.\n *\n * @param signal - Optional abort signal to inspect.\n * @throws {AbortError} When the signal is aborted.\n */\nexport const throwIfAborted = (signal?: AbortSignal): void => {\n  if (signal?.aborted !== true) {\n    return;\n  }\n\n  throw toAbortError(signal.reason);\n};\n\n/**\n * Waits for delay sleep while observing cancellation through an abort signal.\n *\n * @param sleep - Sleep function used to await `delayMs`.\n * @param delayMs - Delay duration in milliseconds.\n * @param signal - Abort signal to observe while waiting.\n * @returns Promise that resolves when delay finishes.\n * @throws {AbortError} When the signal aborts before or during wait.\n */\nexport const sleepWithAbortSignal = async (\n  sleep: (delayMs: number) => Promise<void>,\n  delayMs: number,\n  signal: AbortSignal\n): Promise<void> => {\n  if (signal.aborted) {\n    throw toAbortError(signal.reason);\n  }\n\n  let onAbort: (() => void) | undefined;\n\n  try {\n    await Promise.race([\n      sleep(delayMs),\n      // oxlint-disable-next-line promise/avoid-new -- AbortSignal callback is adapted into the race promise.\n      new Promise<never>((_resolve, reject) => {\n        onAbort = (): void => {\n          reject(toAbortError(signal.reason));\n        };\n\n        signal.addEventListener(\"abort\", onAbort, { once: true });\n      }),\n    ]);\n  } finally {\n    if (onAbort) {\n      signal.removeEventListener(\"abort\", onAbort);\n    }\n  }\n};\n"],"mappings":";;;;;;;;;;;;;AAcA,MAAa,gBAAgB,WAAgC;CAC3D,IAAI,kBAAkB,YACpB,OAAO;CAGT,IAAI,kBAAkB,OACpB,OAAO,IAAI,WAAW,OAAO,SAAS,EAAE,OAAO,OAAO,CAAC;CAGzD,IAAI,OAAO,WAAW,YAAY,OAAO,SAAS,GAChD,OAAO,IAAI,WAAW,MAAM;CAG9B,IAAI,WAAW,KAAA,GACb,OAAO,IAAI,WAAW,gBAAgB;CAGxC,IAAI;EACF,OAAO,IAAI,WAAW,kBAAkB,KAAK,UAAU,MAAM,GAAG;CAClE,QAAQ;EACN,OAAO,IAAI,WAAW,gBAAgB;CACxC;AACF;;;;;;;AAQA,MAAa,kBAAkB,WAA+B;CAC5D,IAAI,QAAQ,YAAY,MACtB;CAGF,MAAM,aAAa,OAAO,MAAM;AAClC;;;;;;;;;;AAWA,MAAa,uBAAuB,OAClC,OACA,SACA,WACkB;CAClB,IAAI,OAAO,SACT,MAAM,aAAa,OAAO,MAAM;CAGlC,IAAI;CAEJ,IAAI;EACF,MAAM,QAAQ,KAAK,CACjB,MAAM,OAAO,GAEb,IAAI,SAAgB,UAAU,WAAW;GACvC,gBAAsB;IACpB,OAAO,aAAa,OAAO,MAAM,CAAC;GACpC;GAEA,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EAC1D,CAAC,CACH,CAAC;CACH,UAAU;EACR,IAAI,SACF,OAAO,oBAAoB,SAAS,OAAO;CAE/C;AACF"}

package/dist/errors-BVZjP1Q5.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-BVZjP1Q5.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;;;;;;UAWiB;;;;WAIN;;;;WAIA;;;;WAIA;;;;;UAMM;;;;WAIN;;;;;;;;;;;cAYE,mBAAmB;;;;WAId;;;;WAIA;;;;WAIA;;;;EAKhB,YAAY,iBAAiB,SAAS;;;;;cAY3B,mBAAmB;;;;oBAIL;;;;;EAMzB,YAAY,iBAAiB,UAAS"}

package/dist/errors.mjs.map

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

package/dist/exponential-backoff.d.mts

@@ -1,55 +0,0 @@
-import { RetryDecision, RetryDecisionInput } from "./types.mjs";
-import { BaseRetryPolicy } from "./index.mjs";
-//#region src/exponential-backoff.d.ts
-/**
- * Configuration for `ExponentialBackoff`.
- */
-interface ExponentialBackoffOptions {
-  /**
-   * Maximum number of attempts (including the first) before giving up.
-   */
-  maxAttempts: number;
-  /**
-   * Initial delay in milliseconds, doubled each retry until capped.
-   */
-  baseDelayMs: number;
-  /**
-   * Hard upper bound in milliseconds for computed exponential delay.
-   */
-  maxDelayMs: number;
-}
-/**
- * Retries with exponential delay growth up to a max cap.
- *
- * @example
- * const policy = new ExponentialBackoff({
- *   maxAttempts: 5,
- *   baseDelayMs: 100,
- *   maxDelayMs: 2_000,
- * });
- */
-declare class ExponentialBackoff extends BaseRetryPolicy {
-  /**
-   * Maximum number of attempts before the policy returns `max-attempts-reached`.
-   */
-  private readonly maxAttempts;
-  /**
-   * Base delay in milliseconds used in `baseDelayMs * 2 ** (attempt - 1)`.
-   */
-  private readonly baseDelayMs;
-  /**
-   * Upper cap for computed delay, applied with `Math.min`.
-   */
-  private readonly maxDelayMs;
-  /**
-   * Creates an exponential backoff retry policy.
-   */
-  constructor(options: ExponentialBackoffOptions);
-  /**
-   * Computes retry decision for the current attempt.
-   */
-  next(input: RetryDecisionInput): RetryDecision;
-}
-//#endregion
-export { ExponentialBackoff, ExponentialBackoffOptions };
-//# sourceMappingURL=exponential-backoff.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"exponential-backoff.d.mts","names":[],"sources":["../src/exponential-backoff.ts"],"mappings":";;;;;;UAYiB;;;;EAIf;;;;EAIA;;;;EAIA;;;;;;;;;;;;cAaW,2BAA2B;;;;mBAIrB;;;;mBAIA;;;;mBAIA;;;;EAKjB,YAAY,SAAS;;;;EAUrB,KAAY,OAAO,qBAAqB"}

package/dist/exponential-backoff.mjs

@@ -1,60 +0,0 @@
-import { BaseRetryPolicy } from "./index.mjs";
-//#region src/exponential-backoff.ts
-/**
-* Exponential backoff retry strategy.
-*
-* @module @zap-studio/retry/exponential-backoff
-*/
-/**
-* Retries with exponential delay growth up to a max cap.
-*
-* @example
-* const policy = new ExponentialBackoff({
-*   maxAttempts: 5,
-*   baseDelayMs: 100,
-*   maxDelayMs: 2_000,
-* });
-*/
-var ExponentialBackoff = class extends BaseRetryPolicy {
-	/**
-	* Maximum number of attempts before the policy returns `max-attempts-reached`.
-	*/
-	maxAttempts;
-	/**
-	* Base delay in milliseconds used in `baseDelayMs * 2 ** (attempt - 1)`.
-	*/
-	baseDelayMs;
-	/**
-	* Upper cap for computed delay, applied with `Math.min`.
-	*/
-	maxDelayMs;
-	/**
-	* Creates an exponential backoff retry policy.
-	*/
-	constructor(options) {
-		super();
-		this.maxAttempts = options.maxAttempts;
-		this.baseDelayMs = options.baseDelayMs;
-		this.maxDelayMs = options.maxDelayMs;
-	}
-	/**
-	* Computes retry decision for the current attempt.
-	*/
-	next(input) {
-		if (input.attempt >= this.maxAttempts) return {
-			delayMs: 0,
-			reason: "max-attempts-reached",
-			shouldRetry: false
-		};
-		const exponent = Math.max(0, input.attempt - 1);
-		return {
-			delayMs: Math.min(this.maxDelayMs, this.baseDelayMs * 2 ** exponent),
-			reason: "retry",
-			shouldRetry: true
-		};
-	}
-};
-//#endregion
-export { ExponentialBackoff };
-
-//# sourceMappingURL=exponential-backoff.mjs.map

package/dist/exponential-backoff.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"exponential-backoff.mjs","names":[],"sources":["../src/exponential-backoff.ts"],"sourcesContent":["/**\n * Exponential backoff retry strategy.\n *\n * @module @zap-studio/retry/exponential-backoff\n */\n\nimport { BaseRetryPolicy } from \"./index.js\";\nimport type { RetryDecision, RetryDecisionInput } from \"./types.js\";\n\n/**\n * Configuration for `ExponentialBackoff`.\n */\nexport interface ExponentialBackoffOptions {\n  /**\n   * Maximum number of attempts (including the first) before giving up.\n   */\n  maxAttempts: number;\n  /**\n   * Initial delay in milliseconds, doubled each retry until capped.\n   */\n  baseDelayMs: number;\n  /**\n   * Hard upper bound in milliseconds for computed exponential delay.\n   */\n  maxDelayMs: number;\n}\n\n/**\n * Retries with exponential delay growth up to a max cap.\n *\n * @example\n * const policy = new ExponentialBackoff({\n *   maxAttempts: 5,\n *   baseDelayMs: 100,\n *   maxDelayMs: 2_000,\n * });\n */\nexport class ExponentialBackoff extends BaseRetryPolicy {\n  /**\n   * Maximum number of attempts before the policy returns `max-attempts-reached`.\n   */\n  private readonly maxAttempts: number;\n  /**\n   * Base delay in milliseconds used in `baseDelayMs * 2 ** (attempt - 1)`.\n   */\n  private readonly baseDelayMs: number;\n  /**\n   * Upper cap for computed delay, applied with `Math.min`.\n   */\n  private readonly maxDelayMs: number;\n\n  /**\n   * Creates an exponential backoff retry policy.\n   */\n  constructor(options: ExponentialBackoffOptions) {\n    super();\n    this.maxAttempts = options.maxAttempts;\n    this.baseDelayMs = options.baseDelayMs;\n    this.maxDelayMs = options.maxDelayMs;\n  }\n\n  /**\n   * Computes retry decision for the current attempt.\n   */\n  public next(input: RetryDecisionInput): RetryDecision {\n    if (input.attempt >= this.maxAttempts) {\n      return { delayMs: 0, reason: \"max-attempts-reached\", shouldRetry: false };\n    }\n\n    const exponent = Math.max(0, input.attempt - 1);\n    const delayMs = Math.min(this.maxDelayMs, this.baseDelayMs * 2 ** exponent);\n\n    return { delayMs, reason: \"retry\", shouldRetry: true };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAqCA,IAAa,qBAAb,cAAwC,gBAAgB;;;;CAItD;;;;CAIA;;;;CAIA;;;;CAKA,YAAY,SAAoC;EAC9C,MAAM;EACN,KAAK,cAAc,QAAQ;EAC3B,KAAK,cAAc,QAAQ;EAC3B,KAAK,aAAa,QAAQ;CAC5B;;;;CAKA,KAAY,OAA0C;EACpD,IAAI,MAAM,WAAW,KAAK,aACxB,OAAO;GAAE,SAAS;GAAG,QAAQ;GAAwB,aAAa;EAAM;EAG1E,MAAM,WAAW,KAAK,IAAI,GAAG,MAAM,UAAU,CAAC;EAG9C,OAAO;GAAE,SAFO,KAAK,IAAI,KAAK,YAAY,KAAK,cAAc,KAAK,QAEnD;GAAG,QAAQ;GAAS,aAAa;EAAK;CACvD;AACF"}

package/dist/fixed-delay.d.mts

@@ -1,46 +0,0 @@
-import { RetryDecision, RetryDecisionInput } from "./types.mjs";
-import { BaseRetryPolicy } from "./index.mjs";
-//#region src/fixed-delay.d.ts
-/**
- * Configuration for `FixedDelay`.
- */
-interface FixedDelayOptions {
-  /**
-   * Maximum number of attempts (including the first) before giving up.
-   */
-  maxAttempts: number;
-  /**
-   * Constant delay in milliseconds before each retry after a failure.
-   */
-  delayMs: number;
-}
-/**
- * Retries with a constant delay between attempts.
- *
- * @example
- * const policy = new FixedDelay({
- *   maxAttempts: 3,
- *   delayMs: 250,
- * });
- */
-declare class FixedDelay extends BaseRetryPolicy {
-  /**
-   * Maximum number of attempts before the policy returns `max-attempts-reached`.
-   */
-  private readonly maxAttempts;
-  /**
-   * Constant delay in milliseconds before each subsequent attempt.
-   */
-  private readonly delayMs;
-  /**
-   * Creates a fixed-delay retry policy.
-   */
-  constructor(options: FixedDelayOptions);
-  /**
-   * Computes retry decision for the current attempt.
-   */
-  next(input: RetryDecisionInput): RetryDecision;
-}
-//#endregion
-export { FixedDelay, FixedDelayOptions };
-//# sourceMappingURL=fixed-delay.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"fixed-delay.d.mts","names":[],"sources":["../src/fixed-delay.ts"],"mappings":";;;;;;UAYiB;;;;EAIf;;;;EAIA;;;;;;;;;;;cAYW,mBAAmB;;;;mBAIb;;;;mBAIA;;;;EAKjB,YAAY,SAAS;;;;EASrB,KAAY,OAAO,qBAAqB"}

package/dist/fixed-delay.mjs

@@ -1,53 +0,0 @@
-import { BaseRetryPolicy } from "./index.mjs";
-//#region src/fixed-delay.ts
-/**
-* Fixed-delay retry strategy.
-*
-* @module @zap-studio/retry/fixed-delay
-*/
-/**
-* Retries with a constant delay between attempts.
-*
-* @example
-* const policy = new FixedDelay({
-*   maxAttempts: 3,
-*   delayMs: 250,
-* });
-*/
-var FixedDelay = class extends BaseRetryPolicy {
-	/**
-	* Maximum number of attempts before the policy returns `max-attempts-reached`.
-	*/
-	maxAttempts;
-	/**
-	* Constant delay in milliseconds before each subsequent attempt.
-	*/
-	delayMs;
-	/**
-	* Creates a fixed-delay retry policy.
-	*/
-	constructor(options) {
-		super();
-		this.maxAttempts = options.maxAttempts;
-		this.delayMs = options.delayMs;
-	}
-	/**
-	* Computes retry decision for the current attempt.
-	*/
-	next(input) {
-		if (input.attempt >= this.maxAttempts) return {
-			delayMs: 0,
-			reason: "max-attempts-reached",
-			shouldRetry: false
-		};
-		return {
-			delayMs: this.delayMs,
-			reason: "retry",
-			shouldRetry: true
-		};
-	}
-};
-//#endregion
-export { FixedDelay };
-
-//# sourceMappingURL=fixed-delay.mjs.map

package/dist/fixed-delay.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"fixed-delay.mjs","names":[],"sources":["../src/fixed-delay.ts"],"sourcesContent":["/**\n * Fixed-delay retry strategy.\n *\n * @module @zap-studio/retry/fixed-delay\n */\n\nimport { BaseRetryPolicy } from \"./index.js\";\nimport type { RetryDecision, RetryDecisionInput } from \"./types.js\";\n\n/**\n * Configuration for `FixedDelay`.\n */\nexport interface FixedDelayOptions {\n  /**\n   * Maximum number of attempts (including the first) before giving up.\n   */\n  maxAttempts: number;\n  /**\n   * Constant delay in milliseconds before each retry after a failure.\n   */\n  delayMs: number;\n}\n\n/**\n * Retries with a constant delay between attempts.\n *\n * @example\n * const policy = new FixedDelay({\n *   maxAttempts: 3,\n *   delayMs: 250,\n * });\n */\nexport class FixedDelay extends BaseRetryPolicy {\n  /**\n   * Maximum number of attempts before the policy returns `max-attempts-reached`.\n   */\n  private readonly maxAttempts: number;\n  /**\n   * Constant delay in milliseconds before each subsequent attempt.\n   */\n  private readonly delayMs: number;\n\n  /**\n   * Creates a fixed-delay retry policy.\n   */\n  constructor(options: FixedDelayOptions) {\n    super();\n    this.maxAttempts = options.maxAttempts;\n    this.delayMs = options.delayMs;\n  }\n\n  /**\n   * Computes retry decision for the current attempt.\n   */\n  public next(input: RetryDecisionInput): RetryDecision {\n    if (input.attempt >= this.maxAttempts) {\n      return { delayMs: 0, reason: \"max-attempts-reached\", shouldRetry: false };\n    }\n\n    return { delayMs: this.delayMs, reason: \"retry\", shouldRetry: true };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgCA,IAAa,aAAb,cAAgC,gBAAgB;;;;CAI9C;;;;CAIA;;;;CAKA,YAAY,SAA4B;EACtC,MAAM;EACN,KAAK,cAAc,QAAQ;EAC3B,KAAK,UAAU,QAAQ;CACzB;;;;CAKA,KAAY,OAA0C;EACpD,IAAI,MAAM,WAAW,KAAK,aACxB,OAAO;GAAE,SAAS;GAAG,QAAQ;GAAwB,aAAa;EAAM;EAG1E,OAAO;GAAE,SAAS,KAAK;GAAS,QAAQ;GAAS,aAAa;EAAK;CACrE;AACF"}