@hazeljs/resilience 0.2.0-beta.41

package/dist/__tests__/sliding-window.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sliding-window.test.d.ts.map

package/dist/__tests__/sliding-window.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sliding-window.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/sliding-window.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/sliding-window.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sliding_window_1 = require("../circuit-breaker/sliding-window");
+describe('CountBasedSlidingWindow', () => {
+    it('should record entries and compute result', () => {
+        const window = new sliding_window_1.CountBasedSlidingWindow(5);
+        window.record(true);
+        window.record(false);
+        window.record(true);
+        const result = window.getResult();
+        expect(result.totalCalls).toBe(3);
+        expect(result.failureCount).toBe(1);
+        expect(result.failureRate).toBeCloseTo(33.33, 1);
+    });
+    it('should evict oldest when exceeding size', () => {
+        const window = new sliding_window_1.CountBasedSlidingWindow(3);
+        window.record(true);
+        window.record(false);
+        window.record(false);
+        window.record(true); // evicts first true
+        const result = window.getResult();
+        expect(result.totalCalls).toBe(3);
+        expect(result.failureCount).toBe(2);
+    });
+    it('should return zeros when empty', () => {
+        const window = new sliding_window_1.CountBasedSlidingWindow(5);
+        const result = window.getResult();
+        expect(result.totalCalls).toBe(0);
+        expect(result.failureCount).toBe(0);
+        expect(result.failureRate).toBe(0);
+    });
+    it('reset should clear entries', () => {
+        const window = new sliding_window_1.CountBasedSlidingWindow(5);
+        window.record(true);
+        window.record(false);
+        window.reset();
+        const result = window.getResult();
+        expect(result.totalCalls).toBe(0);
+        expect(result.failureCount).toBe(0);
+    });
+});
+describe('TimeBasedSlidingWindow', () => {
+    it('should record entries and compute result', () => {
+        const window = new sliding_window_1.TimeBasedSlidingWindow(60000);
+        window.record(true);
+        window.record(false);
+        window.record(true);
+        const result = window.getResult();
+        expect(result.totalCalls).toBe(3);
+        expect(result.failureCount).toBe(1);
+        expect(result.failureRate).toBeCloseTo(33.33, 1);
+    });
+    it('should evict entries outside window', async () => {
+        const window = new sliding_window_1.TimeBasedSlidingWindow(50);
+        window.record(true);
+        window.record(false);
+        await new Promise((r) => setTimeout(r, 60));
+        window.record(true);
+        const result = window.getResult();
+        expect(result.totalCalls).toBe(1);
+        expect(result.failureCount).toBe(0);
+    });
+    it('should return zeros when empty', () => {
+        const window = new sliding_window_1.TimeBasedSlidingWindow(60000);
+        const result = window.getResult();
+        expect(result.totalCalls).toBe(0);
+        expect(result.failureCount).toBe(0);
+        expect(result.failureRate).toBe(0);
+    });
+    it('reset should clear entries', () => {
+        const window = new sliding_window_1.TimeBasedSlidingWindow(60000);
+        window.record(true);
+        window.record(false);
+        window.reset();
+        const result = window.getResult();
+        expect(result.totalCalls).toBe(0);
+        expect(result.failureCount).toBe(0);
+    });
+});
+describe('createSlidingWindow', () => {
+    it('should create CountBasedSlidingWindow for count type', () => {
+        const window = (0, sliding_window_1.createSlidingWindow)('count', 10);
+        expect(window).toBeInstanceOf(sliding_window_1.CountBasedSlidingWindow);
+        window.record(true);
+        expect(window.getResult().totalCalls).toBe(1);
+    });
+    it('should create TimeBasedSlidingWindow for time type', () => {
+        const window = (0, sliding_window_1.createSlidingWindow)('time', 5000);
+        expect(window).toBeInstanceOf(sliding_window_1.TimeBasedSlidingWindow);
+        window.record(true);
+        expect(window.getResult().totalCalls).toBe(1);
+    });
+});

