flowshield 1.0.0

package/dist/esm/index.js

@@ -0,0 +1,13 @@
+// ─── Policies ───────────────────────────────────────────────────────────────
+export { retry } from './policies/retry.js';
+export { circuitBreaker } from './policies/circuit-breaker.js';
+export { timeout } from './policies/timeout.js';
+export { bulkhead } from './policies/bulkhead.js';
+export { fallback } from './policies/fallback.js';
+export { rateLimiter } from './policies/rate-limiter.js';
+export { hedge } from './policies/hedge.js';
+export { cache } from './policies/cache.js';
+// ─── Composition ────────────────────────────────────────────────────────────
+export { pipe, wrap } from './compose.js';
+export { FlowShieldError, TimeoutError, CircuitOpenError, BulkheadRejectedError, RateLimitExceededError, RetryExhaustedError, } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE5C,+EAA+E;AAC/E,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAqB1C,OAAO,EACL,eAAe,EACf,YAAY,EACZ,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,YAAY,CAAC"}

package/dist/esm/policies/bulkhead.js

@@ -0,0 +1,72 @@
+import { BulkheadRejectedError } from '../types.js';
+import { assertNonNegative, assertPositiveInteger } from '../utils.js';
+const DEFAULTS = {
+    maxConcurrent: 10,
+    maxQueue: 0,
+};
+/**
+ * Creates a bulkhead (concurrency limiter) policy that limits the number
+ * of concurrent executions of the wrapped operation.
+ *
+ * Returns an object with `execute` (the policy function) and `handle`
+ * (an interface to inspect the bulkhead's running / queued counts).
+ *
+ * @example
+ * ```ts
+ * const bh = bulkhead({ maxConcurrent: 5, maxQueue: 10 });
+ * const result = await bh.execute(() => fetch('/api/data'));
+ * console.log(bh.handle.running); // number of active calls
+ * ```
+ */
+export function bulkhead(options = {}) {
+    const maxConcurrent = options.maxConcurrent ?? DEFAULTS.maxConcurrent;
+    const maxQueue = options.maxQueue ?? DEFAULTS.maxQueue;
+    assertPositiveInteger(maxConcurrent, 'maxConcurrent');
+    assertNonNegative(maxQueue, 'maxQueue');
+    let running = 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const queue = [];
+    function dequeue() {
+        while (running < maxConcurrent && queue.length > 0) {
+            const entry = queue.shift();
+            run(entry);
+        }
+    }
+    function run(entry) {
+        running++;
+        entry
+            .fn()
+            .then((value) => {
+            entry.resolve(value);
+        }, (error) => {
+            entry.reject(error);
+        })
+            .finally(() => {
+            running--;
+            dequeue();
+        });
+    }
+    const handle = {
+        get running() {
+            return running;
+        },
+        get queued() {
+            return queue.length;
+        },
+    };
+    function execute(fn) {
+        if (running < maxConcurrent) {
+            return new Promise((resolve, reject) => {
+                run({ fn, resolve, reject });
+            });
+        }
+        if (queue.length >= maxQueue) {
+            return Promise.reject(new BulkheadRejectedError());
+        }
+        return new Promise((resolve, reject) => {
+            queue.push({ fn, resolve, reject });
+        });
+    }
+    return { execute, handle };
+}
+//# sourceMappingURL=bulkhead.js.map

