Adaptive

// Adaptive breaker: exp-backoff cooldown + ramped recovery.
type State = "CLOSED" | "OPEN" | "RECOVERING";

class AdaptiveBreaker {
  private state: State = "CLOSED";
  private calls: boolean[] = [];
  private streak = 0;                 // re-trip count, drives backoff
  private cooldownMs;
  private openUntil = 0;
  private rampIdx = 0;
  private rampOk = 0;

  // 10 → 25 → 50 → 100% admission during recovery
  private static ADMIT = [10, 25, 50, 100];

  constructor(
    private size = 12,
    private threshold = 0.5,
    private baseMs = 3_000,
    private maxMs = 24_000,
    private probesPerStep = 2,
  ) { this.cooldownMs = baseMs; }

  async call<T>(work: () => Promise<T>): Promise<T> {
    if (this.state === "OPEN" && Date.now() >= this.openUntil) this.toRecovering();
    if (this.state === "OPEN") throw new Error("circuit open");

    if (this.state === "RECOVERING") {
      // Admit a probabilistic slice; the rest are short-circuited.
      const admit = AdaptiveBreaker.ADMIT[this.rampIdx];
      if (Math.random() * 100 >= admit) throw new Error("recovering · held back");
    }

    try {
      const result = await work();
      this.onResult(true);
      return result;
    } catch (err) {
      this.onResult(false);
      throw err;
    }
  }

  private onResult(ok: boolean) {
    if (this.state === "RECOVERING") {
      if (!ok) { this.trip(); return; }
      this.rampOk++;
      if (this.rampOk >= this.probesPerStep) {
        if (this.rampIdx < AdaptiveBreaker.ADMIT.length - 1) {
          this.rampIdx++; this.rampOk = 0;
        } else { this.close(); }
      }
      return;
    }
    this.calls.push(ok);
    if (this.calls.length > this.size) this.calls.shift();
    const fails = this.calls.filter(c => !c).length;
    if (this.calls.length >= Math.min(5, this.size) && fails / this.calls.length >= this.threshold) {
      this.trip();
    }
  }

  private trip() {
    this.streak++;
    this.cooldownMs = Math.min(this.baseMs * 2 ** (this.streak - 1), this.maxMs);
    this.state = "OPEN";
    this.openUntil = Date.now() + this.cooldownMs;
    this.rampIdx = 0; this.rampOk = 0;
  }
  private toRecovering() { this.state = "RECOVERING"; this.rampIdx = 0; this.rampOk = 0; }
  private close() {
    this.state = "CLOSED"; this.calls = []; this.streak = 0;
    this.cooldownMs = this.baseMs; this.rampIdx = 0; this.rampOk = 0;
  }
}