package/dist/bulkhead/bulkhead.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bulkhead
+ * Concurrency limiter that isolates failures by limiting
+ * the number of concurrent calls and queue depth.
+ */
+import { BulkheadConfig, BulkheadMetrics } from '../types';
+export declare class Bulkhead {
+    private activeCalls;
+    private queue;
+    private rejectedCount;
+    private maxConcurrent;
+    private maxQueue;
+    private queueTimeout;
+    constructor(config: BulkheadConfig);
+    /**
+     * Execute a function within the bulkhead constraints
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get current metrics
+     */
+    getMetrics(): BulkheadMetrics;
+    /**
+     * Get the number of currently active calls
+     */
+    getActiveCalls(): number;
+    /**
+     * Get the number of calls waiting in the queue
+     */
+    getQueueLength(): number;
+    private acquirePermit;
+    private releasePermit;
+}
+//# sourceMappingURL=bulkhead.d.ts.map

package/dist/bulkhead/bulkhead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkhead.d.ts","sourceRoot":"","sources":["../../src/bulkhead/bulkhead.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAiB,eAAe,EAAE,MAAM,UAAU,CAAC;AAQ1E,qBAAa,QAAQ;IACnB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,YAAY,CAAS;gBAEjB,MAAM,EAAE,cAAc;IAMlC;;OAEG;IACG,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAUlD;;OAEG;IACH,UAAU,IAAI,eAAe;IAU7B;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,cAAc,IAAI,MAAM;YAMV,aAAa;IAmC3B,OAAO,CAAC,aAAa;CAatB"}

package/dist/bulkhead/bulkhead.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Bulkhead
+ * Concurrency limiter that isolates failures by limiting
+ * the number of concurrent calls and queue depth.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bulkhead = void 0;
+const types_1 = require("../types");
+class Bulkhead {
+    constructor(config) {
+        this.activeCalls = 0;
+        this.queue = [];
+        this.rejectedCount = 0;
+        this.maxConcurrent = config.maxConcurrent;
+        this.maxQueue = config.maxQueue;
+        this.queueTimeout = config.queueTimeout ?? 0; // 0 = no timeout
+    }
+    /**
+     * Execute a function within the bulkhead constraints
+     */
+    async execute(fn) {
+        await this.acquirePermit();
+        try {
+            return await fn();
+        }
+        finally {
+            this.releasePermit();
+        }
+    }
+    /**
+     * Get current metrics
+     */
+    getMetrics() {
+        return {
+            activeCalls: this.activeCalls,
+            queueLength: this.queue.length,
+            maxConcurrent: this.maxConcurrent,
+            maxQueue: this.maxQueue,
+            rejectedCount: this.rejectedCount,
+        };
+    }
+    /**
+     * Get the number of currently active calls
+     */
+    getActiveCalls() {
+        return this.activeCalls;
+    }
+    /**
+     * Get the number of calls waiting in the queue
+     */
+    getQueueLength() {
+        return this.queue.length;
+    }
+    // ─── Internal ───
+    async acquirePermit() {
+        // If there's capacity, immediately grant
+        if (this.activeCalls < this.maxConcurrent) {
+            this.activeCalls++;
+            return;
+        }
+        // If the queue is full, reject immediately
+        if (this.queue.length >= this.maxQueue) {
+            this.rejectedCount++;
+            throw new types_1.BulkheadError(`Bulkhead capacity exceeded: ${this.activeCalls}/${this.maxConcurrent} active, ${this.queue.length}/${this.maxQueue} queued`);
+        }
+        // Enqueue and wait
+        return new Promise((resolve, reject) => {
+            const queuedCall = { resolve, reject };
+            // Optional queue timeout
+            if (this.queueTimeout > 0) {
+                queuedCall.timeoutId = setTimeout(() => {
+                    const idx = this.queue.indexOf(queuedCall);
+                    if (idx !== -1) {
+                        this.queue.splice(idx, 1);
+                        this.rejectedCount++;
+                        reject(new types_1.BulkheadError(`Bulkhead queue timeout after ${this.queueTimeout}ms`));
+                    }
+                }, this.queueTimeout);
+            }
+            this.queue.push(queuedCall);
+        });
+    }
+    releasePermit() {
+        this.activeCalls--;
+        // If there are queued calls, dequeue one
+        if (this.queue.length > 0) {
+            const next = this.queue.shift();
+            if (next.timeoutId) {
+                clearTimeout(next.timeoutId);
+            }
+            this.activeCalls++;
+            next.resolve();
+        }
+    }
+}
+exports.Bulkhead = Bulkhead;