package/dist/esm/policies/bulkhead.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkhead.js","sourceRoot":"","sources":["../../../src/policies/bulkhead.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEvE,MAAM,QAAQ,GAAG;IACf,aAAa,EAAE,EAAE;IACjB,QAAQ,EAAE,CAAC;CACZ,CAAC;AAQF;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,QAAQ,CAAC,UAA2B,EAAE;IAIpD,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,QAAQ,CAAC,aAAa,CAAC;IACtE,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,QAAQ,CAAC,QAAQ,CAAC;IAEvD,qBAAqB,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC;IACtD,iBAAiB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IAExC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,8DAA8D;IAC9D,MAAM,KAAK,GAAsB,EAAE,CAAC;IAEpC,SAAS,OAAO;QACd,OAAO,OAAO,GAAG,aAAa,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,EAAG,CAAC;YAC7B,GAAG,CAAC,KAAK,CAAC,CAAC;QACb,CAAC;IACH,CAAC;IAED,SAAS,GAAG,CAAI,KAAoB;QAClC,OAAO,EAAE,CAAC;QACV,KAAK;aACF,EAAE,EAAE;aACJ,IAAI,CACH,CAAC,KAAK,EAAE,EAAE;YACR,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC,EACD,CAAC,KAAK,EAAE,EAAE;YACR,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC,CACF;aACA,OAAO,CAAC,GAAG,EAAE;YACZ,OAAO,EAAE,CAAC;YACV,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;IACP,CAAC;IAED,MAAM,MAAM,GAAmB;QAC7B,IAAI,OAAO;YACT,OAAO,OAAO,CAAC;QACjB,CAAC;QACD,IAAI,MAAM;YACR,OAAO,KAAK,CAAC,MAAM,CAAC;QACtB,CAAC;KACF,CAAC;IAEF,SAAS,OAAO,CAAI,EAAoB;QACtC,IAAI,OAAO,GAAG,aAAa,EAAE,CAAC;YAC5B,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACxC,GAAG,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;YAC/B,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,KAAK,CAAC,MAAM,IAAI,QAAQ,EAAE,CAAC;YAC7B,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,qBAAqB,EAAE,CAAC,CAAC;QACrD,CAAC;QAED,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACxC,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AAC7B,CAAC"}

package/dist/esm/policies/cache.js

@@ -0,0 +1,96 @@
+import { assertPositive } from '../utils.js';
+const DEFAULTS = {
+    ttl: 60_000,
+    staleWhileRevalidate: false,
+};
+/**
+ * Creates a TTL-based cache policy that memoizes the result of the wrapped
+ * async operation. Supports stale-while-revalidate for background refresh.
+ *
+ * Returns an object with `execute` (the policy function) and `handle`
+ * (an interface to inspect / invalidate the cache).
+ *
+ * @example
+ * ```ts
+ * const c = cache({ ttl: 10_000 });
+ * const result = await c.execute(() => fetch('/api/data').then(r => r.json()));
+ * ```
+ */
+export function cache(options = {}) {
+    const ttl = options.ttl ?? DEFAULTS.ttl;
+    const staleWhileRevalidate = options.staleWhileRevalidate ?? DEFAULTS.staleWhileRevalidate;
+    const keyFn = options.keyFn ?? (() => 'default');
+    const onEvict = options.onEvict;
+    assertPositive(ttl, 'ttl');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const store = new Map();
+    function evict(key) {
+        const entry = store.get(key);
+        if (entry) {
+            store.delete(key);
+            onEvict?.(key, entry.value);
+        }
+    }
+    const handle = {
+        get size() {
+            return store.size;
+        },
+        invalidate(key) {
+            if (key !== undefined) {
+                evict(key);
+            }
+            else {
+                // Invalidate default key
+                evict(keyFn());
+            }
+        },
+        clear() {
+            if (onEvict) {
+                for (const [k, v] of store) {
+                    onEvict(k, v.value);
+                }
+            }
+            store.clear();
+        },
+    };
+    async function execute(fn) {
+        const key = keyFn();
+        const now = Date.now();
+        const entry = store.get(key);
+        if (entry) {
+            if (now < entry.expiresAt) {
+                // Fresh cache hit
+                return entry.value;
+            }
+            if (staleWhileRevalidate && !entry.stale) {
+                // Return stale value and revalidate in background
+                entry.stale = true;
+                fn()
+                    .then((value) => {
+                    store.set(key, {
+                        value,
+                        expiresAt: Date.now() + ttl,
+                        stale: false,
+                    });
+                })
+                    .catch(() => {
+                    // Revalidation failed — keep stale value, lift stale flag
+                    // so next request tries again
+                    entry.stale = false;
+                });
+                return entry.value;
+            }
+            // Expired and not SWR — evict and re-fetch
+            evict(key);
+        }
+        const value = await fn();
+        store.set(key, {
+            value,
+            expiresAt: now + ttl,
+            stale: false,
+        });
+        return value;
+    }
+    return { execute, handle };
+}
+//# sourceMappingURL=cache.js.map

