flowshield 1.0.0

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circuitBreaker = circuitBreaker;
+const types_js_1 = require("../types.js");
+const utils_js_1 = require("../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'
+ * ```
+ */
+function circuitBreaker(options = {}) {
+    const failureThreshold = options.failureThreshold ?? DEFAULTS.failureThreshold;
+    const successThreshold = options.successThreshold ?? DEFAULTS.successThreshold;
+    const resetTimeout = options.resetTimeout ?? DEFAULTS.resetTimeout;
+    (0, utils_js_1.assertPositiveInteger)(failureThreshold, 'failureThreshold');
+    (0, utils_js_1.assertPositiveInteger)(successThreshold, 'successThreshold');
+    (0, utils_js_1.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 types_js_1.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/cjs/policies/circuit-breaker.js.map

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

package/dist/cjs/policies/fallback.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fallback = fallback;
+/**
+ * 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()),
+ * );
+ * ```
+ */
+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/cjs/policies/fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback.js","sourceRoot":"","sources":["../../../src/policies/fallback.ts"],"names":[],"mappings":";;AAaA,4BAkBC;AA7BD;;;;;;;;;;GAUG;AACH,SAAgB,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/cjs/policies/hedge.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hedge = hedge;
+const utils_js_1 = require("../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()),
+ * );
+ * ```
+ */
+function hedge(options = {}) {
+    const hedgeDelay = options.hedgeDelay ?? DEFAULTS.hedgeDelay;
+    (0, utils_js_1.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/cjs/policies/hedge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hedge.js","sourceRoot":"","sources":["../../../src/policies/hedge.ts"],"names":[],"mappings":";;AAmBA,sBA8DC;AAhFD,0CAA6C;AAE7C,MAAM,QAAQ,GAAG;IACf,UAAU,EAAE,IAAI;CACjB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,SAAgB,KAAK,CAAC,UAAwB,EAAE;IAC9C,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,QAAQ,CAAC,UAAU,CAAC;IAE7D,IAAA,yBAAc,EAAC,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/cjs/policies/rate-limiter.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rateLimiter = rateLimiter;
+const types_js_1 = require("../types.js");
+const utils_js_1 = require("../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'));
+ * ```
+ */
+function rateLimiter(options = {}) {
+    const tokensPerInterval = options.tokensPerInterval ?? DEFAULTS.tokensPerInterval;
+    const interval = options.interval ?? DEFAULTS.interval;
+    const rejectOnLimit = options.rejectOnLimit ?? DEFAULTS.rejectOnLimit;
+    (0, utils_js_1.assertPositiveInteger)(tokensPerInterval, 'tokensPerInterval');
+    (0, utils_js_1.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 types_js_1.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/cjs/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/cjs/policies/retry.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retry = retry;
+const types_js_1 = require("../types.js");
+const utils_js_1 = require("../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'),
+ * );
+ * ```
+ */
+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;
+    (0, utils_js_1.assertPositiveInteger)(maxAttempts, 'maxAttempts');
+    (0, utils_js_1.assertPositive)(baseDelay, 'delay');
+    (0, utils_js_1.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 = (0, utils_js_1.calculateDelay)(attempt, baseDelay, backoff, maxDelay, previousDelay);
+                previousDelay = delayMs;
+                onRetry?.(error, attempt, delayMs);
+                await (0, utils_js_1.sleep)(delayMs, signal);
+            }
+        }
+        throw new types_js_1.RetryExhaustedError(maxAttempts, lastError);
+    };
+}
+//# sourceMappingURL=retry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../../src/policies/retry.ts"],"names":[],"mappings":";;AAsBA,sBA8CC;AAnED,0CAAkD;AAClD,0CAA2F;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,SAAgB,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,IAAA,gCAAqB,EAAC,WAAW,EAAE,aAAa,CAAC,CAAC;IAClD,IAAA,yBAAc,EAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IACnC,IAAA,yBAAc,EAAC,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,IAAA,yBAAc,EAAC,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,IAAA,gBAAK,EAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;QAED,MAAM,IAAI,8BAAmB,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IACxD,CAAC,CAAC;AACJ,CAAC"}

package/dist/cjs/policies/timeout.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeout = timeout;
+const types_js_1 = require("../types.js");
+const utils_js_1 = require("../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'));
+ * ```
+ */
+function timeout(options) {
+    (0, utils_js_1.assertPositive)(options.ms, 'ms');
+    return async (fn) => {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    reject(new types_js_1.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/cjs/policies/timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.js","sourceRoot":"","sources":["../../../src/policies/timeout.ts"],"names":[],"mappings":";;AAgBA,0BAgCC;AA/CD,0CAA2C;AAC3C,0CAA6C;AAE7C;;;;;;;;;;;GAWG;AACH,SAAgB,OAAO,CAAC,OAAuB;IAC7C,IAAA,yBAAc,EAAC,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,uBAAY,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"}

package/dist/cjs/types.js

@@ -0,0 +1,55 @@
+"use strict";
+// ─── Core Types ─────────────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryExhaustedError = exports.RateLimitExceededError = exports.BulkheadRejectedError = exports.CircuitOpenError = exports.TimeoutError = exports.FlowShieldError = void 0;
+// ─── Errors ─────────────────────────────────────────────────────────────────
+class FlowShieldError extends Error {
+    constructor(message, cause) {
+        super(message);
+        this.name = 'FlowShieldError';
+        // Fix prototype chain for instanceof checks
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (cause !== undefined) {
+            this.cause = cause;
+        }
+    }
+}
+exports.FlowShieldError = FlowShieldError;
+class TimeoutError extends FlowShieldError {
+    constructor(ms) {
+        super(`Operation timed out after ${ms}ms`);
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;
+class CircuitOpenError extends FlowShieldError {
+    constructor() {
+        super('Circuit breaker is open — request rejected');
+        this.name = 'CircuitOpenError';
+    }
+}
+exports.CircuitOpenError = CircuitOpenError;
+class BulkheadRejectedError extends FlowShieldError {
+    constructor() {
+        super('Bulkhead capacity exceeded — request rejected');
+        this.name = 'BulkheadRejectedError';
+    }
+}
+exports.BulkheadRejectedError = BulkheadRejectedError;
+class RateLimitExceededError extends FlowShieldError {
+    constructor() {
+        super('Rate limit exceeded — request rejected');
+        this.name = 'RateLimitExceededError';
+    }
+}
+exports.RateLimitExceededError = RateLimitExceededError;
+class RetryExhaustedError extends FlowShieldError {
+    attempts;
+    constructor(attempts, lastError) {
+        super(`All ${attempts} retry attempts exhausted`, lastError);
+        this.name = 'RetryExhaustedError';
+        this.attempts = attempts;
+    }
+}
+exports.RetryExhaustedError = RetryExhaustedError;
+//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";AAAA,+EAA+E;;;AAkJ/E,+EAA+E;AAE/E,MAAa,eAAgB,SAAQ,KAAK;IACxC,YAAY,OAAe,EAAE,KAAe;QAC1C,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,4CAA4C;QAC5C,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAClD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACvB,IAA4B,CAAC,KAAK,GAAG,KAAK,CAAC;QAC9C,CAAC;IACH,CAAC;CACF;AAVD,0CAUC;AAED,MAAa,YAAa,SAAQ,eAAe;IAC/C,YAAY,EAAU;QACpB,KAAK,CAAC,6BAA6B,EAAE,IAAI,CAAC,CAAC;QAC3C,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;IAC7B,CAAC;CACF;AALD,oCAKC;AAED,MAAa,gBAAiB,SAAQ,eAAe;IACnD;QACE,KAAK,CAAC,4CAA4C,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AALD,4CAKC;AAED,MAAa,qBAAsB,SAAQ,eAAe;IACxD;QACE,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACvD,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AALD,sDAKC;AAED,MAAa,sBAAuB,SAAQ,eAAe;IACzD;QACE,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAChD,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;IACvC,CAAC;CACF;AALD,wDAKC;AAED,MAAa,mBAAoB,SAAQ,eAAe;IACtC,QAAQ,CAAS;IACjC,YAAY,QAAgB,EAAE,SAAkB;QAC9C,KAAK,CAAC,OAAO,QAAQ,2BAA2B,EAAE,SAAS,CAAC,CAAC;QAC7D,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;QAClC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;CACF;AAPD,kDAOC"}

package/dist/cjs/utils.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = sleep;
+exports.calculateDelay = calculateDelay;
+exports.assertPositiveInteger = assertPositiveInteger;
+exports.assertPositive = assertPositive;
+exports.assertNonNegative = assertNonNegative;
+/**
+ * Sleep for `ms` milliseconds. Supports cooperative cancellation via AbortSignal.
+ */
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        let done = false;
+        const timer = setTimeout(() => {
+            done = true;
+            if (signal) {
+                signal.removeEventListener('abort', onAbort);
+            }
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            if (!done) {
+                done = true;
+                clearTimeout(timer);
+                reject(signal.reason);
+            }
+        };
+        if (signal) {
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
+    });
+}
+/**
+ * Calculate the delay for a given attempt using the specified backoff strategy.
+ */
+function calculateDelay(attempt, baseDelay, strategy, maxDelay, previousDelay) {
+    let delay;
+    switch (strategy) {
+        case 'constant':
+            delay = baseDelay;
+            break;
+        case 'linear':
+            delay = baseDelay * attempt;
+            break;
+        case 'exponential':
+            delay = baseDelay * Math.pow(2, attempt - 1);
+            break;
+        case 'decorrelatedJitter': {
+            const prev = previousDelay ?? baseDelay;
+            delay = Math.random() * (prev * 3 - baseDelay) + baseDelay;
+            break;
+        }
+    }
+    return Math.min(delay, maxDelay);
+}
+/**
+ * Validate that a number is a positive integer.
+ */
+function assertPositiveInteger(value, name) {
+    if (!Number.isFinite(value) || value < 1 || Math.floor(value) !== value) {
+        throw new RangeError(`${name} must be a positive integer, got ${value}`);
+    }
+}
+/**
+ * Validate that a number is a positive finite number.
+ */
+function assertPositive(value, name) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new RangeError(`${name} must be a positive number, got ${value}`);
+    }
+}
+/**
+ * Validate that a number is a non-negative finite number.
+ */
+function assertNonNegative(value, name) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative number, got ${value}`);
+    }
+}
+//# sourceMappingURL=utils.js.map

package/dist/cjs/utils.js.map

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

package/dist/esm/compose.js

@@ -0,0 +1,49 @@
+/**
+ * Composes multiple policies into a single policy.
+ * Policies are applied **left-to-right** (outermost first).
+ *
+ * `pipe(a, b, c)(fn)` is equivalent to `a(()=> b(()=> c(fn)))`.
+ *
+ * @example
+ * ```ts
+ * const resilient = pipe(
+ *   timeout({ ms: 5000 }),
+ *   retry({ maxAttempts: 3 }),
+ * );
+ * const result = await resilient(() => fetch('/api'));
+ * ```
+ */
+export function pipe(...policies) {
+    if (policies.length === 0) {
+        return (fn) => fn();
+    }
+    return (fn) => {
+        // Build from right to left: the innermost policy wraps fn directly
+        let composed = fn;
+        for (let i = policies.length - 1; i >= 0; i--) {
+            const policy = policies[i];
+            const next = composed;
+            composed = () => policy(next);
+        }
+        return composed();
+    };
+}
+/**
+ * Wraps an inner policy with an outer policy.
+ * `wrap(outer, inner)(fn)` is equivalent to `outer(() => inner(fn))`.
+ *
+ * @example
+ * ```ts
+ * const policy = wrap(
+ *   timeout({ ms: 5000 }),
+ *   retry({ maxAttempts: 3 }),
+ * );
+ * const result = await policy(() => fetch('/api'));
+ * ```
+ */
+export function wrap(outer, inner) {
+    return (fn) => {
+        return outer(() => inner(fn));
+    };
+}
+//# sourceMappingURL=compose.js.map

package/dist/esm/compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../../src/compose.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,IAAI,CAAC,GAAG,QAAkB;IACxC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,CAAI,EAAoB,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;IAC3C,CAAC;IAED,OAAO,CAAI,EAAoB,EAAc,EAAE;QAC7C,mEAAmE;QACnE,IAAI,QAAQ,GAAqB,EAAE,CAAC;QAEpC,KAAK,IAAI,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9C,MAAM,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;YAC3B,MAAM,IAAI,GAAG,QAAQ,CAAC;YACtB,QAAQ,GAAG,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC;QAED,OAAO,QAAQ,EAAE,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,IAAI,CAAC,KAAa,EAAE,KAAa;IAC/C,OAAO,CAAI,EAAoB,EAAc,EAAE;QAC7C,OAAO,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;IAChC,CAAC,CAAC;AACJ,CAAC"}