package/dist/circuit-breaker/circuit-breaker-registry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Circuit Breaker Registry
+ * Global registry for managing named circuit breaker instances
+ */
+import { CircuitBreaker } from './circuit-breaker';
+import { CircuitBreakerConfig } from '../types';
+export declare class CircuitBreakerRegistry {
+    private static breakers;
+    /**
+     * Get or create a circuit breaker by name
+     */
+    static getOrCreate(name: string, config?: Partial<CircuitBreakerConfig>): CircuitBreaker;
+    /**
+     * Get an existing circuit breaker
+     */
+    static get(name: string): CircuitBreaker | undefined;
+    /**
+     * Register a circuit breaker instance
+     */
+    static register(name: string, breaker: CircuitBreaker): void;
+    /**
+     * Remove a circuit breaker
+     */
+    static remove(name: string): boolean;
+    /**
+     * Get all registered breakers
+     */
+    static getAll(): Map<string, CircuitBreaker>;
+    /**
+     * Reset all circuit breakers
+     */
+    static resetAll(): void;
+    /**
+     * Clear the registry
+     */
+    static clear(): void;
+}
+//# sourceMappingURL=circuit-breaker-registry.d.ts.map

package/dist/circuit-breaker/circuit-breaker-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker-registry.d.ts","sourceRoot":"","sources":["../../src/circuit-breaker/circuit-breaker-registry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEhD,qBAAa,sBAAsB;IACjC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAqC;IAE5D;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,cAAc;IASxF;;OAEG;IACH,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAIpD;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI;IAI5D;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIpC;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC;IAI5C;;OAEG;IACH,MAAM,CAAC,QAAQ,IAAI,IAAI;IAMvB;;OAEG;IACH,MAAM,CAAC,KAAK,IAAI,IAAI;CAGrB"}

package/dist/circuit-breaker/circuit-breaker-registry.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Circuit Breaker Registry
+ * Global registry for managing named circuit breaker instances
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreakerRegistry = void 0;
+const circuit_breaker_1 = require("./circuit-breaker");
+class CircuitBreakerRegistry {
+    /**
+     * Get or create a circuit breaker by name
+     */
+    static getOrCreate(name, config) {
+        let breaker = this.breakers.get(name);
+        if (!breaker) {
+            breaker = new circuit_breaker_1.CircuitBreaker(config);
+            this.breakers.set(name, breaker);
+        }
+        return breaker;
+    }
+    /**
+     * Get an existing circuit breaker
+     */
+    static get(name) {
+        return this.breakers.get(name);
+    }
+    /**
+     * Register a circuit breaker instance
+     */
+    static register(name, breaker) {
+        this.breakers.set(name, breaker);
+    }
+    /**
+     * Remove a circuit breaker
+     */
+    static remove(name) {
+        return this.breakers.delete(name);
+    }
+    /**
+     * Get all registered breakers
+     */
+    static getAll() {
+        return new Map(this.breakers);
+    }
+    /**
+     * Reset all circuit breakers
+     */
+    static resetAll() {
+        for (const breaker of this.breakers.values()) {
+            breaker.reset();
+        }
+    }
+    /**
+     * Clear the registry
+     */
+    static clear() {
+        this.breakers.clear();
+    }
+}
+exports.CircuitBreakerRegistry = CircuitBreakerRegistry;
+CircuitBreakerRegistry.breakers = new Map();