package/dist/esm/policies/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../src/policies/cache.ts"],"names":[],"mappings":"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"}

package/dist/esm/policies/circuit-breaker.js

@@ -0,0 +1,107 @@
+import { CircuitOpenError } from '../types.js';
+import { assertPositiveInteger, assertPositive } from '../utils.js';
+const DEFAULTS = {
+    failureThreshold: 5,
+    successThreshold: 1,
+    resetTimeout: 30_000,
+};
+/**
+ * Creates a circuit breaker policy that prevents calls to a failing service.
+ *
+ * Returns an object with `execute` (the policy function) and `handle`
+ * (an interface to inspect / reset the breaker state).
+ *
+ * @example
+ * ```ts
+ * const cb = circuitBreaker({ failureThreshold: 3, resetTimeout: 10_000 });
+ * const result = await cb.execute(() => fetch('/api/health'));
+ * console.log(cb.handle.state); // 'closed'
+ * ```
+ */
+export function circuitBreaker(options = {}) {
+    const failureThreshold = options.failureThreshold ?? DEFAULTS.failureThreshold;
+    const successThreshold = options.successThreshold ?? DEFAULTS.successThreshold;
+    const resetTimeout = options.resetTimeout ?? DEFAULTS.resetTimeout;
+    assertPositiveInteger(failureThreshold, 'failureThreshold');
+    assertPositiveInteger(successThreshold, 'successThreshold');
+    assertPositive(resetTimeout, 'resetTimeout');
+    let state = 'closed';
+    let failureCount = 0;
+    let successCount = 0;
+    let nextAttemptTime = 0;
+    function trip() {
+        state = 'open';
+        nextAttemptTime = Date.now() + resetTimeout;
+        options.onOpen?.();
+    }
+    function resetState() {
+        state = 'closed';
+        failureCount = 0;
+        successCount = 0;
+        options.onClose?.();
+    }
+    function tryTransitionToHalfOpen() {
+        if (state === 'open' && Date.now() >= nextAttemptTime) {
+            state = 'half-open';
+            successCount = 0;
+            options.onHalfOpen?.();
+            return true;
+        }
+        return false;
+    }
+    const handle = {
+        get state() {
+            // Auto-transition if timer has elapsed
+            if (state === 'open' && Date.now() >= nextAttemptTime) {
+                state = 'half-open';
+                successCount = 0;
+                options.onHalfOpen?.();
+            }
+            return state;
+        },
+        get failureCount() {
+            return failureCount;
+        },
+        get successCount() {
+            return successCount;
+        },
+        reset() {
+            resetState();
+        },
+    };
+    async function execute(fn) {
+        if (state === 'open') {
+            if (!tryTransitionToHalfOpen()) {
+                throw new CircuitOpenError();
+            }
+        }
+        try {
+            const result = await fn();
+            // Success handling
+            if (state === 'half-open') {
+                successCount++;
+                if (successCount >= successThreshold) {
+                    resetState();
+                }
+            }
+            else {
+                // In closed state, reset failure count on success
+                failureCount = 0;
+            }
+            return result;
+        }
+        catch (error) {
+            failureCount++;
+            if (state === 'half-open') {
+                // Any failure in half-open trips back to open
+                trip();
+            }
+            else if (failureCount >= failureThreshold) {
+                trip();
+            }
+            throw error;
+        }
+    }
+    return { execute, handle };
+}
+//# sourceMappingURL=circuit-breaker.js.map

