Dependencies and Graceful Degradation

// a minimal circuit breaker with a timeout and a retry budget
class Breaker {
  private failures = 0; private openedAt = 0; private state: 'closed' | 'open' | 'half' = 'closed';
  constructor(private threshold = 5, private coolMs = 10_000) {}
  async call<T>(fn: (signal: AbortSignal) => Promise<T>, timeoutMs: number): Promise<T> {
    if (this.state === 'open') {
      if (Date.now() - this.openedAt < this.coolMs) throw new Error('circuit open');   // fail fast
      this.state = 'half';                                                             // let a trial through
    }
    try {
      const r = await fn(AbortSignal.timeout(timeoutMs));
      this.failures = 0; this.state = 'closed'; return r;
    } catch (e) {
      if (++this.failures >= this.threshold || this.state === 'half') { this.state = 'open'; this.openedAt = Date.now(); }
      throw e;
    }
  }
}

const retryTokens = { n: 0, max: 0 };                     // refilled at 10% of request volume each second
async function withRetry<T>(fn: () => Promise<T>, idempotent: boolean): Promise<T> {
  for (let attempt = 0; ; attempt++) {
    try { return await fn(); }
    catch (e) {
      if (!idempotent || attempt >= 2 || retryTokens.n <= 0) throw e;
      retryTokens.n--;
      await sleep(Math.random() * 100 * 2 ** attempt);    // full jitter
    }
  }
}