@zap-studio/retry 0.3.2 → 1.0.0

package/dist/fixed-delay.d.ts

@@ -1,8 +1,10 @@
-import { RetryDecision, RetryDecisionInput } from "./types.js";
-import { BaseRetryPolicy } from "./base-policy.js";
+import { RetryPolicy } from "./types.js";
 //#region src/fixed-delay.d.ts
 /**
- * Configuration for `FixedDelay`.
+ * Configuration for `fixedDelay(...)`.
+ *
+ * @example
+ * const options: FixedDelayOptions = { maxAttempts: 3, delayMs: 250 };
  */
 interface FixedDelayOptions {
   /**
@@ -15,32 +17,15 @@ interface FixedDelayOptions {
   delayMs: number;
 }
 /**
- * Retries with a constant delay between attempts.
+ * Creates a retry policy with a constant delay between attempts.
  *
  * @example
- * const policy = new FixedDelay({
+ * const policy = 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;
-}
+declare const fixedDelay: (options: FixedDelayOptions) => RetryPolicy;
 //#endregion
-export { FixedDelay, FixedDelayOptions };
+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":";;;;;;UAYiB;;;;EAIf;;;;EAIA;;;;;;;;;;;cAYW,mBAAmB;;;;mBAIb;;;;mBAIA;;;;EAKjB,YAAY,SAAS;;;;EASrB,KAAY,OAAO,qBAAqB"}
+{"version":3,"file":"fixed-delay.d.ts","names":[],"sources":["../src/fixed-delay.ts"],"mappings":";;;;;;;;UAkBiB;;;;EAIf;;;;EAIA;;;;;;;;;;;cAYW,aAAc,SAAS,sBAAoB"}

package/dist/fixed-delay.js

@@ -1,53 +1,33 @@
-import { t as BaseRetryPolicy } from "./base-policy-Dn3TOJd3.js";
 //#region src/fixed-delay.ts
 /**
-* Fixed-delay retry strategy.
-*
-* @module @zap-studio/retry/fixed-delay
-*/
-/**
-* Retries with a constant delay between attempts.
+* Creates a retry policy with a constant delay between attempts.
 *
 * @example
-* const policy = new FixedDelay({
+* const policy = 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;
-	}
+const fixedDelay = (options) => {
+	const { maxAttempts, delayMs } = options;
+	return { 
 	/**
 	* Computes retry decision for the current attempt.
 	*/
-	next(input) {
-		if (input.attempt >= this.maxAttempts) return {
+next(input) {
+		if (input.attempt >= maxAttempts) return {
 			delayMs: 0,
 			reason: "max-attempts-reached",
 			shouldRetry: false
 		};
 		return {
-			delayMs: this.delayMs,
+			delayMs,
 			reason: "retry",
 			shouldRetry: true
 		};
-	}
+	} };
 };
 //#endregion
-export { FixedDelay };
+export { fixedDelay };
 
 //# sourceMappingURL=fixed-delay.js.map

package/dist/fixed-delay.js.map

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,7 +1,6 @@
 import { AbortError, RetryError } from "./errors.js";
-import { sleepWithAbortSignal, throwIfAborted, toAbortError } from "./abort.js";
-import { t as BaseRetryPolicy } from "./base-policy-Dn3TOJd3.js";
-import { defaultSleep } from "./sleep.js";
-import { ExponentialBackoff } from "./exponential-backoff.js";
-import { FixedDelay } from "./fixed-delay.js";
-export { AbortError, BaseRetryPolicy, ExponentialBackoff, FixedDelay, RetryError, defaultSleep, sleepWithAbortSignal, throwIfAborted, toAbortError };
+import { defaultSleep, runRetryPolicy } from "./base-policy.js";
+import { exponentialBackoff } from "./exponential-backoff.js";
+import { fixedDelay } from "./fixed-delay.js";
+import { linearBackoff } from "./linear-backoff.js";
+export { AbortError, RetryError, defaultSleep, exponentialBackoff, fixedDelay, linearBackoff, runRetryPolicy };

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.ts

@@ -1,7 +1,11 @@
-import { r as RetryError, t as AbortError } from "./errors-BVZjP1Q5.js";
+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.js";
  *   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 };
+export { ResolvedRetryPolicy, RetryDecision, RetryDecisionInput, RetryExhaustedInput, RetryPolicy, RetryRunOptions, RetryRunResult };
 //# 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":";;;;;;;;;;;UAiBiB,YAAY,kBAAkB;;;;;;EAM7C,OAAO,OAAO,mBAAmB,QAAQ,WAAW;;;;;;EAMpD,cAAc,OAAO,oBAAoB,QAAQ,WAAW;;;;;UAM7C;;;;;WAKN;;;;WAIA;;;;WAIA;;;;;UAMM,mBAAmB,kBAAkB;;;;WAI3C;;;;;WAKA;;;;;WAKA,QAAQ;;;;;WAKR,OAAO;;;;;UAMD,oBAAoB,kBAAkB;;;;WAI5C;;;;WAIA,QAAQ;;;;WAIR,OAAO;;;;;UAMD;;;;;;WAMN,SAAS,oBAAoB;;;;;;WAM7B,SAAS;;;;;;;;WAQT;;;;;;;;;KAUC,eAAe;;;;EAKrB;;;;EAIA,OAAO;;;;;EAMP;;;;;EAKA,OAAO,aAAa;;;;EAIpB"}
+{"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.2",
+  "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"
@@ -30,12 +31,11 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js",
-    "./abort": "./dist/abort.js",
     "./base-policy": "./dist/base-policy.js",
     "./errors": "./dist/errors.js",
     "./exponential-backoff": "./dist/exponential-backoff.js",
     "./fixed-delay": "./dist/fixed-delay.js",
-    "./sleep": "./dist/sleep.js",
+    "./linear-backoff": "./dist/linear-backoff.js",
     "./types": "./dist/types.js",
     "./package.json": "./package.json"
   },
@@ -43,12 +43,12 @@
     "access": "public"
   },
   "devDependencies": {
-    "@zap-studio/typescript": "workspace:*",
-    "tsdown": "catalog:",
-    "typescript": "catalog:",
-    "vitest": "catalog:"
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
+    "@zap-studio/typescript": "0.0.0"
   },
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}

package/dist/abort.d.ts

@@ -1,29 +0,0 @@
-import { t as AbortError } from "./errors-BVZjP1Q5.js";
-//#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.ts.map

package/dist/abort.d.ts.map

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

package/dist/abort.js

@@ -1,61 +0,0 @@
-import { AbortError } from "./errors.js";
-//#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.js.map

package/dist/abort.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"abort.js","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"}