package/dist/esm/policies/circuit-breaker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.js","sourceRoot":"","sources":["../../../src/policies/circuit-breaker.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAEpE,MAAM,QAAQ,GAAG;IACf,gBAAgB,EAAE,CAAC;IACnB,gBAAgB,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM;CACrB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAAC,UAAiC,EAAE;IAIhE,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,IAAI,QAAQ,CAAC,gBAAgB,CAAC;IAC/E,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,IAAI,QAAQ,CAAC,gBAAgB,CAAC;IAC/E,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,IAAI,QAAQ,CAAC,YAAY,CAAC;IAEnE,qBAAqB,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAAC;IAC5D,qBAAqB,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAAC;IAC5D,cAAc,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;IAE7C,IAAI,KAAK,GAAiB,QAAQ,CAAC;IACnC,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,eAAe,GAAG,CAAC,CAAC;IAExB,SAAS,IAAI;QACX,KAAK,GAAG,MAAM,CAAC;QACf,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,YAAY,CAAC;QAC5C,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IACrB,CAAC;IAED,SAAS,UAAU;QACjB,KAAK,GAAG,QAAQ,CAAC;QACjB,YAAY,GAAG,CAAC,CAAC;QACjB,YAAY,GAAG,CAAC,CAAC;QACjB,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;IACtB,CAAC;IAED,SAAS,uBAAuB;QAC9B,IAAI,KAAK,KAAK,MAAM,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,eAAe,EAAE,CAAC;YACtD,KAAK,GAAG,WAAW,CAAC;YACpB,YAAY,GAAG,CAAC,CAAC;YACjB,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,MAAM,GAAyB;QACnC,IAAI,KAAK;YACP,uCAAuC;YACvC,IAAI,KAAK,KAAK,MAAM,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,eAAe,EAAE,CAAC;gBACtD,KAAK,GAAG,WAAW,CAAC;gBACpB,YAAY,GAAG,CAAC,CAAC;gBACjB,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC;YACzB,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,YAAY;YACd,OAAO,YAAY,CAAC;QACtB,CAAC;QACD,IAAI,YAAY;YACd,OAAO,YAAY,CAAC;QACtB,CAAC;QACD,KAAK;YACH,UAAU,EAAE,CAAC;QACf,CAAC;KACF,CAAC;IAEF,KAAK,UAAU,OAAO,CAAI,EAAoB;QAC5C,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;YACrB,IAAI,CAAC,uBAAuB,EAAE,EAAE,CAAC;gBAC/B,MAAM,IAAI,gBAAgB,EAAE,CAAC;YAC/B,CAAC;QACH,CAAC;QAED,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,EAAE,EAAE,CAAC;YAE1B,mBAAmB;YACnB,IAAI,KAAK,KAAK,WAAW,EAAE,CAAC;gBAC1B,YAAY,EAAE,CAAC;gBACf,IAAI,YAAY,IAAI,gBAAgB,EAAE,CAAC;oBACrC,UAAU,EAAE,CAAC;gBACf,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,kDAAkD;gBAClD,YAAY,GAAG,CAAC,CAAC;YACnB,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,YAAY,EAAE,CAAC;YAEf,IAAI,KAAK,KAAK,WAAW,EAAE,CAAC;gBAC1B,8CAA8C;gBAC9C,IAAI,EAAE,CAAC;YACT,CAAC;iBAAM,IAAI,YAAY,IAAI,gBAAgB,EAAE,CAAC;gBAC5C,IAAI,EAAE,CAAC;YACT,CAAC;YAED,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AAC7B,CAAC"}

package/dist/esm/policies/fallback.js

