actly 1.1.5 → 1.2.0

package/dist/policies/dedupe.d.ts

@@ -2,34 +2,16 @@ import type { PolicyApplier, DedupeOptions } from '../types/index.js';
 /**
  * Collapse concurrent calls that share the same key into one in-flight Promise.
  *
- * # How it works
- *
- * The first caller (originator) starts the work and stores
- * `{ promise, meta }` in the store under `dedupe:<key>`. Every subsequent
- * caller that arrives before the promise settles receives the SAME promise
- * — no duplicate work.
- *
- * # Shared `meta` (fixes v1.0 trade-off)
- *
- * The originator's `ctx.meta` reference is stored alongside the promise.
- * Inner policies (e.g. `retryPolicy`) mutate it as they run. After the
- * promise settles, joiners copy `attempts` and `source` from the shared
- * meta into their own `ctx.meta`. This means a joiner's `ActResult.attempts`
- * reflects the real effort (e.g. `3` if the originator retried twice), not
- * the misleading default of `1`.
- *
- * # Abort safety (fixes hung-fn block)
- *
- * Joiners race the in-flight promise against their own AbortSignal via
- * `raceAbort`. If a joiner's signal aborts (e.g. their `totalTimeout`
- * fires), they reject immediately — they don't have to wait for the
- * originator to finish. The originator's promise continues in the
- * background for any other joiners that haven't aborted.
- *
- * If `inflightTtl` is set, the store entry is also TTL'd: if the
- * originator never settles, new callers can start fresh after the TTL
- * expires (the original promise still leaks unless an outer timeout
- * fires, but new callers aren't blocked).
+ * # Properties
+ *
+ *  - **Generation-safe cleanup**: stale originators never delete newer
+ *    entries when `inflightTtl` triggers replacement.
+ *  - **Joiner isolation**: originator's caller-signal abort does NOT
+ *    propagate to joiners. Each joiner races the shared in-flight promise
+ *    against their OWN signal only.
+ *  - **Truthful joiner attempts**: joiners that abort before the originator
+ *    settles report `attempts: 0` (they did no work), not the originator's
+ *    in-progress count.
  *
  * # INVARIANT: requires SyncStateStore
  *

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

@@ -1 +1 @@
-{"version":3,"file":"dedupe.d.ts","sourceRoot":"","sources":["../../src/policies/dedupe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAqB3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAE,aAAiC,GAAG,aAAa,CAAC,CAAC,CAAC,CAkDzF"}
+{"version":3,"file":"dedupe.d.ts","sourceRoot":"","sources":["../../src/policies/dedupe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,aAAa,EAAE,MAAM,mBAAmB,CAAA;AA6D3F;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAE,aAAiC,GAAG,aAAa,CAAC,CAAC,CAAC,CAqFzF"}

package/dist/policies/dedupe.js

@@ -2,37 +2,29 @@ import { REQUIRES_SYNC_STORE } from '../core/executor.js';
 import { raceAbort } from '../utils/abort.js';
 // Namespace so dedupe keys never collide with cache keys in the shared store.
 const NS = 'dedupe:';
+/**
+ * Module-level generation counter. Monotonic — guarantees uniqueness
+ * across the lifetime of the process. Wraps at `Number.MAX_SAFE_INTEGER`
+ * (which would take ~285 000 years at 1M increments/sec).
+ */
+let generationCounter = 0;
+function nextGeneration() {
+    generationCounter = (generationCounter + 1) % Number.MAX_SAFE_INTEGER;
+    return generationCounter;
+}
 /**
  * Collapse concurrent calls that share the same key into one in-flight Promise.
  *
- * # How it works
- *
- * The first caller (originator) starts the work and stores
- * `{ promise, meta }` in the store under `dedupe:<key>`. Every subsequent
- * caller that arrives before the promise settles receives the SAME promise
- * — no duplicate work.
- *
- * # Shared `meta` (fixes v1.0 trade-off)
- *
- * The originator's `ctx.meta` reference is stored alongside the promise.
- * Inner policies (e.g. `retryPolicy`) mutate it as they run. After the
- * promise settles, joiners copy `attempts` and `source` from the shared
- * meta into their own `ctx.meta`. This means a joiner's `ActResult.attempts`
- * reflects the real effort (e.g. `3` if the originator retried twice), not
- * the misleading default of `1`.
- *
- * # Abort safety (fixes hung-fn block)
+ * # Properties
  *
- * Joiners race the in-flight promise against their own AbortSignal via
- * `raceAbort`. If a joiner's signal aborts (e.g. their `totalTimeout`
- * fires), they reject immediately — they don't have to wait for the
- * originator to finish. The originator's promise continues in the
- * background for any other joiners that haven't aborted.
- *
- * If `inflightTtl` is set, the store entry is also TTL'd: if the
- * originator never settles, new callers can start fresh after the TTL
- * expires (the original promise still leaks unless an outer timeout
- * fires, but new callers aren't blocked).
+ *  - **Generation-safe cleanup**: stale originators never delete newer
+ *    entries when `inflightTtl` triggers replacement.
+ *  - **Joiner isolation**: originator's caller-signal abort does NOT
+ *    propagate to joiners. Each joiner races the shared in-flight promise
+ *    against their OWN signal only.
+ *  - **Truthful joiner attempts**: joiners that abort before the originator
+ *    settles report `attempts: 0` (they did no work), not the originator's
+ *    in-progress count.
  *
  * # INVARIANT: requires SyncStateStore
  *
@@ -51,34 +43,71 @@ export function dedupePolicy(opts = { enabled: true }) {
         const syncCtx = ctx;
         return async (signal) => {
             const key = NS + syncCtx.key;
-            // Fast path: an in-flight promise already exists. Join it.
-            // raceAbort ensures we don't block on a hung originator if our own
-            // signal aborts.
+            // ─── Fast path: an in-flight promise already exists. Join it. ──────
+            //
+            // The joiner races the in-flight promise against THEIR OWN signal.
+            // They do NOT inherit the originator's signal state — if the
+            // originator's caller cancels, joiners continue waiting (or get
+            // the eventual settled value).
             const existing = syncCtx.store.get(key);
             if (existing) {
                 try {
                     const value = await raceAbort(existing.promise, signal);
-                    return value;
-                }
-                finally {
-                    // Copy the originator's final meta into our own, regardless of
-                    // success or failure. By the time `existing.promise` has settled
-                    // (or our signal aborted), the originator's retry loop has set
-                    // the final attempt count.
+                    // Success — copy originator's final meta (attempts, source)
+                    // so the joiner's ActResult reflects the real effort.
                     syncCtx.meta.attempts = existing.meta.attempts;
                     syncCtx.meta.source = existing.meta.source;
+                    return value;
+                }
+                catch (err) {
+                    // Joiner either aborted (their own signal) or got the
+                    // originator's settled error.
+                    if (signal.aborted) {
+                        // Joiner's own signal aborted before originator settled.
+                        // They did no work — report `attempts: 0` (truthful).
+                        syncCtx.meta.attempts = 0;
+                        // source stays 'fresh' (default) — joiner didn't read from cache
+                    }
+                    else {
+                        // Originator settled with failure — copy its final meta.
+                        syncCtx.meta.attempts = existing.meta.attempts;
+                        syncCtx.meta.source = existing.meta.source;
+                    }
+                    throw err;
                 }
             }
-            // Originator path: start the work and publish the promise.
+            // ─── Originator path: start the work and publish the promise. ──────
             //
-            // We race fn against `signal` so that if our own signal aborts while
-            // fn is pending, we reject (and the .finally cleans up the store).
-            // The stored promise is the RACED one — joiners see the same
-            // rejection if they join before cleanup.
-            const promise = raceAbort(Promise.resolve(fn(signal)), signal).finally(() => syncCtx.store.delete(key));
-            const entry = { promise, meta: syncCtx.meta };
+            // The stored promise is the RAW fn(signal) — NOT raceAbort-wrapped.
+            // This is critical: if we stored raceAbort(fn, signal), an
+            // originator signal abort would cause the stored promise to reject,
+            // which would propagate to all joiners. Instead:
+            //   - stored: raw fn(signal) — joiners await this
+            //   - originator's await: raceAbort(stored, signal) — originator
+            //     can bail out on their own signal without affecting joiners
+            const generation = nextGeneration();
+            const rawPromise = Promise.resolve(fn(signal));
+            const entry = {
+                promise: rawPromise,
+                meta: syncCtx.meta,
+                generation,
+            };
             syncCtx.store.set(key, entry, inflightTtl);
-            return promise;
+            // Cleanup on settle: only delete if generation matches. If a newer
+            // originator has replaced this entry (because inflightTtl expired),
+            // our cleanup is a no-op — the newer entry stays.
+            const cleanup = () => {
+                const current = syncCtx.store.get(key);
+                if (current && current.generation === generation) {
+                    syncCtx.store.delete(key);
+                }
+            };
+            // Attach cleanup to the RAW promise (not the raceAbort-wrapped one)
+            // so cleanup runs whenever fn settles, regardless of originator abort.
+            rawPromise.then(cleanup, cleanup);
+            // Originator races the raw promise against their own signal —
+            // they can bail out without affecting joiners.
+            return raceAbort(rawPromise, signal);
         };
     };
     applier[REQUIRES_SYNC_STORE] = true;

package/dist/policies/dedupe.js.map

@@ -1 +1 @@
-{"version":3,"file":"dedupe.js","sourceRoot":"","sources":["../../src/policies/dedupe.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAE7C,8EAA8E;AAC9E,MAAM,EAAE,GAAG,SAAS,CAAA;AAepB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,UAAU,YAAY,CAAI,OAAsB,EAAE,OAAO,EAAE,IAAI,EAAE;IACrE,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAA;IAEpC,MAAM,OAAO,GAAG,CAAC,EAAY,EAAE,GAAkB,EAAY,EAAE;QAC7D,yEAAyE;QACzE,8CAA8C;QAC9C,MAAM,OAAO,GAAG,GAAoB,CAAA;QAEpC,OAAO,KAAK,EAAE,MAAmB,EAAE,EAAE;YACnC,MAAM,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,CAAA;YAE5B,2DAA2D;YAC3D,mEAAmE;YACnE,iBAAiB;YACjB,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAiB,GAAG,CAAC,CAAA;YACvD,IAAI,QAAQ,EAAE,CAAC;gBACb,IAAI,CAAC;oBACH,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;oBACvD,OAAO,KAAK,CAAA;gBACd,CAAC;wBAAS,CAAC;oBACT,+DAA+D;oBAC/D,iEAAiE;oBACjE,+DAA+D;oBAC/D,2BAA2B;oBAC3B,OAAO,CAAC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAA;oBAC9C,OAAO,CAAC,IAAI,CAAC,MAAM,GAAK,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAA;gBAC9C,CAAC;YACH,CAAC;YAED,2DAA2D;YAC3D,EAAE;YACF,qEAAqE;YACrE,mEAAmE;YACnE,6DAA6D;YAC7D,yCAAyC;YACzC,MAAM,OAAO,GAAG,SAAS,CACvB,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAC3B,MAAM,CACP,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;YAE1C,MAAM,KAAK,GAAmB,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,CAAA;YAC7D,OAAO,CAAC,KAAK,CAAC,GAAG,CAAiB,GAAG,EAAE,KAAK,EAAE,WAAW,CAAC,CAAA;YAC1D,OAAO,OAAO,CAAA;QAChB,CAAC,CAAA;IACH,CAAC,CAGA;IAAC,OAA+D,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAA;IAE7F,OAAO,OAAO,CAAA;AAChB,CAAC"}
+{"version":3,"file":"dedupe.js","sourceRoot":"","sources":["../../src/policies/dedupe.ts"],"names":[],"mappings":"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"}

package/dist/policies/rateLimit.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rateLimitPolicy = rateLimitPolicy;
+const executor_js_1 = require("../core/executor.js");
+const errors_js_1 = require("../errors.js");
+const NS = 'rl:';
+function getState(store, key) {
+    return store.get(NS + key) ?? { timestamps: [] };
+}
+function setState(store, key, state) {
+    store.set(NS + key, state);
+}
+function rateLimitPolicy(opts) {
+    const maxCalls = Math.max(1, Math.floor(opts.maxCalls));
+    const windowMs = opts.windowMs;
+    const applier = (fn, ctx) => {
+        const syncCtx = ctx;
+        return async (signal) => {
+            const key = syncCtx.key;
+            const now = Date.now();
+            const state = getState(syncCtx.store, key);
+            const cutoff = now - windowMs;
+            state.timestamps = state.timestamps.filter(t => t > cutoff);
+            if (state.timestamps.length >= maxCalls) {
+                setState(syncCtx.store, key, state);
+                throw new errors_js_1.RateLimitError(key, maxCalls, windowMs);
+            }
+            state.timestamps.push(now);
+            setState(syncCtx.store, key, state);
+            return fn(signal);
+        };
+    };
+    applier[executor_js_1.REQUIRES_SYNC_STORE] = true;
+    return applier;
+}

package/dist/policies/rateLimit.d.ts

@@ -0,0 +1,3 @@
+import type { PolicyApplier, RateLimitOptions } from '../types/index.js';
+export declare function rateLimitPolicy<T>(opts: RateLimitOptions): PolicyApplier<T>;
+//# sourceMappingURL=rateLimit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rateLimit.d.ts","sourceRoot":"","sources":["../../src/policies/rateLimit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAmB9F,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,GAAG,aAAa,CAAC,CAAC,CAAC,CA6B3E"}

package/dist/policies/rateLimit.js

@@ -0,0 +1,33 @@
+import { REQUIRES_SYNC_STORE } from '../core/executor.js';
+import { RateLimitError } from '../errors.js';
+const NS = 'rl:';
+function getState(store, key) {
+    return store.get(NS + key) ?? { timestamps: [] };
+}
+function setState(store, key, state) {
+    store.set(NS + key, state);
+}
+export function rateLimitPolicy(opts) {
+    const maxCalls = Math.max(1, Math.floor(opts.maxCalls));
+    const windowMs = opts.windowMs;
+    const applier = (fn, ctx) => {
+        const syncCtx = ctx;
+        return async (signal) => {
+            const key = syncCtx.key;
+            const now = Date.now();
+            const state = getState(syncCtx.store, key);
+            const cutoff = now - windowMs;
+            state.timestamps = state.timestamps.filter(t => t > cutoff);
+            if (state.timestamps.length >= maxCalls) {
+                setState(syncCtx.store, key, state);
+                throw new RateLimitError(key, maxCalls, windowMs);
+            }
+            state.timestamps.push(now);
+            setState(syncCtx.store, key, state);
+            return fn(signal);
+        };
+    };
+    applier[REQUIRES_SYNC_STORE] = true;
+    return applier;
+}
+//# sourceMappingURL=rateLimit.js.map

package/dist/policies/rateLimit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rateLimit.js","sourceRoot":"","sources":["../../src/policies/rateLimit.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,MAAM,EAAE,GAAG,KAAK,CAAA;AAMhB,SAAS,QAAQ,CAAC,KAAqB,EAAE,GAAW;IAClD,OAAO,KAAK,CAAC,GAAG,CAAiB,EAAE,GAAG,GAAG,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,CAAA;AAClE,CAAC;AAED,SAAS,QAAQ,CAAC,KAAqB,EAAE,GAAW,EAAE,KAAqB;IACzE,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,EAAE,KAAK,CAAC,CAAA;AAC5B,CAAC;AAED,MAAM,UAAU,eAAe,CAAI,IAAsB;IACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAA;IACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAA;IAE9B,MAAM,OAAO,GAAG,CAAC,EAAY,EAAE,GAAkB,EAAY,EAAE;QAC7D,MAAM,OAAO,GAAG,GAA+D,CAAA;QAE/E,OAAO,KAAK,EAAE,MAAmB,EAAE,EAAE;YACnC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAA;YACvB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;YACtB,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;YAE1C,MAAM,MAAM,GAAG,GAAG,GAAG,QAAQ,CAAA;YAC7B,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,CAAA;YAE3D,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,IAAI,QAAQ,EAAE,CAAC;gBACxC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA;gBACnC,MAAM,IAAI,cAAc,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;YACnD,CAAC;YAED,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YAC1B,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA;YAEnC,OAAO,EAAE,CAAC,MAAM,CAAC,CAAA;QACnB,CAAC,CAAA;IACH,CAAC,CAEA;IAAC,OAA+D,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAA;IAC7F,OAAO,OAAO,CAAA;AAChB,CAAC"}

package/dist/policies/retry.cjs

@@ -3,6 +3,7 @@ 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");
+const errors_js_1 = require("../errors.js");
 // ─── Default predicate ────────────────────────────────────────────────────────
 /**
  * Default `shouldRetry`: retry on any error EXCEPT abort errors.
@@ -47,41 +48,77 @@ function retryPolicy(opts) {
     const max = Math.max(1, Math.floor(opts.attempts));
     const shouldRetry = opts.shouldRetry ?? defaultShouldRetry;
     return (fn, ctx) => async (parentSignal) => {
+        const errors = [];
         let lastErr;
+        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 {
+                // Emit onAttempt before each attempt. (We could emit
+                // after with duration/error, but before lets observers track
+                // in-flight attempts in real time.)
+                if (obs) {
+                    obs.hooks.onAttempt?.({
+                        type: 'attempt', key: ctx.key, traceId: obs.traceId,
+                        timestamp: attemptStart, attempt,
+                    });
+                }
                 return await fn(parentSignal);
             }
             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);
+                errors.push(err);
+                // Invoke shouldRetry. If the predicate throws, treat as "don't retry"
+                // and surface the original fn error (not the predicate error).
+                let retryable;
+                try {
+                    retryable = shouldRetry(err, attempt);
+                }
+                catch {
+                    // Predicate threw — don't retry, surface original error
+                    throw err;
+                }
                 if (attempt >= max) {
-                    // Last attempt — surface the error regardless of retryable.
+                    // Last attempt. If we retried at least once (predicate
+                    // allowed retries), wrap in RetryExhaustedError for context.
+                    if (retriedAtLeastOnce) {
+                        throw new errors_js_1.RetryExhaustedError({
+                            key: ctx.key,
+                            attempts: attempt,
+                            lastError: err,
+                            errors,
+                        });
+                    }
                     throw err;
                 }
                 if (!retryable) {
-                    // Non-retryable error — bail immediately without consuming
-                    // remaining attempts. The error surfaces exactly as-is.
+                    // Non-retryable error — bail immediately.
                     throw err;
                 }
+                // Mark that we retried at least once — affects final wrap.
+                retriedAtLeastOnce = true;
                 // Parent aborted mid-attempt — don't sleep, bail.
                 if (parentSignal.aborted)
                     throw parentSignal.reason;
                 const delay = (0, backoff_js_1.computeDelay)(attempt, opts);
+                // Emit onRetry before the delay sleep.
+                if (obs) {
+                    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);
                 }
             }
         }
         // Unreachable: the loop either returns or throws on every iteration.
-        // The cast satisfies the type checker without a `throw` after the loop.
         throw lastErr;
     };
 }

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;AAqB1F;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC,CAAC,CAAC,CAuFnE"}

package/dist/policies/retry.js

@@ -1,5 +1,6 @@
 import { computeDelay } from '../utils/backoff.js';
 import { isAbortError, sleep } from '../utils/abort.js';
+import { RetryExhaustedError } from '../errors.js';
 // ─── Default predicate ────────────────────────────────────────────────────────
 /**
  * Default `shouldRetry`: retry on any error EXCEPT abort errors.
@@ -44,41 +45,77 @@ export function retryPolicy(opts) {
     const max = Math.max(1, Math.floor(opts.attempts));
     const shouldRetry = opts.shouldRetry ?? defaultShouldRetry;
     return (fn, ctx) => async (parentSignal) => {
+        const errors = [];
         let lastErr;
+        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 {
+                // Emit onAttempt before each attempt. (We could emit
+                // after with duration/error, but before lets observers track
+                // in-flight attempts in real time.)
+                if (obs) {
+                    obs.hooks.onAttempt?.({
+                        type: 'attempt', key: ctx.key, traceId: obs.traceId,
+                        timestamp: attemptStart, attempt,
+                    });
+                }
                 return await fn(parentSignal);
             }
             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);
+                errors.push(err);
+                // Invoke shouldRetry. If the predicate throws, treat as "don't retry"
+                // and surface the original fn error (not the predicate error).
+                let retryable;
+                try {
+                    retryable = shouldRetry(err, attempt);
+                }
+                catch {
+                    // Predicate threw — don't retry, surface original error
+                    throw err;
+                }
                 if (attempt >= max) {
-                    // Last attempt — surface the error regardless of retryable.
+                    // Last attempt. If we retried at least once (predicate
+                    // allowed retries), wrap in RetryExhaustedError for context.
+                    if (retriedAtLeastOnce) {
+                        throw new RetryExhaustedError({
+                            key: ctx.key,
+                            attempts: attempt,
+                            lastError: err,
+                            errors,
+                        });
+                    }
                     throw err;
                 }
                 if (!retryable) {
-                    // Non-retryable error — bail immediately without consuming
-                    // remaining attempts. The error surfaces exactly as-is.
+                    // Non-retryable error — bail immediately.
                     throw err;
                 }
+                // Mark that we retried at least once — affects final wrap.
+                retriedAtLeastOnce = true;
                 // Parent aborted mid-attempt — don't sleep, bail.
                 if (parentSignal.aborted)
                     throw parentSignal.reason;
                 const delay = computeDelay(attempt, opts);
+                // Emit onRetry before the delay sleep.
+                if (obs) {
+                    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);
                 }
             }
         }
         // Unreachable: the loop either returns or throws on every iteration.
-        // The cast satisfies the type checker without a `throw` after the loop.
         throw lastErr;
     };
 }

package/dist/policies/retry.js.map

@@ -1 +1 @@
-{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../src/policies/retry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEvD,iFAAiF;AAEjF;;;;;;;GAOG;AACH,SAAS,kBAAkB,CAAC,KAAc,EAAE,QAAgB;IAC1D,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAA;AAC7B,CAAC;AAED,iFAAiF;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,WAAW,CAAI,IAAkB;IAC/C,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAA;IAClD,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,kBAAkB,CAAA;IAE1D,OAAO,CAAC,EAAY,EAAE,GAAkB,EAAY,EAAE,CACpD,KAAK,EAAE,YAAyB,EAAE,EAAE;QAClC,IAAI,OAAgB,CAAA;QAEpB,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,GAAG,EAAE,OAAO,EAAE,EAAE,CAAC;YAChD,iEAAiE;YACjE,IAAI,YAAY,CAAC,OAAO;gBAAE,MAAM,YAAY,CAAC,MAAM,CAAA;YAEnD,GAAG,CAAC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;YAE3B,IAAI,CAAC;gBACH,OAAO,MAAM,EAAE,CAAC,YAAY,CAAC,CAAA;YAC/B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,GAAG,GAAG,CAAA;gBAEb,4DAA4D;gBAC5D,8DAA8D;gBAC9D,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;gBAE3C,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;oBACnB,4DAA4D;oBAC5D,MAAM,GAAG,CAAA;gBACX,CAAC;gBAED,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,2DAA2D;oBAC3D,wDAAwD;oBACxD,MAAM,GAAG,CAAA;gBACX,CAAC;gBAED,kDAAkD;gBAClD,IAAI,YAAY,CAAC,OAAO;oBAAE,MAAM,YAAY,CAAC,MAAM,CAAA;gBAEnD,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;gBACzC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;oBACd,+DAA+D;oBAC/D,MAAM,KAAK,CAAC,KAAK,EAAE,YAAY,CAAC,CAAA;gBAClC,CAAC;YACH,CAAC;QACH,CAAC;QAED,qEAAqE;QACrE,wEAAwE;QACxE,MAAM,OAAO,CAAA;IACf,CAAC,CAAA;AACL,CAAC"}
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../src/policies/retry.ts"],"names":[],"mappings":"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"}

package/dist/policies/timeout.cjs

@@ -4,50 +4,9 @@ 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;
+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; } });
 // ─── Policy ───────────────────────────────────────────────────────────────────
 /**
  * Build a timeout policy that throws `ErrorCtor` on deadline.
@@ -76,16 +35,21 @@ exports.TotalTimeoutError = TotalTimeoutError;
  * reason (could be `TotalTimeoutError`, an `AbortError`, or anything else).
  */
 function makeTimeoutPolicy(opts, ErrorCtor) {
-    return (fn, _ctx) => async (parentSignal) => {
+    return (fn, ctx) => async (parentSignal) => {
         const controller = new AbortController();
-        const timerError = new ErrorCtor(opts.ms);
+        // Pass key to the error ctor for better debugging context.
+        const timerError = new ErrorCtor(opts.ms, { key: ctx.key });
         // 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);
+        // NOTE: do NOT `unref()` this timer. The timeout IS the operation
+        // the caller is awaiting. unref'ing would let Node exit the process
+        // while a timeout was pending — silently dropping the operation.
+        // The timer is cleared in the finally block below.
+        // Link parent → child. Capture the unlink function so we can clean
+        // up the listener on success path (contract).
+        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.
@@ -97,12 +61,20 @@ function makeTimeoutPolicy(opts, ErrorCtor) {
                     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();
         }
     };
 }
@@ -113,7 +85,7 @@ function makeTimeoutPolicy(opts, ErrorCtor) {
  * own clock.
  */
 function timeoutPolicy(opts) {
-    return makeTimeoutPolicy(opts, TimeoutError);
+    return makeTimeoutPolicy(opts, errors_js_1.TimeoutError);
 }
 /**
  * Operation-wide timeout. Races the ENTIRE chain (all retry attempts +
@@ -123,5 +95,5 @@ function timeoutPolicy(opts) {
  * 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);
 }