@zap-studio/retry 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## @zap-studio/retry@0.3.1
+
+### Migrate to ultracite lint/format
+
+Internal formatting and lint cleanup only. No public API or behavior change.
+
 # @zap-studio/retry
 
 ## 0.3.0

package/README.md

@@ -33,8 +33,7 @@ const data = await exponential.run(async () => {
 
 `run(...)` throws when retries are exhausted.
 
-By default, policies extending `BaseRetryPolicy` throw `RetryError` on exhaustion
-and `AbortError` on cancellation.
+By default, policies extending `BaseRetryPolicy` throw `RetryError` on exhaustion and `AbortError` on cancellation.
 
 ```ts
 import { AbortError, RetryError } from "@zap-studio/retry/errors";
@@ -69,7 +68,7 @@ const result = await exponential.run(
     });
     return await response.json();
   },
-  { throwOnExhausted: false },
+  { throwOnExhausted: false }
 );
 
 if (!result.ok) {
@@ -102,7 +101,7 @@ const promise = exponential.run(
     });
     return await response.json();
   },
-  { signal: controller.signal },
+  { signal: controller.signal }
 );
 
 controller.abort(new Error("Request canceled"));
@@ -110,8 +109,7 @@ controller.abort(new Error("Request canceled"));
 await promise;
 ```
 
-In non-throw mode, abort is returned as `{ ok: false }` with `AbortError` on
-`result.error`:
+In non-throw mode, abort is returned as `{ ok: false }` with `AbortError` on `result.error`:
 
 ```ts
 const controller = new AbortController();
@@ -126,7 +124,7 @@ const result = await exponential.run(
   {
     signal: controller.signal,
     throwOnExhausted: false,
-  },
+  }
 );
 
 if (!result.ok) {
@@ -159,18 +157,19 @@ const predictableIntervalPolicy = new FixedDelay({
 
 Extend `BaseRetryPolicy` when the built-in policies do not match your retry rules.
 
-You implement `next(...)` only; the base class supplies `onExhausted` with a default
-`RetryError` and keeps the shared `run(...)` orchestration (override `onExhausted` when
-you need a different terminal error).
+You implement `next(...)` only; the base class supplies `onExhausted` with a default `RetryError` and keeps the shared `run(...)` orchestration (override `onExhausted` when you need a different terminal error).
 
 ```ts
 import { BaseRetryPolicy } from "@zap-studio/retry";
-import type { RetryDecision, RetryDecisionInput } from "@zap-studio/retry/types";
+import type {
+  RetryDecision,
+  RetryDecisionInput,
+} from "@zap-studio/retry/types";
 
 class LinearBackoff extends BaseRetryPolicy {
   constructor(
     private readonly maxAttempts: number,
-    private readonly stepMs: number,
+    private readonly stepMs: number
   ) {
     super();
   }

package/dist/abort.d.mts

@@ -1,30 +1,29 @@
-import { t as AbortError } from "./errors-fWo_KyVO.mjs";
-
+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 function throwIfAborted(signal?: AbortSignal): void;
+ * 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;
 /**
-* Converts an abort reason into a normalized `AbortError`.
-*
-* @param reason - Arbitrary abort reason value.
-* @returns Normalized abort error instance.
-*/
-declare function 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 function sleepWithAbortSignal(sleep: (delayMs: number) => Promise<void>, delayMs: number, signal: AbortSignal): Promise<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 +1 @@
-{"version":3,"file":"abort.d.mts","names":[],"sources":["../src/abort.ts"],"mappings":";;;;;AA4BA;;;;iBAdgB,cAAA,CAAe,MAAA,GAAS,WAAA;AA+CxC;;;;;;AAAA,iBAjCgB,YAAA,CAAa,MAAA,YAAkB,UAAA;;;;;;;;;;iBAiCzB,oBAAA,CACpB,KAAA,GAAQ,OAAA,aAAoB,OAAA,QAC5B,OAAA,UACA,MAAA,EAAQ,WAAA,GACP,OAAA"}
+{"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

@@ -11,17 +11,7 @@ import { AbortError } from "./errors.mjs";
 * @param signal - Optional abort signal to inspect.
 * @throws {AbortError} When the signal is aborted.
 */
-function throwIfAborted(signal) {
-	if (!signal?.aborted) return;
-	throw toAbortError(signal.reason);
-}
-/**
-* Converts an abort reason into a normalized `AbortError`.
-*
-* @param reason - Arbitrary abort reason value.
-* @returns Normalized abort error instance.
-*/
-function toAbortError(reason) {
+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);
@@ -31,7 +21,17 @@ function toAbortError(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.
 *
@@ -41,11 +41,11 @@ function toAbortError(reason) {
 * @returns Promise that resolves when delay finishes.
 * @throws {AbortError} When the signal aborts before or during wait.
 */
-async function sleepWithAbortSignal(sleep, delayMs, signal) {
+const sleepWithAbortSignal = async (sleep, delayMs, signal) => {
 	if (signal.aborted) throw toAbortError(signal.reason);
 	let onAbort;
 	try {
-		await Promise.race([sleep(delayMs), new Promise((_, reject) => {
+		await Promise.race([sleep(delayMs), new Promise((_resolve, reject) => {
 			onAbort = () => {
 				reject(toAbortError(signal.reason));
 			};
@@ -54,7 +54,7 @@ async function sleepWithAbortSignal(sleep, delayMs, signal) {
 	} finally {
 		if (onAbort) signal.removeEventListener("abort", onAbort);
 	}
-}
+};
 //#endregion
 export { sleepWithAbortSignal, throwIfAborted, toAbortError };
 

package/dist/abort.mjs.map

@@ -1 +1 @@
-{"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 function throwIfAborted(signal?: AbortSignal): void {\n  if (!signal?.aborted) {\n    return;\n  }\n\n  throw toAbortError(signal.reason);\n}\n\n/**\n * Converts an abort reason into a normalized `AbortError`.\n *\n * @param reason - Arbitrary abort reason value.\n * @returns Normalized abort error instance.\n */\nexport function 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 * 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 async function sleepWithAbortSignal(\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>((_, 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,SAAgB,eAAe,QAA4B;AACzD,KAAI,CAAC,QAAQ,QACX;AAGF,OAAM,aAAa,OAAO,OAAO;;;;;;;;AASnC,SAAgB,aAAa,QAA6B;AACxD,KAAI,kBAAkB,WACpB,QAAO;AAGT,KAAI,kBAAkB,MACpB,QAAO,IAAI,WAAW,OAAO,SAAS,EAAE,OAAO,QAAQ,CAAC;AAG1D,KAAI,OAAO,WAAW,YAAY,OAAO,SAAS,EAChD,QAAO,IAAI,WAAW,OAAO;AAG/B,KAAI,WAAW,KAAA,EACb,QAAO,IAAI,WAAW,iBAAiB;AAGzC,KAAI;AACF,SAAO,IAAI,WAAW,kBAAkB,KAAK,UAAU,OAAO,GAAG;SAC3D;AACN,SAAO,IAAI,WAAW,iBAAiB;;;;;;;;;;;;AAa3C,eAAsB,qBACpB,OACA,SACA,QACe;AACf,KAAI,OAAO,QACT,OAAM,aAAa,OAAO,OAAO;CAGnC,IAAI;AAEJ,KAAI;AACF,QAAM,QAAQ,KAAK,CACjB,MAAM,QAAQ,EACd,IAAI,SAAgB,GAAG,WAAW;AAChC,mBAAsB;AACpB,WAAO,aAAa,OAAO,OAAO,CAAC;;AAGrC,UAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,MAAM,CAAC;IACzD,CACH,CAAC;WACM;AACR,MAAI,QACF,QAAO,oBAAoB,SAAS,QAAQ"}
+{"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

@@ -0,0 +1,76 @@
+//#region src/errors.d.ts
+/**
+ * Terminal error types used by retry policies and runners.
+ *
+ * @module @zap-studio/retry/errors
+ */
+/**
+ * Context payload attached to `RetryError`.
+ */
+interface RetryErrorContext {
+  /**
+   * Count of completed attempts at exhaustion.
+   */
+  readonly attempts: number;
+  /**
+   * The last error object raised by a failed `execute` attempt.
+   */
+  readonly lastError?: unknown;
+  /**
+   * Optional data captured from the last attempt when provided by a policy.
+   */
+  readonly lastData?: unknown;
+}
+/**
+ * Context payload attached to `AbortError`.
+ */
+interface AbortErrorContext {
+  /**
+   * When the abort `reason` was an `Error`, the optional wrapped cause.
+   */
+  readonly cause?: unknown;
+}
+/**
+ * Error thrown when retries are exhausted.
+ *
+ * @example
+ * throw new RetryError("Retry exhausted", {
+ *   attempts: 3,
+ *   lastError: new Error("network"),
+ * });
+ */
+declare class RetryError extends Error {
+  /**
+   * Total attempts performed before exhaustion.
+   */
+  readonly attempts: number;
+  /**
+   * Last captured error from execution.
+   */
+  readonly lastError?: unknown;
+  /**
+   * Last captured data value, when available.
+   */
+  readonly lastData?: unknown;
+  /**
+   * Creates a RetryError with structured terminal context.
+   */
+  constructor(message: string, context: RetryErrorContext);
+}
+/**
+ * Error thrown when retry orchestration is canceled through `AbortSignal`.
+ */
+declare class AbortError extends Error {
+  /**
+   * Optional wrapped cause when the native abort `reason` was an `Error`.
+   */
+  override readonly cause?: unknown;
+  /**
+   * @param message - Human-readable abort description.
+   * @param context - Optional `cause` link for diagnostic chaining.
+   */
+  constructor(message: string, context?: AbortErrorContext);
+}
+//#endregion
+export { RetryErrorContext as i, AbortErrorContext as n, RetryError as r, AbortError as t };
+//# sourceMappingURL=errors-BVZjP1Q5.d.mts.map

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

@@ -0,0 +1 @@
+{"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.d.mts

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

package/dist/errors.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Terminal error types used by retry policies and runners.\n *\n * @module @zap-studio/retry/errors\n */\n\n/**\n * Context payload attached to `RetryError`.\n */\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":";;;;;;;;;;AA2CA,IAAa,aAAb,cAAgC,MAAM;;;;CAIpC;;;;CAIA;;;;CAIA;;;;CAKA,YAAY,SAAiB,SAA4B;AACvD,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,WAAW,QAAQ;AACxB,OAAK,YAAY,QAAQ;AACzB,OAAK,WAAW,QAAQ;;;;;;AAO5B,IAAa,aAAb,cAAgC,MAAM;;;;CAIpC;;;;;CAMA,YAAY,SAAiB,UAA6B,EAAE,EAAE;AAC5D,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,QAAQ,QAAQ"}
+{"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,54 +1,53 @@
 import { RetryDecision, RetryDecisionInput } from "./types.mjs";
 import { BaseRetryPolicy } from "./index.mjs";
-
 //#region src/exponential-backoff.d.ts
 /**
-* Configuration for `ExponentialBackoff`.
-*/
+ * Configuration for `ExponentialBackoff`.
+ */
 interface ExponentialBackoffOptions {
   /**
-  * Maximum number of attempts (including the first) before giving up.
-  */
+   * Maximum number of attempts (including the first) before giving up.
+   */
   maxAttempts: number;
   /**
-  * Initial delay in milliseconds, doubled each retry until capped.
-  */
+   * Initial delay in milliseconds, doubled each retry until capped.
+   */
   baseDelayMs: number;
   /**
-  * Hard upper bound in milliseconds for computed exponential delay.
-  */
+   * 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,
-* });
-*/
+ * 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`.
-  */
+   * Maximum number of attempts before the policy returns `max-attempts-reached`.
+   */
   private readonly maxAttempts;
   /**
-  * Base delay in milliseconds used in `baseDelayMs * 2 ** (attempt - 1)`.
-  */
+   * Base delay in milliseconds used in `baseDelayMs * 2 ** (attempt - 1)`.
+   */
   private readonly baseDelayMs;
   /**
-  * Upper cap for computed delay, applied with `Math.min`.
-  */
+   * Upper cap for computed delay, applied with `Math.min`.
+   */
   private readonly maxDelayMs;
   /**
-  * Creates an exponential backoff retry policy.
-  */
+   * Creates an exponential backoff retry policy.
+   */
   constructor(options: ExponentialBackoffOptions);
   /**
-  * Computes retry decision for the current attempt.
-  */
+   * Computes retry decision for the current attempt.
+   */
   next(input: RetryDecisionInput): RetryDecision;
 }
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"exponential-backoff.d.mts","names":[],"sources":["../src/exponential-backoff.ts"],"mappings":";;;;;;;UAYiB,yBAAA;;;AAyBjB;EArBE,WAAA;;;;EAIA,WAAA;;;;EAIA,UAAA;AAAA;;;;;;;;;;;cAaW,kBAAA,SAA2B,eAAA;;;;mBAIrB,WAAA;;;;mBAIA,WAAA;;;;mBAIA,UAAA;;;;EAKjB,WAAA,CAAY,OAAA,EAAS,yBAAA;;;;EAUrB,IAAA,CAAY,KAAA,EAAO,kBAAA,GAAqB,aAAA;AAAA"}
+{"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

@@ -42,15 +42,15 @@ var ExponentialBackoff = class extends BaseRetryPolicy {
 	*/
 	next(input) {
 		if (input.attempt >= this.maxAttempts) return {
-			shouldRetry: false,
 			delayMs: 0,
-			reason: "max-attempts-reached"
+			reason: "max-attempts-reached",
+			shouldRetry: false
 		};
 		const exponent = Math.max(0, input.attempt - 1);
 		return {
-			shouldRetry: true,
 			delayMs: Math.min(this.maxDelayMs, this.baseDelayMs * 2 ** exponent),
-			reason: "retry"
+			reason: "retry",
+			shouldRetry: true
 		};
 	}
 };

package/dist/exponential-backoff.mjs.map

@@ -1 +1 @@
-{"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 { shouldRetry: false, delayMs: 0, reason: \"max-attempts-reached\" };\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 { shouldRetry: true, delayMs, reason: \"retry\" };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAqCA,IAAa,qBAAb,cAAwC,gBAAgB;;;;CAItD;;;;CAIA;;;;CAIA;;;;CAKA,YAAY,SAAoC;AAC9C,SAAO;AACP,OAAK,cAAc,QAAQ;AAC3B,OAAK,cAAc,QAAQ;AAC3B,OAAK,aAAa,QAAQ;;;;;CAM5B,KAAY,OAA0C;AACpD,MAAI,MAAM,WAAW,KAAK,YACxB,QAAO;GAAE,aAAa;GAAO,SAAS;GAAG,QAAQ;GAAwB;EAG3E,MAAM,WAAW,KAAK,IAAI,GAAG,MAAM,UAAU,EAAE;AAG/C,SAAO;GAAE,aAAa;GAAM,SAFZ,KAAK,IAAI,KAAK,YAAY,KAAK,cAAc,KAAK,SAAS;GAEtC,QAAQ;GAAS"}
+{"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,45 +1,44 @@
 import { RetryDecision, RetryDecisionInput } from "./types.mjs";
 import { BaseRetryPolicy } from "./index.mjs";
-
 //#region src/fixed-delay.d.ts
 /**
-* Configuration for `FixedDelay`.
-*/
+ * Configuration for `FixedDelay`.
+ */
 interface FixedDelayOptions {
   /**
-  * Maximum number of attempts (including the first) before giving up.
-  */
+   * Maximum number of attempts (including the first) before giving up.
+   */
   maxAttempts: number;
   /**
-  * Constant delay in milliseconds before each retry after a failure.
-  */
+   * 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,
-* });
-*/
+ * 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`.
-  */
+   * Maximum number of attempts before the policy returns `max-attempts-reached`.
+   */
   private readonly maxAttempts;
   /**
-  * Constant delay in milliseconds before each subsequent attempt.
-  */
+   * Constant delay in milliseconds before each subsequent attempt.
+   */
   private readonly delayMs;
   /**
-  * Creates a fixed-delay retry policy.
-  */
+   * Creates a fixed-delay retry policy.
+   */
   constructor(options: FixedDelayOptions);
   /**
-  * Computes retry decision for the current attempt.
-  */
+   * Computes retry decision for the current attempt.
+   */
   next(input: RetryDecisionInput): RetryDecision;
 }
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"fixed-delay.d.mts","names":[],"sources":["../src/fixed-delay.ts"],"mappings":";;;;;;AAgCA;UApBiB,iBAAA;;;;EAIf,WAAA;;;;EAIA,OAAA;AAAA;;;;;;;;;;cAYW,UAAA,SAAmB,eAAA;;;;mBAIb,WAAA;;;;mBAIA,OAAA;;;;EAKjB,WAAA,CAAY,OAAA,EAAS,iBAAA;;;;EASrB,IAAA,CAAY,KAAA,EAAO,kBAAA,GAAqB,aAAA;AAAA"}
+{"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

@@ -36,14 +36,14 @@ var FixedDelay = class extends BaseRetryPolicy {
 	*/
 	next(input) {
 		if (input.attempt >= this.maxAttempts) return {
-			shouldRetry: false,
 			delayMs: 0,
-			reason: "max-attempts-reached"
+			reason: "max-attempts-reached",
+			shouldRetry: false
 		};
 		return {
-			shouldRetry: true,
 			delayMs: this.delayMs,
-			reason: "retry"
+			reason: "retry",
+			shouldRetry: true
 		};
 	}
 };

package/dist/fixed-delay.mjs.map

@@ -1 +1 @@
-{"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 { shouldRetry: false, delayMs: 0, reason: \"max-attempts-reached\" };\n    }\n\n    return { shouldRetry: true, delayMs: this.delayMs, reason: \"retry\" };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgCA,IAAa,aAAb,cAAgC,gBAAgB;;;;CAI9C;;;;CAIA;;;;CAKA,YAAY,SAA4B;AACtC,SAAO;AACP,OAAK,cAAc,QAAQ;AAC3B,OAAK,UAAU,QAAQ;;;;;CAMzB,KAAY,OAA0C;AACpD,MAAI,MAAM,WAAW,KAAK,YACxB,QAAO;GAAE,aAAa;GAAO,SAAS;GAAG,QAAQ;GAAwB;AAG3E,SAAO;GAAE,aAAa;GAAM,SAAS,KAAK;GAAS,QAAQ;GAAS"}
+{"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"}