@@ -0,0 +1,30 @@
+/**
+ * Creates a fallback policy that returns a fallback value (or the result
+ * of a fallback function) when the wrapped operation fails.
+ *
+ * @example
+ * ```ts
+ * const result = await fallback({ fallback: [] })(
+ *   () => fetch('/api/items').then(r => r.json()),
+ * );
+ * ```
+ */
+export function fallback(options) {
+    const shouldFallback = options.shouldFallback ?? (() => true);
+    return async (fn) => {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (!shouldFallback(error)) {
+                throw error;
+            }
+            const fb = options.fallback;
+            if (typeof fb === 'function') {
+                return await fb(error);
+            }
+            return fb;
+        }
+    };
+}
+//# sourceMappingURL=fallback.js.map

package/dist/esm/policies/fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback.js","sourceRoot":"","sources":["../../../src/policies/fallback.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,QAAQ,CAAI,OAA2B;IACrD,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IAE9D,OAAO,KAAK,EAAK,EAAoB,EAAkB,EAAE;QACvD,IAAI,CAAC;YACH,OAAO,MAAM,EAAE,EAAE,CAAC;QACpB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3B,MAAM,KAAK,CAAC;YACd,CAAC;YAED,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;YAC5B,IAAI,OAAO,EAAE,KAAK,UAAU,EAAE,CAAC;gBAC7B,OAAO,MAAO,EAAyC,CAAC,KAAK,CAAC,CAAC;YACjE,CAAC;YACD,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/dist/esm/policies/hedge.js

@@ -0,0 +1,71 @@
+import { assertPositive } from '../utils.js';
+const DEFAULTS = {
+    hedgeDelay: 2000,
+};
+/**
+ * Creates a hedge policy that sends a parallel (hedged) request if the
+ * primary request doesn't resolve within the configured delay.
+ * The first request to resolve wins; the other's result is discarded.
+ *
+ * @example
+ * ```ts
+ * const result = await hedge({ hedgeDelay: 1000 })(
+ *   () => fetch('/api/data').then(r => r.json()),
+ * );
+ * ```
+ */
+export function hedge(options = {}) {
+    const hedgeDelay = options.hedgeDelay ?? DEFAULTS.hedgeDelay;
+    assertPositive(hedgeDelay, 'hedgeDelay');
+    return async (fn) => {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            let primaryDone = false;
+            let hedgeDone = false;
+            let primaryError;
+            let hedgeLaunched = false;
+            const trySettle = (value) => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(hedgeTimer);
+                    resolve(value);
+                }
+            };
+            const tryRejectBoth = () => {
+                if (primaryDone && hedgeDone && !settled) {
+                    settled = true;
+                    reject(primaryError);
+                }
+            };
+            const doLaunchHedge = () => {
+                hedgeLaunched = true;
+                const hedgeRequest = fn();
+                hedgeRequest.then(trySettle, (_hedgeErr) => {
+                    hedgeDone = true;
+                    if (!primaryDone && !settled) {
+                        return;
+                    }
+                    tryRejectBoth();
+                });
+            };
+            // Primary request
+            const primary = fn();
+            primary.then(trySettle, (err) => {
+                primaryDone = true;
+                primaryError = err;
+                if (!hedgeLaunched) {
+                    clearTimeout(hedgeTimer);
+                    doLaunchHedge();
+                }
+                tryRejectBoth();
+            });
+            // Schedule hedged request
+            const hedgeTimer = setTimeout(() => {
+                if (!settled) {
+                    doLaunchHedge();
+                }
+            }, hedgeDelay);
+        });
+    };
+}
+//# sourceMappingURL=hedge.js.map