package/dist/circuit-breaker/circuit-breaker.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Circuit Breaker
+ * Prevents cascading failures by stopping calls to failing services.
+ *
+ * States:
+ *   CLOSED  -> normal operation, calls pass through
+ *   OPEN    -> calls are rejected immediately
+ *   HALF_OPEN -> a limited number of trial calls are allowed through
+ *
+ * Enhanced with sliding window metrics, failure predicates,
+ * event emitter, and fallback support.
+ */
+import { EventEmitter } from 'events';
+import { CircuitState, CircuitBreakerConfig, CircuitBreakerMetrics } from '../types';
+import { MetricsCollector } from '../metrics/metrics-collector';
+export declare class CircuitBreaker extends EventEmitter {
+    private state;
+    private nextAttempt;
+    private halfOpenSuccessCount;
+    private slidingWindow;
+    private metrics;
+    private config;
+    constructor(config?: Partial<CircuitBreakerConfig>);
+    /**
+     * Execute a function with circuit breaker protection
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    getState(): CircuitState;
+    isOpen(): boolean;
+    isClosed(): boolean;
+    isHalfOpen(): boolean;
+    getMetrics(): CircuitBreakerMetrics;
+    /**
+     * Get the failure count within the current sliding window
+     */
+    getFailureCount(): number;
+    /**
+     * Get the success count within the current sliding window
+     */
+    getSuccessCount(): number;
+    getMetricsCollector(): MetricsCollector;
+    getTimeUntilNextAttempt(): number;
+    /**
+     * Manually reset the circuit to CLOSED
+     */
+    reset(): void;
+    private onSuccess;
+    private onFailure;
+    private transitionTo;
+}
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/circuit-breaker/circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../src/circuit-breaker/circuit-breaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EACL,YAAY,EACZ,oBAAoB,EAEpB,qBAAqB,EAEtB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAmBhE,qBAAa,cAAe,SAAQ,YAAY;IAC9C,OAAO,CAAC,KAAK,CAAqC;IAClD,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,MAAM,CAAwB;gBAE1B,MAAM,GAAE,OAAO,CAAC,oBAAoB,CAAM;IAStD;;OAEG;IACG,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA8ClD,QAAQ,IAAI,YAAY;IAIxB,MAAM,IAAI,OAAO;IAIjB,QAAQ,IAAI,OAAO;IAInB,UAAU,IAAI,OAAO;IAIrB,UAAU,IAAI,qBAAqB;IAenC;;OAEG;IACH,eAAe,IAAI,MAAM;IAIzB;;OAEG;IACH,eAAe,IAAI,MAAM;IAKzB,mBAAmB,IAAI,gBAAgB;IAIvC,uBAAuB,IAAI,MAAM;IAKjC;;OAEG;IACH,KAAK,IAAI,IAAI;IAQb,OAAO,CAAC,SAAS;IAajB,OAAO,CAAC,SAAS;IAkBjB,OAAO,CAAC,YAAY;CAkBrB"}

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

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Circuit Breaker
+ * Prevents cascading failures by stopping calls to failing services.
+ *
+ * States:
+ *   CLOSED  -> normal operation, calls pass through
+ *   OPEN    -> calls are rejected immediately
+ *   HALF_OPEN -> a limited number of trial calls are allowed through
+ *
+ * Enhanced with sliding window metrics, failure predicates,
+ * event emitter, and fallback support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreaker = void 0;
+const events_1 = require("events");
+const types_1 = require("../types");
+const sliding_window_1 = require("./sliding-window");
+const metrics_collector_1 = require("../metrics/metrics-collector");
+const DEFAULT_CONFIG = {
+    failureThreshold: 5,
+    successThreshold: 2,
+    timeout: 60000,
+    resetTimeout: 30000,
+    slidingWindow: { type: 'count', size: 20 },
+    fallback: undefined,
+    onStateChange: undefined,
+    failurePredicate: undefined,
+};
+class CircuitBreaker extends events_1.EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.state = types_1.CircuitState.CLOSED;
+        this.nextAttempt = 0;
+        this.halfOpenSuccessCount = 0;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        const swCfg = this.config.slidingWindow;
+        this.slidingWindow = (0, sliding_window_1.createSlidingWindow)(swCfg.type, swCfg.size);
+        this.metrics = new metrics_collector_1.MetricsCollector(swCfg.type === 'time' ? swCfg.size : 60000);
+    }
+    /**
+     * Execute a function with circuit breaker protection
+     */
+    async execute(fn) {
+        // If OPEN, check if it's time to try again
+        if (this.state === types_1.CircuitState.OPEN) {
+            if (Date.now() < this.nextAttempt) {
+                throw new types_1.CircuitBreakerError('Circuit breaker is OPEN - service unavailable', this.state);
+            }
+            this.transitionTo(types_1.CircuitState.HALF_OPEN);
+        }
+        const startTime = Date.now();
+        let timeoutId;
+        try {
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new types_1.TimeoutError('Circuit breaker timeout')), this.config.timeout);
+            });
+            const result = await Promise.race([fn(), timeoutPromise]);
+            const duration = Date.now() - startTime;
+            this.onSuccess(duration);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            // Check if this error should count as a failure
+            if (this.config.failurePredicate && !this.config.failurePredicate(error)) {
+                // Error does not count as failure — still record as success for metrics
+                this.metrics.recordSuccess(duration);
+                throw error;
+            }
+            this.onFailure(duration, error);
+            throw error;
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+    // ─── State Queries ───
+    getState() {
+        return this.state;
+    }
+    isOpen() {
+        return this.state === types_1.CircuitState.OPEN;
+    }
+    isClosed() {
+        return this.state === types_1.CircuitState.CLOSED;
+    }
+    isHalfOpen() {
+        return this.state === types_1.CircuitState.HALF_OPEN;
+    }
+    getMetrics() {
+        const snapshot = this.metrics.getSnapshot();
+        return {
+            totalRequests: snapshot.totalCalls,
+            successCount: snapshot.successCalls,
+            failureCount: snapshot.failureCalls,
+            failureRate: snapshot.failureRate,
+            state: this.state,
+            lastFailureTime: snapshot.failureCalls > 0 ? snapshot.lastCallTime : undefined,
+            lastSuccessTime: snapshot.successCalls > 0 ? snapshot.lastCallTime : undefined,
+            averageResponseTime: snapshot.averageResponseTime,
+            p99ResponseTime: snapshot.p99ResponseTime,
+        };
+    }
+    /**
+     * Get the failure count within the current sliding window
+     */
+    getFailureCount() {
+        return this.slidingWindow.getResult().failureCount;
+    }
+    /**
+     * Get the success count within the current sliding window
+     */
+    getSuccessCount() {
+        const result = this.slidingWindow.getResult();
+        return result.totalCalls - result.failureCount;
+    }
+    getMetricsCollector() {
+        return this.metrics;
+    }
+    getTimeUntilNextAttempt() {
+        if (this.state !== types_1.CircuitState.OPEN)
+            return 0;
+        return Math.max(0, this.nextAttempt - Date.now());
+    }
+    /**
+     * Manually reset the circuit to CLOSED
+     */
+    reset() {
+        this.transitionTo(types_1.CircuitState.CLOSED);
+        this.slidingWindow.reset();
+        this.metrics.reset();
+    }
+    // ─── Internal ───
+    onSuccess(duration) {
+        this.slidingWindow.record(true);
+        this.metrics.recordSuccess(duration);
+        this.emit('success', { duration });
+        if (this.state === types_1.CircuitState.HALF_OPEN) {
+            this.halfOpenSuccessCount++;
+            if (this.halfOpenSuccessCount >= this.config.successThreshold) {
+                this.transitionTo(types_1.CircuitState.CLOSED);
+            }
+        }
+    }
+    onFailure(duration, error) {
+        this.slidingWindow.record(false);
+        this.metrics.recordFailure(duration, String(error));
+        this.emit('failure', { duration, error });
+        if (this.state === types_1.CircuitState.HALF_OPEN) {
+            // Any failure in HALF_OPEN immediately opens the circuit
+            this.transitionTo(types_1.CircuitState.OPEN);
+            return;
+        }
+        // Check sliding window failure rate / count
+        const result = this.slidingWindow.getResult();
+        if (result.failureCount >= this.config.failureThreshold) {
+            this.transitionTo(types_1.CircuitState.OPEN);
+        }
+    }
+    transitionTo(newState) {
+        if (this.state === newState)
+            return;
+        const previousState = this.state;
+        this.state = newState;
+        if (newState === types_1.CircuitState.OPEN) {
+            this.nextAttempt = Date.now() + this.config.resetTimeout;
+        }
+        else if (newState === types_1.CircuitState.CLOSED) {
+            this.halfOpenSuccessCount = 0;
+            this.slidingWindow.reset();
+        }
+        else if (newState === types_1.CircuitState.HALF_OPEN) {
+            this.halfOpenSuccessCount = 0;
+        }
+        this.emit('stateChange', previousState, newState);
+        this.config.onStateChange?.(previousState, newState);
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;

package/dist/circuit-breaker/sliding-window.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Sliding Window implementations for Circuit Breaker
+ *
+ * Count-based: tracks the last N calls
+ * Time-based: tracks calls within a rolling time window
+ */
+export interface SlidingWindowResult {
+    totalCalls: number;
+    failureCount: number;
+    failureRate: number;
+}
+/**
+ * Base sliding window interface
+ */
+export interface SlidingWindow {
+    record(success: boolean): void;
+    getResult(): SlidingWindowResult;
+    reset(): void;
+}
+/**
+ * Count-based sliding window
+ * Tracks the last `size` calls regardless of time
+ */
+export declare class CountBasedSlidingWindow implements SlidingWindow {
+    private readonly size;
+    private entries;
+    constructor(size: number);
+    record(success: boolean): void;
+    getResult(): SlidingWindowResult;
+    reset(): void;
+}
+/**
+ * Time-based sliding window
+ * Tracks calls within a rolling time window of `sizeMs` milliseconds
+ */
+export declare class TimeBasedSlidingWindow implements SlidingWindow {
+    private readonly sizeMs;
+    private entries;
+    constructor(sizeMs: number);
+    record(success: boolean): void;
+    getResult(): SlidingWindowResult;
+    reset(): void;
+    private evict;
+}
+/**
+ * Factory to create the appropriate sliding window
+ */
+export declare function createSlidingWindow(type: 'count' | 'time', size: number): SlidingWindow;
+//# sourceMappingURL=sliding-window.d.ts.map

package/dist/circuit-breaker/sliding-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sliding-window.d.ts","sourceRoot":"","sources":["../../src/circuit-breaker/sliding-window.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,SAAS,IAAI,mBAAmB,CAAC;IACjC,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;GAGG;AACH,qBAAa,uBAAwB,YAAW,aAAa;IAG/C,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,OAAO,CAAC,OAAO,CAAiB;gBAEH,IAAI,EAAE,MAAM;IAEzC,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAO9B,SAAS,IAAI,mBAAmB;IAahC,KAAK,IAAI,IAAI;CAGd;AAED;;;GAGG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAG9C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,OAAO,CAAC,OAAO,CAAqB;gBAEP,MAAM,EAAE,MAAM;IAE3C,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAK9B,SAAS,IAAI,mBAAmB;IAchC,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,KAAK;CAUd;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAEvF"}