@revealui/resilience 0.2.0

package/dist/index.js

@@ -0,0 +1,915 @@
+// src/logger.ts
+var resilienceLogger = console;
+function configureResilienceLogger(logger) {
+  resilienceLogger = logger;
+}
+function getResilienceLogger() {
+  return resilienceLogger;
+}
+
+// src/circuit-breaker.ts
+var DEFAULT_CONFIG = {
+  failureThreshold: 5,
+  successThreshold: 2,
+  timeout: 6e4,
+  resetTimeout: 3e4,
+  volumeThreshold: 10,
+  errorFilter: () => true,
+  onStateChange: () => {
+  },
+  onTrip: () => {
+  },
+  onReset: () => {
+  }
+};
+var CircuitBreaker = class {
+  state = "closed";
+  failures = 0;
+  successes = 0;
+  consecutiveFailures = 0;
+  consecutiveSuccesses = 0;
+  totalCalls = 0;
+  totalFailures = 0;
+  totalSuccesses = 0;
+  lastFailureTime;
+  lastSuccessTime;
+  stateChangedAt = Date.now();
+  resetTimer;
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Execute function with circuit breaker
+   */
+  async execute(fn) {
+    if (this.state === "open") {
+      if (Date.now() - this.stateChangedAt >= this.config.resetTimeout) {
+        this.transitionTo("half-open");
+      } else {
+        throw new CircuitBreakerOpenError("Circuit breaker is open");
+      }
+    }
+    this.totalCalls++;
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.onFailure(err);
+      throw error;
+    }
+  }
+  /**
+   * Handle successful execution
+   */
+  onSuccess() {
+    this.successes++;
+    this.consecutiveSuccesses++;
+    this.totalSuccesses++;
+    this.consecutiveFailures = 0;
+    this.lastSuccessTime = Date.now();
+    if (this.state === "half-open") {
+      if (this.consecutiveSuccesses >= this.config.successThreshold) {
+        this.transitionTo("closed");
+      }
+    }
+    if (this.state === "closed") {
+      this.failures = 0;
+    }
+  }
+  /**
+   * Handle failed execution
+   */
+  onFailure(error) {
+    if (!this.config.errorFilter(error)) {
+      return;
+    }
+    this.failures++;
+    this.consecutiveFailures++;
+    this.totalFailures++;
+    this.consecutiveSuccesses = 0;
+    this.lastFailureTime = Date.now();
+    if (this.state === "half-open") {
+      this.transitionTo("open");
+    } else if (this.state === "closed") {
+      if (this.consecutiveFailures >= this.config.failureThreshold && this.totalCalls >= this.config.volumeThreshold) {
+        this.transitionTo("open");
+      }
+    }
+  }
+  /**
+   * Transition to new state
+   */
+  transitionTo(newState) {
+    if (this.state === newState) return;
+    const oldState = this.state;
+    this.state = newState;
+    this.stateChangedAt = Date.now();
+    if (newState === "half-open" || newState === "closed") {
+      this.consecutiveFailures = 0;
+      this.consecutiveSuccesses = 0;
+    }
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer);
+      this.resetTimer = void 0;
+    }
+    if (newState === "open") {
+      this.resetTimer = setTimeout(() => {
+        this.transitionTo("half-open");
+      }, this.config.resetTimeout);
+      this.config.onTrip();
+    }
+    if (newState === "closed" && oldState === "half-open") {
+      this.failures = 0;
+      this.config.onReset();
+    }
+    this.config.onStateChange(newState);
+    getResilienceLogger().info(
+      `Circuit breaker state changed: ${oldState} -> ${newState}`,
+      this.getStats()
+    );
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      state: this.state,
+      failures: this.failures,
+      successes: this.successes,
+      consecutiveFailures: this.consecutiveFailures,
+      consecutiveSuccesses: this.consecutiveSuccesses,
+      totalCalls: this.totalCalls,
+      totalFailures: this.totalFailures,
+      totalSuccesses: this.totalSuccesses,
+      lastFailureTime: this.lastFailureTime,
+      lastSuccessTime: this.lastSuccessTime,
+      stateChangedAt: this.stateChangedAt
+    };
+  }
+  /**
+   * Manually open circuit
+   */
+  trip() {
+    this.transitionTo("open");
+  }
+  /**
+   * Manually close circuit
+   */
+  reset() {
+    this.failures = 0;
+    this.successes = 0;
+    this.consecutiveFailures = 0;
+    this.consecutiveSuccesses = 0;
+    this.transitionTo("closed");
+  }
+  /**
+   * Force state to half-open
+   */
+  halfOpen() {
+    this.transitionTo("half-open");
+  }
+  /**
+   * Check if circuit is open
+   */
+  isOpen() {
+    return this.state === "open";
+  }
+  /**
+   * Check if circuit is closed
+   */
+  isClosed() {
+    return this.state === "closed";
+  }
+  /**
+   * Check if circuit is half-open
+   */
+  isHalfOpen() {
+    return this.state === "half-open";
+  }
+  /**
+   * Get failure rate
+   */
+  getFailureRate() {
+    if (this.totalCalls === 0) return 0;
+    return this.totalFailures / this.totalCalls;
+  }
+  /**
+   * Get success rate
+   */
+  getSuccessRate() {
+    if (this.totalCalls === 0) return 0;
+    return this.totalSuccesses / this.totalCalls;
+  }
+  /**
+   * Cleanup
+   */
+  destroy() {
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer);
+    }
+  }
+};
+var CircuitBreakerOpenError = class extends Error {
+  constructor(message = "Circuit breaker is open") {
+    super(message);
+    this.name = "CircuitBreakerOpenError";
+  }
+};
+var CircuitBreakerRegistry = class {
+  breakers = /* @__PURE__ */ new Map();
+  /**
+   * Get or create circuit breaker
+   */
+  get(name, config) {
+    let breaker = this.breakers.get(name);
+    if (!breaker) {
+      breaker = new CircuitBreaker(config);
+      this.breakers.set(name, breaker);
+    }
+    return breaker;
+  }
+  /**
+   * Check if breaker exists
+   */
+  has(name) {
+    return this.breakers.has(name);
+  }
+  /**
+   * Remove circuit breaker
+   */
+  remove(name) {
+    const breaker = this.breakers.get(name);
+    if (breaker) {
+      breaker.destroy();
+      return this.breakers.delete(name);
+    }
+    return false;
+  }
+  /**
+   * Get all breakers
+   */
+  getAll() {
+    return new Map(this.breakers);
+  }
+  /**
+   * Get all statistics
+   */
+  getAllStats() {
+    const stats = {};
+    for (const [name, breaker] of this.breakers) {
+      stats[name] = breaker.getStats();
+    }
+    return stats;
+  }
+  /**
+   * Reset all breakers
+   */
+  resetAll() {
+    for (const breaker of this.breakers.values()) {
+      breaker.reset();
+    }
+  }
+  /**
+   * Clear all breakers
+   */
+  clear() {
+    for (const breaker of this.breakers.values()) {
+      breaker.destroy();
+    }
+    this.breakers.clear();
+  }
+};
+var circuitBreakerRegistry = new CircuitBreakerRegistry();
+function CircuitBreak(nameOrConfig = {}) {
+  return (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    const name = typeof nameOrConfig === "string" ? nameOrConfig : `${target.constructor.name}.${propertyKey}`;
+    const config = typeof nameOrConfig === "object" ? nameOrConfig : void 0;
+    descriptor.value = async function(...args) {
+      const breaker = circuitBreakerRegistry.get(name, config);
+      return breaker.execute(() => originalMethod.apply(this, args));
+    };
+    return descriptor;
+  };
+}
+async function withCircuitBreaker(name, fn, config) {
+  const breaker = circuitBreakerRegistry.get(name, config);
+  return breaker.execute(fn);
+}
+function createCircuitBreakerMiddleware(name, config) {
+  const breaker = circuitBreakerRegistry.get(name, config);
+  return async (_request, next) => {
+    return breaker.execute(next);
+  };
+}
+async function fetchWithCircuitBreaker(name, url, init, config) {
+  const breaker = circuitBreakerRegistry.get(name, config);
+  return breaker.execute(async () => {
+    const response = await fetch(url, init);
+    if (response.status >= 500) {
+      const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+      error.statusCode = response.status;
+      throw error;
+    }
+    return response;
+  });
+}
+var AdaptiveCircuitBreaker = class extends CircuitBreaker {
+  errorRateWindow = [];
+  windowSize = 100;
+  adaptiveThreshold;
+  constructor(config = {}) {
+    super(config);
+    this.adaptiveThreshold = config.failureThreshold || 5;
+  }
+  /**
+   * Execute with adaptive thresholds
+   */
+  async execute(fn) {
+    try {
+      const result = await super.execute(fn);
+      this.recordSuccess();
+      return result;
+    } catch (error) {
+      this.recordFailure();
+      throw error;
+    }
+  }
+  /**
+   * Record success in window
+   */
+  recordSuccess() {
+    this.errorRateWindow.push(0);
+    this.trimWindow();
+    this.adjustThreshold();
+  }
+  /**
+   * Record failure in window
+   */
+  recordFailure() {
+    this.errorRateWindow.push(1);
+    this.trimWindow();
+    this.adjustThreshold();
+  }
+  /**
+   * Trim window to size
+   */
+  trimWindow() {
+    if (this.errorRateWindow.length > this.windowSize) {
+      this.errorRateWindow.shift();
+    }
+  }
+  /**
+   * Adjust threshold based on error rate
+   */
+  adjustThreshold() {
+    const errorRate = this.getWindowErrorRate();
+    if (errorRate < 0.1) {
+      this.adaptiveThreshold = Math.min(this.adaptiveThreshold + 1, 20);
+    } else if (errorRate > 0.5) {
+      this.adaptiveThreshold = Math.max(this.adaptiveThreshold - 1, 2);
+    }
+    this.config.failureThreshold = this.adaptiveThreshold;
+  }
+  /**
+   * Get error rate in window
+   */
+  getWindowErrorRate() {
+    if (this.errorRateWindow.length === 0) return 0;
+    const errors = this.errorRateWindow.reduce((sum, val) => sum + val, 0);
+    return errors / this.errorRateWindow.length;
+  }
+  /**
+   * Get adaptive threshold
+   */
+  getAdaptiveThreshold() {
+    return this.adaptiveThreshold;
+  }
+};
+var Bulkhead = class {
+  activeRequests = 0;
+  queue = [];
+  maxConcurrent;
+  maxQueue;
+  constructor(maxConcurrent = 10, maxQueue = 100) {
+    this.maxConcurrent = maxConcurrent;
+    this.maxQueue = maxQueue;
+  }
+  /**
+   * Execute with bulkhead
+   */
+  async execute(fn) {
+    if (this.activeRequests >= this.maxConcurrent) {
+      if (this.queue.length >= this.maxQueue) {
+        throw new Error("Bulkhead queue is full");
+      }
+      await new Promise((resolve) => {
+        this.queue.push(resolve);
+      });
+    }
+    this.activeRequests++;
+    try {
+      return await fn();
+    } finally {
+      this.activeRequests--;
+      const next = this.queue.shift();
+      if (next) {
+        next();
+      }
+    }
+  }
+  /**
+   * Get active requests
+   */
+  getActiveRequests() {
+    return this.activeRequests;
+  }
+  /**
+   * Get queue size
+   */
+  getQueueSize() {
+    return this.queue.length;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      activeRequests: this.activeRequests,
+      queueSize: this.queue.length,
+      maxConcurrent: this.maxConcurrent,
+      maxQueue: this.maxQueue
+    };
+  }
+};
+var ResilientOperation = class {
+  constructor(fn, circuitBreaker, bulkhead) {
+    this.fn = fn;
+    this.circuitBreaker = circuitBreaker;
+    this.bulkhead = bulkhead;
+  }
+  /**
+   * Execute with all resilience patterns
+   */
+  async execute() {
+    const executeFn = async () => {
+      if (this.bulkhead) {
+        return this.bulkhead.execute(this.fn);
+      }
+      return this.fn();
+    };
+    if (this.circuitBreaker) {
+      return this.circuitBreaker.execute(executeFn);
+    }
+    return executeFn();
+  }
+};
+function createResilientFunction(fn, options = {}) {
+  const breaker = options.circuitBreaker ? new CircuitBreaker(options.circuitBreaker) : void 0;
+  const bulkhead = options.bulkhead ? new Bulkhead(options.bulkhead.maxConcurrent, options.bulkhead.maxQueue) : void 0;
+  const operation = new ResilientOperation(fn, breaker, bulkhead);
+  return () => operation.execute();
+}
+
+// src/retry.ts
+import { randomInt } from "crypto";
+var DEFAULT_CONFIG2 = {
+  maxRetries: 3,
+  baseDelay: 1e3,
+  maxDelay: 3e4,
+  exponentialBackoff: true,
+  jitter: true,
+  retryableErrors: (error) => {
+    if ("statusCode" in error) {
+      const statusCode = error.statusCode;
+      if (statusCode !== void 0 && statusCode >= 400 && statusCode < 500) {
+        return statusCode === 408 || statusCode === 429;
+      }
+    }
+    return true;
+  },
+  onRetry: () => {
+  }
+};
+async function retry(fn, config = {}, options = {}) {
+  const mergedConfig = { ...DEFAULT_CONFIG2, ...config };
+  let lastError = new Error("Retry failed");
+  for (let attempt = 0; attempt <= mergedConfig.maxRetries; attempt++) {
+    try {
+      if (options.signal?.aborted) {
+        throw new Error("Request aborted");
+      }
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt === mergedConfig.maxRetries) {
+        throw lastError;
+      }
+      if (!mergedConfig.retryableErrors(lastError)) {
+        throw lastError;
+      }
+      mergedConfig.onRetry(lastError, attempt + 1);
+      const delay = calculateDelay(
+        attempt,
+        mergedConfig.baseDelay,
+        mergedConfig.maxDelay,
+        mergedConfig.exponentialBackoff,
+        mergedConfig.jitter
+      );
+      await sleep(delay, options.signal);
+    }
+  }
+  throw lastError;
+}
+function calculateDelay(attempt, baseDelay, maxDelay, exponentialBackoff, jitter) {
+  let delay = baseDelay;
+  if (exponentialBackoff) {
+    delay = Math.min(baseDelay * 2 ** attempt, maxDelay);
+  }
+  if (jitter) {
+    const jitterAmount = Math.ceil(delay * 0.25);
+    if (jitterAmount > 0) {
+      delay = delay + randomInt(jitterAmount * 2 + 1) - jitterAmount;
+    }
+  }
+  return Math.floor(Math.min(delay, maxDelay));
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Request aborted"));
+      return;
+    }
+    const timeout = setTimeout(resolve, ms);
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        clearTimeout(timeout);
+        reject(new Error("Request aborted"));
+      });
+    }
+  });
+}
+async function fetchWithRetry(url, init, config) {
+  const abortController = new AbortController();
+  const signal = init?.signal || abortController.signal;
+  return retry(
+    async () => {
+      const response = await fetch(url, {
+        ...init,
+        signal
+      });
+      if (!response.ok) {
+        const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+        error.statusCode = response.status;
+        error.response = response;
+        throw error;
+      }
+      return response;
+    },
+    {
+      ...config,
+      retryableErrors: (error) => {
+        if (config?.retryableErrors && !config.retryableErrors(error)) {
+          return false;
+        }
+        if ("statusCode" in error) {
+          const statusCode = error.statusCode;
+          if (statusCode !== void 0 && statusCode >= 400 && statusCode < 500) {
+            return statusCode === 408 || statusCode === 429;
+          }
+        }
+        return true;
+      }
+    },
+    { signal }
+  );
+}
+var RetryableOperation = class {
+  constructor(fn, config = {}) {
+    this.fn = fn;
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+    this.abortController = new AbortController();
+  }
+  config;
+  abortController;
+  attempts = 0;
+  lastError;
+  /**
+   * Execute with retry
+   */
+  async execute() {
+    return retry(this.fn, this.config, { signal: this.abortController.signal });
+  }
+  /**
+   * Abort operation
+   */
+  abort() {
+    this.abortController.abort();
+  }
+  /**
+   * Get retry statistics
+   */
+  getStats() {
+    return {
+      attempts: this.attempts,
+      lastError: this.lastError
+    };
+  }
+};
+function Retryable(config) {
+  return (_target, _propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      return retry(() => originalMethod.apply(this, args), config);
+    };
+    return descriptor;
+  };
+}
+function createRetryMiddleware(config = {}) {
+  return async (_request, next) => {
+    return retry(next, config);
+  };
+}
+async function retryBatch(operations, config = {}) {
+  return Promise.all(
+    operations.map(async (op) => {
+      try {
+        return await retry(op, config);
+      } catch (error) {
+        return error instanceof Error ? error : new Error(String(error));
+      }
+    })
+  );
+}
+async function retryWithFallback(primary, fallback, config = {}) {
+  try {
+    return await retry(primary, config);
+  } catch (error) {
+    getResilienceLogger().warn("Primary operation failed, trying fallback", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return fallback();
+  }
+}
+async function retryIf(fn, condition, config = {}) {
+  return retry(fn, {
+    ...config,
+    retryableErrors: (error) => {
+      const originalCheck = config.retryableErrors?.(error) ?? DEFAULT_CONFIG2.retryableErrors(error);
+      if (!originalCheck) return false;
+      return condition(error, 0);
+    }
+  });
+}
+async function retryUntil(fn, predicate, config = {}, maxAttempts = 10) {
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    try {
+      const result = await fn();
+      if (predicate(result)) {
+        return result;
+      }
+      attempts++;
+      if (attempts >= maxAttempts) {
+        throw new Error("Max attempts reached without matching predicate");
+      }
+      const delay = calculateDelay(
+        attempts - 1,
+        config.baseDelay ?? DEFAULT_CONFIG2.baseDelay,
+        config.maxDelay ?? DEFAULT_CONFIG2.maxDelay,
+        config.exponentialBackoff ?? DEFAULT_CONFIG2.exponentialBackoff,
+        config.jitter ?? DEFAULT_CONFIG2.jitter
+      );
+      await sleep(delay);
+    } catch (error) {
+      attempts++;
+      if (attempts >= maxAttempts) {
+        throw error;
+      }
+      const delay = calculateDelay(
+        attempts - 1,
+        config.baseDelay ?? DEFAULT_CONFIG2.baseDelay,
+        config.maxDelay ?? DEFAULT_CONFIG2.maxDelay,
+        config.exponentialBackoff ?? DEFAULT_CONFIG2.exponentialBackoff,
+        config.jitter ?? DEFAULT_CONFIG2.jitter
+      );
+      await sleep(delay);
+    }
+  }
+  throw new Error("Max attempts reached");
+}
+var ExponentialBackoff = class {
+  constructor(baseDelay = 1e3, maxDelay = 3e4, maxAttempts = 10, jitter = true) {
+    this.baseDelay = baseDelay;
+    this.maxDelay = maxDelay;
+    this.maxAttempts = maxAttempts;
+    this.jitter = jitter;
+  }
+  async *[Symbol.asyncIterator]() {
+    for (let attempt = 0; attempt < this.maxAttempts; attempt++) {
+      const delay = calculateDelay(attempt, this.baseDelay, this.maxDelay, true, this.jitter);
+      yield delay;
+      await sleep(delay);
+    }
+  }
+};
+var RetryPolicyBuilder = class {
+  config = {};
+  /**
+   * Set max retries
+   */
+  maxRetries(count) {
+    this.config.maxRetries = count;
+    return this;
+  }
+  /**
+   * Set base delay
+   */
+  baseDelay(ms) {
+    this.config.baseDelay = ms;
+    return this;
+  }
+  /**
+   * Set max delay
+   */
+  maxDelay(ms) {
+    this.config.maxDelay = ms;
+    return this;
+  }
+  /**
+   * Enable/disable exponential backoff
+   */
+  exponentialBackoff(enabled = true) {
+    this.config.exponentialBackoff = enabled;
+    return this;
+  }
+  /**
+   * Enable/disable jitter
+   */
+  jitter(enabled = true) {
+    this.config.jitter = enabled;
+    return this;
+  }
+  /**
+   * Set custom retryable errors function
+   */
+  retryOn(fn) {
+    this.config.retryableErrors = fn;
+    return this;
+  }
+  /**
+   * Set retry callback
+   */
+  onRetry(fn) {
+    this.config.onRetry = fn;
+    return this;
+  }
+  /**
+   * Build retry config
+   */
+  build() {
+    return this.config;
+  }
+  /**
+   * Execute function with built policy
+   */
+  async execute(fn) {
+    return retry(fn, this.build());
+  }
+};
+var RetryPolicies = {
+  /**
+   * Default policy - 3 retries with exponential backoff
+   */
+  default: () => ({
+    maxRetries: 3,
+    baseDelay: 1e3,
+    maxDelay: 3e4,
+    exponentialBackoff: true,
+    jitter: true
+  }),
+  /**
+   * Aggressive policy - more retries, faster backoff
+   */
+  aggressive: () => ({
+    maxRetries: 5,
+    baseDelay: 500,
+    maxDelay: 1e4,
+    exponentialBackoff: true,
+    jitter: true
+  }),
+  /**
+   * Conservative policy - fewer retries, longer backoff
+   */
+  conservative: () => ({
+    maxRetries: 2,
+    baseDelay: 2e3,
+    maxDelay: 6e4,
+    exponentialBackoff: true,
+    jitter: true
+  }),
+  /**
+   * Linear backoff policy
+   */
+  linear: () => ({
+    maxRetries: 3,
+    baseDelay: 1e3,
+    maxDelay: 1e4,
+    exponentialBackoff: false,
+    jitter: false
+  }),
+  /**
+   * Immediate retry policy - no delay
+   */
+  immediate: () => ({
+    maxRetries: 3,
+    baseDelay: 0,
+    maxDelay: 0,
+    exponentialBackoff: false,
+    jitter: false
+  }),
+  /**
+   * Network error only policy
+   */
+  networkOnly: () => ({
+    maxRetries: 3,
+    baseDelay: 1e3,
+    maxDelay: 3e4,
+    exponentialBackoff: true,
+    jitter: true,
+    retryableErrors: (error) => error.name === "NetworkError"
+  }),
+  /**
+   * Idempotent operations policy (safe to retry)
+   */
+  idempotent: () => ({
+    maxRetries: 5,
+    baseDelay: 1e3,
+    maxDelay: 3e4,
+    exponentialBackoff: true,
+    jitter: true
+  })
+};
+var GlobalRetryConfig = class {
+  config = RetryPolicies.default();
+  /**
+   * Set global retry config
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Get global retry config
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Reset to default config
+   */
+  reset() {
+    this.config = RetryPolicies.default();
+  }
+};
+var globalRetryConfig = new GlobalRetryConfig();
+export {
+  AdaptiveCircuitBreaker,
+  Bulkhead,
+  CircuitBreak,
+  CircuitBreaker,
+  CircuitBreakerOpenError,
+  CircuitBreakerRegistry,
+  ExponentialBackoff,
+  ResilientOperation,
+  RetryPolicies,
+  RetryPolicyBuilder,
+  Retryable,
+  RetryableOperation,
+  calculateDelay,
+  circuitBreakerRegistry,
+  configureResilienceLogger,
+  createCircuitBreakerMiddleware,
+  createResilientFunction,
+  createRetryMiddleware,
+  fetchWithCircuitBreaker,
+  fetchWithRetry,
+  getResilienceLogger,
+  globalRetryConfig,
+  retry,
+  retryBatch,
+  retryIf,
+  retryUntil,
+  retryWithFallback,
+  sleep,
+  withCircuitBreaker
+};
+//# sourceMappingURL=index.js.map