package/dist/esm/policies/hedge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hedge.js","sourceRoot":"","sources":["../../../src/policies/hedge.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,QAAQ,GAAG;IACf,UAAU,EAAE,IAAI;CACjB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,KAAK,CAAC,UAAwB,EAAE;IAC9C,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,QAAQ,CAAC,UAAU,CAAC;IAE7D,cAAc,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;IAEzC,OAAO,KAAK,EAAK,EAAoB,EAAc,EAAE;QACnD,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACxC,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,IAAI,WAAW,GAAG,KAAK,CAAC;YACxB,IAAI,SAAS,GAAG,KAAK,CAAC;YACtB,IAAI,YAAqB,CAAC;YAC1B,IAAI,aAAa,GAAG,KAAK,CAAC;YAE1B,MAAM,SAAS,GAAG,CAAC,KAAQ,EAAE,EAAE;gBAC7B,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,OAAO,GAAG,IAAI,CAAC;oBACf,YAAY,CAAC,UAAU,CAAC,CAAC;oBACzB,OAAO,CAAC,KAAK,CAAC,CAAC;gBACjB,CAAC;YACH,CAAC,CAAC;YAEF,MAAM,aAAa,GAAG,GAAG,EAAE;gBACzB,IAAI,WAAW,IAAI,SAAS,IAAI,CAAC,OAAO,EAAE,CAAC;oBACzC,OAAO,GAAG,IAAI,CAAC;oBACf,MAAM,CAAC,YAAY,CAAC,CAAC;gBACvB,CAAC;YACH,CAAC,CAAC;YAEF,MAAM,aAAa,GAAG,GAAG,EAAE;gBACzB,aAAa,GAAG,IAAI,CAAC;gBACrB,MAAM,YAAY,GAAG,EAAE,EAAE,CAAC;gBAC1B,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,SAAkB,EAAE,EAAE;oBAClD,SAAS,GAAG,IAAI,CAAC;oBACjB,IAAI,CAAC,WAAW,IAAI,CAAC,OAAO,EAAE,CAAC;wBAC7B,OAAO;oBACT,CAAC;oBACD,aAAa,EAAE,CAAC;gBAClB,CAAC,CAAC,CAAC;YACL,CAAC,CAAC;YAEF,kBAAkB;YAClB,MAAM,OAAO,GAAG,EAAE,EAAE,CAAC;YACrB,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,GAAY,EAAE,EAAE;gBACvC,WAAW,GAAG,IAAI,CAAC;gBACnB,YAAY,GAAG,GAAG,CAAC;gBAEnB,IAAI,CAAC,aAAa,EAAE,CAAC;oBACnB,YAAY,CAAC,UAAU,CAAC,CAAC;oBACzB,aAAa,EAAE,CAAC;gBAClB,CAAC;gBAED,aAAa,EAAE,CAAC;YAClB,CAAC,CAAC,CAAC;YAEH,0BAA0B;YAC1B,MAAM,UAAU,GAAG,UAAU,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,aAAa,EAAE,CAAC;gBAClB,CAAC;YACH,CAAC,EAAE,UAAU,CAAC,CAAC;QACjB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC"}

package/dist/esm/policies/rate-limiter.js

