actly 1.1.5 → 1.3.0

package/dist/policies/retry.cjs

@@ -3,85 +3,157 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.retryPolicy = retryPolicy;
 const backoff_js_1 = require("../utils/backoff.js");
 const abort_js_1 = require("../utils/abort.js");
-// ─── Default predicate ────────────────────────────────────────────────────────
-/**
- * Default `shouldRetry`: retry on any error EXCEPT abort errors.
- *
- * Abort errors indicate the caller or a timeout cancelled the operation —
- * retrying would just abort again on the next attempt, wasting delay budget.
- *
- * User-supplied `shouldRetry` overrides this entirely.
- */
+const safeCall_js_1 = require("../utils/safeCall.js");
+const errors_js_1 = require("../errors.js");
+const limits_js_1 = require("../utils/limits.js");
 function defaultShouldRetry(error, _attempt) {
-    return !(0, abort_js_1.isAbortError)(error);
+    if ((0, abort_js_1.isAbortError)(error))
+        return false;
+    if (typeof error === 'object' && error !== null) {
+        const code = error.code;
+        if (code === 'ACTLY_TIMEOUT' || code === 'ACTLY_TOTAL_TIMEOUT')
+            return false;
+    }
+    return true;
 }
-// ─── Policy ───────────────────────────────────────────────────────────────────
-/**
- * Retry `fn` up to `opts.attempts` times on retryable errors.
- *
- * Writes the live attempt count into `ctx.meta.attempts` so `act()` can
- * report it in the final `ActResult`.
- *
- * # Signal awareness
- *
- * - Before each attempt, checks `parentSignal.aborted`. If the parent (e.g.
- *   `totalTimeout` or caller) has aborted, throws the parent's reason
- *   immediately — no more attempts.
- * - Sleeps between attempts use `sleep(delay, parentSignal)`. If the parent
- *   aborts mid-delay, the sleep rejects immediately instead of blocking
- *   the loop until the timer would have elapsed.
- *
- * # `shouldRetry` invocation
- *
- * Called after EVERY failure, including the last attempt. This preserves the
- * predicate's contract for observers / metrics that rely on it being called
- * per-attempt. The return value is only consulted when `attempt < max`.
- *
- * # Default predicate
- *
- * If `shouldRetry` is omitted, uses `defaultShouldRetry` which retries on
- * every error EXCEPT abort errors (so timeouts and caller cancellations
- * don't waste retry budget).
- */
 function retryPolicy(opts) {
     const max = Math.max(1, Math.floor(opts.attempts));
     const shouldRetry = opts.shouldRetry ?? defaultShouldRetry;
+    const shouldRetryResult = opts.shouldRetryResult;
+    const dangerouslyUnref = opts.dangerouslyUnref === true;
+    const sleepOpts = dangerouslyUnref ? { unref: true } : undefined;
+    const backoffFn = opts.backoffFn;
     return (fn, ctx) => async (parentSignal) => {
-        let lastErr;
+        const backoffState = {};
+        let errors;
+        let retriedAtLeastOnce = false;
+        const obs = ctx.observability;
         for (let attempt = 1; attempt <= max; attempt++) {
-            // Parent (totalTimeout or caller signal) already aborted — bail.
             if (parentSignal.aborted)
                 throw parentSignal.reason;
             ctx.meta.attempts = attempt;
+            const attemptStart = Date.now();
             try {
-                return await fn(parentSignal);
+                if (obs) {
+                    (0, safeCall_js_1.safeCall)(obs.hooks.onAttempt, {
+                        type: 'attempt', key: ctx.key, traceId: obs.traceId,
+                        timestamp: attemptStart, attempt,
+                    });
+                }
+                const value = await fn(parentSignal);
+                if (shouldRetryResult) {
+                    let accept;
+                    try {
+                        const raw = shouldRetryResult(value, attempt);
+                        accept = typeof raw === 'boolean' ? raw : true;
+                    }
+                    catch {
+                        return value;
+                    }
+                    if (accept)
+                        return value;
+                    const syntheticError = new Error(`Actly: shouldRetryResult returned false on attempt ${attempt}`);
+                    if (errors === undefined)
+                        errors = [];
+                    if (errors.length < 10) {
+                        errors.push(syntheticError);
+                    }
+                    else {
+                        errors.shift();
+                        errors.push(syntheticError);
+                    }
+                    if (attempt >= max) {
+                        if (obs) {
+                            (0, safeCall_js_1.safeCall)(obs.hooks.onRetry, {
+                                type: 'retry', key: ctx.key, traceId: obs.traceId,
+                                timestamp: Date.now(), attempt, delayMs: 0,
+                                error: syntheticError,
+                            });
+                        }
+                        return value;
+                    }
+                    retriedAtLeastOnce = true;
+                    if (parentSignal.aborted)
+                        throw parentSignal.reason;
+                    let rawDelay;
+                    try {
+                        rawDelay = backoffFn
+                            ? backoffFn(attempt, syntheticError, backoffState)
+                            : (0, backoff_js_1.computeDelay)(attempt, opts);
+                    }
+                    catch {
+                        rawDelay = (0, backoff_js_1.computeDelay)(attempt, opts);
+                    }
+                    const safeDelay = Number.isFinite(rawDelay) ? rawDelay : 0;
+                    const delay = Math.min(Math.max(0, safeDelay), limits_js_1.LIMITS.MAX_RETRY_DELAY_MS);
+                    if (obs) {
+                        (0, safeCall_js_1.safeCall)(obs.hooks.onRetry, {
+                            type: 'retry', key: ctx.key, traceId: obs.traceId,
+                            timestamp: Date.now(), attempt, delayMs: delay,
+                            error: syntheticError,
+                        });
+                    }
+                    if (delay > 0)
+                        await (0, abort_js_1.sleep)(delay, parentSignal, sleepOpts);
+                    continue;
+                }
+                return value;
             }
             catch (err) {
-                lastErr = err;
-                // Always invoke shouldRetry so observers see every failure.
-                // The return value only matters when there are attempts left.
-                const retryable = shouldRetry(err, attempt);
-                if (attempt >= max) {
-                    // Last attempt — surface the error regardless of retryable.
+                if (errors === undefined)
+                    errors = [];
+                if (errors.length < 10) {
+                    errors.push(err);
+                }
+                else {
+                    errors.shift();
+                    errors.push(err);
+                }
+                let retryable;
+                try {
+                    retryable = shouldRetry(err, attempt);
+                }
+                catch {
                     throw err;
                 }
-                if (!retryable) {
-                    // Non-retryable error — bail immediately without consuming
-                    // remaining attempts. The error surfaces exactly as-is.
+                if (attempt >= max) {
+                    if (retriedAtLeastOnce) {
+                        throw new errors_js_1.RetryExhaustedError({
+                            key: ctx.key,
+                            attempts: attempt,
+                            lastError: err,
+                            errors: errors ?? [],
+                        });
+                    }
                     throw err;
                 }
-                // Parent aborted mid-attempt — don't sleep, bail.
+                if (!retryable)
+                    throw err;
+                retriedAtLeastOnce = true;
                 if (parentSignal.aborted)
                     throw parentSignal.reason;
-                const delay = (0, backoff_js_1.computeDelay)(attempt, opts);
+                let rawDelay;
+                try {
+                    rawDelay = backoffFn
+                        ? backoffFn(attempt, err, backoffState)
+                        : (0, backoff_js_1.computeDelay)(attempt, opts);
+                }
+                catch {
+                    rawDelay = (0, backoff_js_1.computeDelay)(attempt, opts);
+                }
+                const safeDelay = Number.isFinite(rawDelay) ? rawDelay : 0;
+                const delay = Math.min(Math.max(0, safeDelay), limits_js_1.LIMITS.MAX_RETRY_DELAY_MS);
+                if (obs) {
+                    (0, safeCall_js_1.safeCall)(obs.hooks.onRetry, {
+                        type: 'retry', key: ctx.key, traceId: obs.traceId,
+                        timestamp: Date.now(), attempt, delayMs: delay, error: err,
+                    });
+                }
                 if (delay > 0) {
-                    // Sleep is signal-aware: rejects immediately if parent aborts.
-                    await (0, abort_js_1.sleep)(delay, parentSignal);
+                    await (0, abort_js_1.sleep)(delay, parentSignal, sleepOpts);
                 }
             }
         }
-        // Unreachable: the loop either returns or throws on every iteration.
-        // The cast satisfies the type checker without a `throw` after the loop.
-        throw lastErr;
+        throw new Error('Actly: retryPolicy reached unreachable state');
     };
 }

package/dist/policies/retry.d.ts

@@ -1,30 +1,3 @@
 import type { PolicyApplier, RetryOptions } from '../types/index.js';
-/**
- * Retry `fn` up to `opts.attempts` times on retryable errors.
- *
- * Writes the live attempt count into `ctx.meta.attempts` so `act()` can
- * report it in the final `ActResult`.
- *
- * # Signal awareness
- *
- * - Before each attempt, checks `parentSignal.aborted`. If the parent (e.g.
- *   `totalTimeout` or caller) has aborted, throws the parent's reason
- *   immediately — no more attempts.
- * - Sleeps between attempts use `sleep(delay, parentSignal)`. If the parent
- *   aborts mid-delay, the sleep rejects immediately instead of blocking
- *   the loop until the timer would have elapsed.
- *
- * # `shouldRetry` invocation
- *
- * Called after EVERY failure, including the last attempt. This preserves the
- * predicate's contract for observers / metrics that rely on it being called
- * per-attempt. The return value is only consulted when `attempt < max`.
- *
- * # Default predicate
- *
- * If `shouldRetry` is omitted, uses `defaultShouldRetry` which retries on
- * every error EXCEPT abort errors (so timeouts and caller cancellations
- * don't waste retry budget).
- */
 export declare function retryPolicy<T>(opts: RetryOptions): PolicyApplier<T>;
 //# sourceMappingURL=retry.d.ts.map

package/dist/policies/retry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/policies/retry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAoB1F;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC,CAAC,CAAC,CAiDnE"}
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/policies/retry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAsC1F,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC,CAAC,CAAC,CA4KnE"}

package/dist/policies/retry.js

@@ -1,85 +1,156 @@
 import { computeDelay } from '../utils/backoff.js';
 import { isAbortError, sleep } from '../utils/abort.js';
-// ─── Default predicate ────────────────────────────────────────────────────────
-/**
- * Default `shouldRetry`: retry on any error EXCEPT abort errors.
- *
- * Abort errors indicate the caller or a timeout cancelled the operation —
- * retrying would just abort again on the next attempt, wasting delay budget.
- *
- * User-supplied `shouldRetry` overrides this entirely.
- */
+import { safeCall } from '../utils/safeCall.js';
+import { RetryExhaustedError } from '../errors.js';
+import { LIMITS } from '../utils/limits.js';
 function defaultShouldRetry(error, _attempt) {
-    return !isAbortError(error);
+    if (isAbortError(error))
+        return false;
+    if (typeof error === 'object' && error !== null) {
+        const code = error.code;
+        if (code === 'ACTLY_TIMEOUT' || code === 'ACTLY_TOTAL_TIMEOUT')
+            return false;
+    }
+    return true;
 }
-// ─── Policy ───────────────────────────────────────────────────────────────────
-/**
- * Retry `fn` up to `opts.attempts` times on retryable errors.
- *
- * Writes the live attempt count into `ctx.meta.attempts` so `act()` can
- * report it in the final `ActResult`.
- *
- * # Signal awareness
- *
- * - Before each attempt, checks `parentSignal.aborted`. If the parent (e.g.
- *   `totalTimeout` or caller) has aborted, throws the parent's reason
- *   immediately — no more attempts.
- * - Sleeps between attempts use `sleep(delay, parentSignal)`. If the parent
- *   aborts mid-delay, the sleep rejects immediately instead of blocking
- *   the loop until the timer would have elapsed.
- *
- * # `shouldRetry` invocation
- *
- * Called after EVERY failure, including the last attempt. This preserves the
- * predicate's contract for observers / metrics that rely on it being called
- * per-attempt. The return value is only consulted when `attempt < max`.
- *
- * # Default predicate
- *
- * If `shouldRetry` is omitted, uses `defaultShouldRetry` which retries on
- * every error EXCEPT abort errors (so timeouts and caller cancellations
- * don't waste retry budget).
- */
 export function retryPolicy(opts) {
     const max = Math.max(1, Math.floor(opts.attempts));
     const shouldRetry = opts.shouldRetry ?? defaultShouldRetry;
+    const shouldRetryResult = opts.shouldRetryResult;
+    const dangerouslyUnref = opts.dangerouslyUnref === true;
+    const sleepOpts = dangerouslyUnref ? { unref: true } : undefined;
+    const backoffFn = opts.backoffFn;
     return (fn, ctx) => async (parentSignal) => {
-        let lastErr;
+        const backoffState = {};
+        let errors;
+        let retriedAtLeastOnce = false;
+        const obs = ctx.observability;
         for (let attempt = 1; attempt <= max; attempt++) {
-            // Parent (totalTimeout or caller signal) already aborted — bail.
             if (parentSignal.aborted)
                 throw parentSignal.reason;
             ctx.meta.attempts = attempt;
+            const attemptStart = Date.now();
             try {
-                return await fn(parentSignal);
+                if (obs) {
+                    safeCall(obs.hooks.onAttempt, {
+                        type: 'attempt', key: ctx.key, traceId: obs.traceId,
+                        timestamp: attemptStart, attempt,
+                    });
+                }
+                const value = await fn(parentSignal);
+                if (shouldRetryResult) {
+                    let accept;
+                    try {
+                        const raw = shouldRetryResult(value, attempt);
+                        accept = typeof raw === 'boolean' ? raw : true;
+                    }
+                    catch {
+                        return value;
+                    }
+                    if (accept)
+                        return value;
+                    const syntheticError = new Error(`Actly: shouldRetryResult returned false on attempt ${attempt}`);
+                    if (errors === undefined)
+                        errors = [];
+                    if (errors.length < 10) {
+                        errors.push(syntheticError);
+                    }
+                    else {
+                        errors.shift();
+                        errors.push(syntheticError);
+                    }
+                    if (attempt >= max) {
+                        if (obs) {
+                            safeCall(obs.hooks.onRetry, {
+                                type: 'retry', key: ctx.key, traceId: obs.traceId,
+                                timestamp: Date.now(), attempt, delayMs: 0,
+                                error: syntheticError,
+                            });
+                        }
+                        return value;
+                    }
+                    retriedAtLeastOnce = true;
+                    if (parentSignal.aborted)
+                        throw parentSignal.reason;
+                    let rawDelay;
+                    try {
+                        rawDelay = backoffFn
+                            ? backoffFn(attempt, syntheticError, backoffState)
+                            : computeDelay(attempt, opts);
+                    }
+                    catch {
+                        rawDelay = computeDelay(attempt, opts);
+                    }
+                    const safeDelay = Number.isFinite(rawDelay) ? rawDelay : 0;
+                    const delay = Math.min(Math.max(0, safeDelay), LIMITS.MAX_RETRY_DELAY_MS);
+                    if (obs) {
+                        safeCall(obs.hooks.onRetry, {
+                            type: 'retry', key: ctx.key, traceId: obs.traceId,
+                            timestamp: Date.now(), attempt, delayMs: delay,
+                            error: syntheticError,
+                        });
+                    }
+                    if (delay > 0)
+                        await sleep(delay, parentSignal, sleepOpts);
+                    continue;
+                }
+                return value;
             }
             catch (err) {
-                lastErr = err;
-                // Always invoke shouldRetry so observers see every failure.
-                // The return value only matters when there are attempts left.
-                const retryable = shouldRetry(err, attempt);
-                if (attempt >= max) {
-                    // Last attempt — surface the error regardless of retryable.
+                if (errors === undefined)
+                    errors = [];
+                if (errors.length < 10) {
+                    errors.push(err);
+                }
+                else {
+                    errors.shift();
+                    errors.push(err);
+                }
+                let retryable;
+                try {
+                    retryable = shouldRetry(err, attempt);
+                }
+                catch {
                     throw err;
                 }
-                if (!retryable) {
-                    // Non-retryable error — bail immediately without consuming
-                    // remaining attempts. The error surfaces exactly as-is.
+                if (attempt >= max) {
+                    if (retriedAtLeastOnce) {
+                        throw new RetryExhaustedError({
+                            key: ctx.key,
+                            attempts: attempt,
+                            lastError: err,
+                            errors: errors ?? [],
+                        });
+                    }
                     throw err;
                 }
-                // Parent aborted mid-attempt — don't sleep, bail.
+                if (!retryable)
+                    throw err;
+                retriedAtLeastOnce = true;
                 if (parentSignal.aborted)
                     throw parentSignal.reason;
-                const delay = computeDelay(attempt, opts);
+                let rawDelay;
+                try {
+                    rawDelay = backoffFn
+                        ? backoffFn(attempt, err, backoffState)
+                        : computeDelay(attempt, opts);
+                }
+                catch {
+                    rawDelay = computeDelay(attempt, opts);
+                }
+                const safeDelay = Number.isFinite(rawDelay) ? rawDelay : 0;
+                const delay = Math.min(Math.max(0, safeDelay), LIMITS.MAX_RETRY_DELAY_MS);
+                if (obs) {
+                    safeCall(obs.hooks.onRetry, {
+                        type: 'retry', key: ctx.key, traceId: obs.traceId,
+                        timestamp: Date.now(), attempt, delayMs: delay, error: err,
+                    });
+                }
                 if (delay > 0) {
-                    // Sleep is signal-aware: rejects immediately if parent aborts.
-                    await sleep(delay, parentSignal);
+                    await sleep(delay, parentSignal, sleepOpts);
                 }
             }
         }
-        // Unreachable: the loop either returns or throws on every iteration.
-        // The cast satisfies the type checker without a `throw` after the loop.
-        throw lastErr;
+        throw new Error('Actly: retryPolicy reached unreachable state');
     };
 }
-//# sourceMappingURL=retry.js.map

package/dist/policies/timeout.cjs

@@ -4,124 +4,68 @@ exports.TotalTimeoutError = exports.TimeoutError = void 0;
 exports.timeoutPolicy = timeoutPolicy;
 exports.totalTimeoutPolicy = totalTimeoutPolicy;
 const abort_js_1 = require("../utils/abort.js");
-// ─── Errors ───────────────────────────────────────────────────────────────────
-/**
- * Thrown when a per-attempt `timeout` deadline fires.
- *
- * Carries the configured `ms` so callers can log/alert precisely:
- *
- * ```ts
- * if (!result.ok && result.error instanceof TimeoutError) {
- *   console.log(`attempt timed out after ${result.error.ms}ms`)
- * }
- * ```
- */
-class TimeoutError extends Error {
-    ms;
-    constructor(ms) {
-        super(`ACT timed out after ${ms}ms`);
-        this.name = 'TimeoutError';
-        this.ms = ms;
-    }
-}
-exports.TimeoutError = TimeoutError;
-/**
- * Thrown when the operation-wide `totalTimeout` budget fires.
- *
- * Distinct from `TimeoutError` (per-attempt) so callers can `instanceof`-check
- * which deadline fired:
- *
- * ```ts
- * if (result.error instanceof TotalTimeoutError) {
- *   // whole operation budget exhausted
- * } else if (result.error instanceof TimeoutError) {
- *   // last attempt's per-attempt deadline fired
- * }
- * ```
- */
-class TotalTimeoutError extends Error {
-    ms;
-    constructor(ms) {
-        super(`ACT total timeout exceeded after ${ms}ms`);
-        this.name = 'TotalTimeoutError';
-        this.ms = ms;
-    }
-}
-exports.TotalTimeoutError = TotalTimeoutError;
-// ─── Policy ───────────────────────────────────────────────────────────────────
-/**
- * Build a timeout policy that throws `ErrorCtor` on deadline.
- *
- * # Cancellation contract
- *
- * Each invocation:
- *   1. Creates a fresh `AbortController` for this attempt.
- *   2. Arms a `setTimeout` that aborts the controller with a fresh `ErrorCtor(ms)`.
- *   3. Links the parent signal: if the parent aborts (e.g. `totalTimeout` or
- *      caller cancellation), the child aborts with the parent's reason.
- *   4. Races `fn(childSignal)` against the abort event.
- *
- * The race is critical: it ensures `act()` returns promptly even if `fn`
- * ignores the signal. The underlying `fn` may keep running in the background
- * (resource leak), but the caller is unblocked. This is the best JavaScript
- * can do without cooperation from `fn`.
- *
- * If `fn` cooperates (passes `signal` to `fetch`, `AbortController`, etc.),
- * the underlying work is cancelled properly — no leak.
- *
- * # Error attribution
- *
- * If the per-attempt timer fires, we throw `ErrorCtor(ms)` regardless of
- * what `fn` does. If the parent signal fires first, we throw the parent's
- * reason (could be `TotalTimeoutError`, an `AbortError`, or anything else).
- */
-function makeTimeoutPolicy(opts, ErrorCtor) {
-    return (fn, _ctx) => async (parentSignal) => {
+const safeCall_js_1 = require("../utils/safeCall.js");
+const errors_js_1 = require("../errors.js");
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_js_1.TimeoutError; } });
+Object.defineProperty(exports, "TotalTimeoutError", { enumerable: true, get: function () { return errors_js_1.TotalTimeoutError; } });
+function makeTimeoutPolicy(opts, errorCtor, kind) {
+    const strategy = opts.strategy ?? 'race';
+    return (fn, ctx) => async (parentSignal) => {
         const controller = new AbortController();
-        const timerError = new ErrorCtor(opts.ms);
-        // Arm the per-attempt timer. The error object is allocated once so the
-        // stack trace points here (the policy frame), not at setTimeout's
-        // internal callback.
-        const timer = setTimeout(() => controller.abort(timerError), opts.ms);
-        // Link parent -> child. If parent is already aborted, child aborts
-        // synchronously with parent's reason.
-        (0, abort_js_1.linkSignal)(parentSignal, controller);
+        const timerError = new errorCtor(opts.ms, { key: ctx.key });
+        const obs = ctx.observability;
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            if (obs) {
+                (0, safeCall_js_1.safeCall)(obs.hooks.onTimeout, {
+                    type: 'timeout', key: ctx.key, traceId: obs.traceId,
+                    timestamp: Date.now(), kind, ms: opts.ms,
+                });
+            }
+            controller.abort(timerError);
+        }, opts.ms);
+        const unlink = (0, abort_js_1.linkSignal)(parentSignal, controller);
         try {
-            // Race fn against the abort event. If fn settles first, we get its
-            // result/error. If the signal aborts first, we reject with reason.
-            //
-            // We do NOT use AbortSignal.timeout() here because we need to throw
-            // our own ErrorCtor, not a DOMException named "TimeoutError".
+            if (strategy === 'cooperative') {
+                if (parentSignal.aborted) {
+                    throw parentSignal.reason;
+                }
+                try {
+                    const value = await fn(controller.signal);
+                    return value;
+                }
+                catch (err) {
+                    if (timedOut)
+                        throw timerError;
+                    throw err;
+                }
+            }
             return await new Promise((resolve, reject) => {
                 if (controller.signal.aborted) {
                     reject(controller.signal.reason);
                     return;
                 }
-                controller.signal.addEventListener('abort', () => reject(controller.signal.reason), { once: true });
-                Promise.resolve(fn(controller.signal)).then((value) => resolve(value), (error) => reject(error));
+                const onAbort = () => reject(controller.signal.reason);
+                controller.signal.addEventListener('abort', onAbort, { once: true });
+                Promise.resolve(fn(controller.signal)).then((value) => {
+                    controller.signal.removeEventListener('abort', onAbort);
+                    resolve(value);
+                }, (error) => {
+                    controller.signal.removeEventListener('abort', onAbort);
+                    reject(error);
+                });
             });
         }
         finally {
             clearTimeout(timer);
+            unlink();
         }
     };
 }
-/**
- * Per-attempt timeout. Races `fn` against a deadline that resets on retry.
- *
- * Place this INSIDE `retryPolicy` (closer to `fn`) so each attempt has its
- * own clock.
- */
 function timeoutPolicy(opts) {
-    return makeTimeoutPolicy(opts, TimeoutError);
+    return makeTimeoutPolicy(opts, errors_js_1.TimeoutError, 'per-attempt');
 }
-/**
- * Operation-wide timeout. Races the ENTIRE chain (all retry attempts +
- * delays) against a hard budget that does NOT reset.
- *
- * Place this as the OUTERMOST policy so the clock starts before any other
- * policy runs and stops regardless of what the inner chain is doing.
- */
 function totalTimeoutPolicy(opts) {
-    return makeTimeoutPolicy(opts, TotalTimeoutError);
+    return makeTimeoutPolicy(opts, errors_js_1.TotalTimeoutError, 'total');
 }