@@ -0,0 +1,89 @@
+import { RateLimitExceededError } from '../types.js';
+import { assertPositiveInteger, assertPositive } from '../utils.js';
+const DEFAULTS = {
+    tokensPerInterval: 10,
+    interval: 1000,
+    rejectOnLimit: false,
+};
+/**
+ * Creates a token-bucket rate limiter policy that limits how many times
+ * the wrapped operation can be executed within a time interval.
+ *
+ * Returns an object with `execute` (the policy function) and `handle`
+ * (an interface to inspect / reset the bucket).
+ *
+ * @example
+ * ```ts
+ * const rl = rateLimiter({ tokensPerInterval: 5, interval: 1000 });
+ * const result = await rl.execute(() => fetch('/api/data'));
+ * ```
+ */
+export function rateLimiter(options = {}) {
+    const tokensPerInterval = options.tokensPerInterval ?? DEFAULTS.tokensPerInterval;
+    const interval = options.interval ?? DEFAULTS.interval;
+    const rejectOnLimit = options.rejectOnLimit ?? DEFAULTS.rejectOnLimit;
+    assertPositiveInteger(tokensPerInterval, 'tokensPerInterval');
+    assertPositive(interval, 'interval');
+    let tokens = tokensPerInterval;
+    let lastRefill = Date.now();
+    const waiters = [];
+    function refill() {
+        const now = Date.now();
+        const elapsed = now - lastRefill;
+        const newTokens = Math.floor((elapsed / interval) * tokensPerInterval);
+        if (newTokens > 0) {
+            tokens = Math.min(tokensPerInterval, tokens + newTokens);
+            lastRefill = now;
+        }
+    }
+    function releaseWaiters() {
+        while (tokens > 0 && waiters.length > 0) {
+            tokens--;
+            const waiter = waiters.shift();
+            waiter.resolve();
+        }
+    }
+    // Refill timer — only active when there are waiters
+    let refillTimer = null;
+    function startRefillTimer() {
+        if (refillTimer !== null)
+            return;
+        refillTimer = setInterval(() => {
+            refill();
+            releaseWaiters();
+            if (waiters.length === 0 && refillTimer !== null) {
+                clearInterval(refillTimer);
+                refillTimer = null;
+            }
+        }, Math.min(interval, 100));
+    }
+    const handle = {
+        get availableTokens() {
+            refill();
+            return tokens;
+        },
+        reset() {
+            tokens = tokensPerInterval;
+            lastRefill = Date.now();
+            releaseWaiters();
+        },
+    };
+    async function execute(fn) {
+        refill();
+        if (tokens > 0) {
+            tokens--;
+            return fn();
+        }
+        if (rejectOnLimit) {
+            throw new RateLimitExceededError();
+        }
+        // Queue and wait for a token
+        await new Promise((resolve) => {
+            waiters.push({ resolve });
+            startRefillTimer();
+        });
+        return fn();
+    }
+    return { execute, handle };
+}
+//# sourceMappingURL=rate-limiter.js.map

package/dist/esm/policies/rate-limiter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.js","sourceRoot":"","sources":["../../../src/policies/rate-limiter.ts"],"names":[],"mappings":"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"}

package/dist/esm/policies/retry.js

@@ -0,0 +1,58 @@
+import { RetryExhaustedError } from '../types.js';
+import { sleep, calculateDelay, assertPositiveInteger, assertPositive } from '../utils.js';
+const DEFAULTS = {
+    maxAttempts: 3,
+    delay: 200,
+    backoff: 'exponential',
+    maxDelay: 30_000,
+};
+/**
+ * Creates a retry policy that re-executes the wrapped operation on failure
+ * using the configured backoff strategy.
+ *
+ * @example
+ * ```ts
+ * const result = await retry({ maxAttempts: 5, backoff: 'exponential' })(
+ *   () => fetch('/api/data'),
+ * );
+ * ```
+ */
+export function retry(options = {}) {
+    const maxAttempts = options.maxAttempts ?? DEFAULTS.maxAttempts;
+    const baseDelay = options.delay ?? DEFAULTS.delay;
+    const backoff = options.backoff ?? DEFAULTS.backoff;
+    const maxDelay = options.maxDelay ?? DEFAULTS.maxDelay;
+    const shouldRetry = options.shouldRetry ?? (() => true);
+    const onRetry = options.onRetry;
+    const signal = options.signal;
+    assertPositiveInteger(maxAttempts, 'maxAttempts');
+    assertPositive(baseDelay, 'delay');
+    assertPositive(maxDelay, 'maxDelay');
+    return async (fn) => {
+        let lastError;
+        let previousDelay = baseDelay;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            if (signal?.aborted) {
+                throw signal.reason;
+            }
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt === maxAttempts) {
+                    break;
+                }
+                if (!shouldRetry(error, attempt)) {
+                    break;
+                }
+                const delayMs = calculateDelay(attempt, baseDelay, backoff, maxDelay, previousDelay);
+                previousDelay = delayMs;
+                onRetry?.(error, attempt, delayMs);
+                await sleep(delayMs, signal);
+            }
+        }
+        throw new RetryExhaustedError(maxAttempts, lastError);
+    };
+}
+//# sourceMappingURL=retry.js.map

package/dist/esm/policies/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../../src/policies/retry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE3F,MAAM,QAAQ,GAAG;IACf,WAAW,EAAE,CAAC;IACd,KAAK,EAAE,GAAG;IACV,OAAO,EAAE,aAAsB;IAC/B,QAAQ,EAAE,MAAM;CACjB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,KAAK,CAAC,UAAwB,EAAE;IAC9C,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,QAAQ,CAAC,WAAW,CAAC;IAChE,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC;IAClD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,QAAQ,CAAC,OAAO,CAAC;IACpD,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,QAAQ,CAAC,QAAQ,CAAC;IACvD,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IACxD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAChC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAE9B,qBAAqB,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;IAClD,cAAc,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IACnC,cAAc,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IAErC,OAAO,KAAK,EAAK,EAAoB,EAAc,EAAE;QACnD,IAAI,SAAkB,CAAC;QACvB,IAAI,aAAa,GAAG,SAAS,CAAC;QAE9B,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC;YACxD,IAAI,MAAM,EAAE,OAAO,EAAE,CAAC;gBACpB,MAAM,MAAM,CAAC,MAAM,CAAC;YACtB,CAAC;YAED,IAAI,CAAC;gBACH,OAAO,MAAM,EAAE,EAAE,CAAC;YACpB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,SAAS,GAAG,KAAK,CAAC;gBAElB,IAAI,OAAO,KAAK,WAAW,EAAE,CAAC;oBAC5B,MAAM;gBACR,CAAC;gBAED,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC;oBACjC,MAAM;gBACR,CAAC;gBAED,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC;gBACrF,aAAa,GAAG,OAAO,CAAC;gBAExB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;gBAEnC,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;QAED,MAAM,IAAI,mBAAmB,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IACxD,CAAC,CAAC;AACJ,CAAC"}

package/dist/esm/policies/timeout.js

@@ -0,0 +1,42 @@
+import { TimeoutError } from '../types.js';
+import { assertPositive } from '../utils.js';
+/**
+ * Creates a timeout policy that rejects if the wrapped operation
+ * does not resolve within the specified deadline.
+ *
+ * Uses AbortController for cooperative cancellation when the
+ * wrapped function supports it.
+ *
+ * @example
+ * ```ts
+ * const result = await timeout({ ms: 5000 })(() => fetch('/api/data'));
+ * ```
+ */
+export function timeout(options) {
+    assertPositive(options.ms, 'ms');
+    return async (fn) => {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    reject(new TimeoutError(options.ms));
+                }
+            }, options.ms);
+            fn().then((value) => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    resolve(value);
+                }
+            }, (error) => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    reject(error);
+                }
+            });
+        });
+    };
+}
+//# sourceMappingURL=timeout.js.map

package/dist/esm/policies/timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.js","sourceRoot":"","sources":["../../../src/policies/timeout.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,OAAO,CAAC,OAAuB;IAC7C,cAAc,CAAC,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IAEjC,OAAO,KAAK,EAAK,EAAoB,EAAc,EAAE;QACnD,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACxC,IAAI,OAAO,GAAG,KAAK,CAAC;YAEpB,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC5B,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,OAAO,GAAG,IAAI,CAAC;oBACf,MAAM,CAAC,IAAI,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;gBACvC,CAAC;YACH,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;YAEf,EAAE,EAAE,CAAC,IAAI,CACP,CAAC,KAAK,EAAE,EAAE;gBACR,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,OAAO,GAAG,IAAI,CAAC;oBACf,YAAY,CAAC,KAAK,CAAC,CAAC;oBACpB,OAAO,CAAC,KAAK,CAAC,CAAC;gBACjB,CAAC;YACH,CAAC,EACD,CAAC,KAAK,EAAE,EAAE;gBACR,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,OAAO,GAAG,IAAI,CAAC;oBACf,YAAY,CAAC,KAAK,CAAC,CAAC;oBACpB,MAAM,CAAC,KAAK,CAAC,CAAC;gBAChB,CAAC;YACH,CAAC,CACF,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC"}