@nextn/outbound-guard 0.1.0 → 0.1.2

package/dist/{src/index.d.cts → index.d.cts}

@@ -28,21 +28,28 @@ interface MicroCacheOptions {
     keyFn?: (req: ResilientRequest) => string;
     retry?: MicroCacheRetryOptions;
 }
+interface HealthOptions {
+    enabled?: boolean;
+}
 interface ResilientHttpClientOptions {
+    /**
+     * Applied per base URL (scheme + host + port).
+     */
     maxInFlight: number;
-    maxQueue: number;
-    enqueueTimeoutMs: number;
-    requestTimeoutMs: number;
     /**
-     * GET-only micro-cache + request coalescing.
+     * Per-attempt timeout.
      */
+    requestTimeoutMs: number;
+    health?: HealthOptions;
     microCache?: MicroCacheOptions;
 }
 
 declare class ResilientHttpClient extends EventEmitter {
     private readonly opts;
-    private readonly limiter;
     private readonly requestTimeoutMs;
+    private readonly healthEnabled;
+    private readonly limiters;
+    private readonly health;
     private readonly microCache?;
     private cache?;
     private inFlight?;
@@ -50,28 +57,24 @@ declare class ResilientHttpClient extends EventEmitter {
     private readonly cleanupEveryNRequests;
     constructor(opts: ResilientHttpClientOptions);
     request(req: ResilientRequest): Promise<ResilientResponse>;
+    snapshot(): {
+        inFlight: number;
+        queueDepth: number;
+    };
+    private getLimiter;
+    private getHealth;
+    private closeHealth;
+    private halfOpenHealth;
+    private openHealth;
+    private recordOutcome;
+    private execute;
     private cloneResponse;
     private maybeCleanupExpired;
     private evictIfNeeded;
     private isRetryableStatus;
     private computeBackoffMs;
     private fetchWithLeaderRetry;
-    /**
-     * Window behavior:
-     * - 0..ttlMs: return cache (fresh)
-     * - ttlMs..maxStaleMs: leader refreshes; others get old value until replaced (stale-while-revalidate)
-     * - >maxStaleMs: do not serve old; behave like no cache
-     *
-     * Follower controls (only when no cache is served):
-     * - maxWaiters: cap concurrent followers joining the leader
-     * - followerTimeoutMs: shared "join window" from first follower; after it expires, late followers fail fast until leader completes
-     */
     private requestWithMicroCache;
-    private existingPipeline;
-    snapshot(): {
-        inFlight: number;
-        queueDepth: number;
-    };
 }
 
 declare abstract class ResilientHttpError extends Error {
@@ -94,5 +97,14 @@ declare class UpstreamError extends ResilientHttpError {
     readonly status: number;
     constructor(status: number);
 }
+declare class UpstreamUnhealthyError extends ResilientHttpError {
+    readonly baseUrl: string;
+    readonly state: string;
+    constructor(baseUrl: string, state: string);
+}
+declare class HalfOpenRejectedError extends ResilientHttpError {
+    readonly baseUrl: string;
+    constructor(baseUrl: string);
+}
 
-export { type HttpMethod, type MicroCacheOptions, type MicroCacheRetryOptions, QueueFullError, QueueTimeoutError, RequestTimeoutError, ResilientHttpClient, type ResilientHttpClientOptions, ResilientHttpError, type ResilientRequest, type ResilientResponse, UpstreamError };
+export { HalfOpenRejectedError, type HealthOptions, type HttpMethod, type MicroCacheOptions, type MicroCacheRetryOptions, QueueFullError, QueueTimeoutError, RequestTimeoutError, ResilientHttpClient, type ResilientHttpClientOptions, ResilientHttpError, type ResilientRequest, type ResilientResponse, UpstreamError, UpstreamUnhealthyError };

package/dist/{src/index.d.ts → index.d.ts}

@@ -28,21 +28,28 @@ interface MicroCacheOptions {
     keyFn?: (req: ResilientRequest) => string;
     retry?: MicroCacheRetryOptions;
 }
+interface HealthOptions {
+    enabled?: boolean;
+}
 interface ResilientHttpClientOptions {
+    /**
+     * Applied per base URL (scheme + host + port).
+     */
     maxInFlight: number;
-    maxQueue: number;
-    enqueueTimeoutMs: number;
-    requestTimeoutMs: number;
     /**
-     * GET-only micro-cache + request coalescing.
+     * Per-attempt timeout.
      */
+    requestTimeoutMs: number;
+    health?: HealthOptions;
     microCache?: MicroCacheOptions;
 }
 
 declare class ResilientHttpClient extends EventEmitter {
     private readonly opts;
-    private readonly limiter;
     private readonly requestTimeoutMs;
+    private readonly healthEnabled;
+    private readonly limiters;
+    private readonly health;
     private readonly microCache?;
     private cache?;
     private inFlight?;
@@ -50,28 +57,24 @@ declare class ResilientHttpClient extends EventEmitter {
     private readonly cleanupEveryNRequests;
     constructor(opts: ResilientHttpClientOptions);
     request(req: ResilientRequest): Promise<ResilientResponse>;
+    snapshot(): {
+        inFlight: number;
+        queueDepth: number;
+    };
+    private getLimiter;
+    private getHealth;
+    private closeHealth;
+    private halfOpenHealth;
+    private openHealth;
+    private recordOutcome;
+    private execute;
     private cloneResponse;
     private maybeCleanupExpired;
     private evictIfNeeded;
     private isRetryableStatus;
     private computeBackoffMs;
     private fetchWithLeaderRetry;
-    /**
-     * Window behavior:
-     * - 0..ttlMs: return cache (fresh)
-     * - ttlMs..maxStaleMs: leader refreshes; others get old value until replaced (stale-while-revalidate)
-     * - >maxStaleMs: do not serve old; behave like no cache
-     *
-     * Follower controls (only when no cache is served):
-     * - maxWaiters: cap concurrent followers joining the leader
-     * - followerTimeoutMs: shared "join window" from first follower; after it expires, late followers fail fast until leader completes
-     */
     private requestWithMicroCache;
-    private existingPipeline;
-    snapshot(): {
-        inFlight: number;
-        queueDepth: number;
-    };
 }
 
 declare abstract class ResilientHttpError extends Error {
@@ -94,5 +97,14 @@ declare class UpstreamError extends ResilientHttpError {
     readonly status: number;
     constructor(status: number);
 }
+declare class UpstreamUnhealthyError extends ResilientHttpError {
+    readonly baseUrl: string;
+    readonly state: string;
+    constructor(baseUrl: string, state: string);
+}
+declare class HalfOpenRejectedError extends ResilientHttpError {
+    readonly baseUrl: string;
+    constructor(baseUrl: string);
+}
 
-export { type HttpMethod, type MicroCacheOptions, type MicroCacheRetryOptions, QueueFullError, QueueTimeoutError, RequestTimeoutError, ResilientHttpClient, type ResilientHttpClientOptions, ResilientHttpError, type ResilientRequest, type ResilientResponse, UpstreamError };
+export { HalfOpenRejectedError, type HealthOptions, type HttpMethod, type MicroCacheOptions, type MicroCacheRetryOptions, QueueFullError, QueueTimeoutError, RequestTimeoutError, ResilientHttpClient, type ResilientHttpClientOptions, ResilientHttpError, type ResilientRequest, type ResilientResponse, UpstreamError, UpstreamUnhealthyError };

package/dist/{src/index.js → index.js}

@@ -33,12 +33,24 @@ var UpstreamError = class extends ResilientHttpError {
     this.status = status;
   }
 };
+var UpstreamUnhealthyError = class extends ResilientHttpError {
+  constructor(baseUrl, state) {
+    super(`Upstream is unhealthy (state=${state}, baseUrl=${baseUrl}).`);
+    this.baseUrl = baseUrl;
+    this.state = state;
+  }
+};
+var HalfOpenRejectedError = class extends ResilientHttpError {
+  constructor(baseUrl) {
+    super(`Upstream is HALF_OPEN (probe only) for baseUrl=${baseUrl}.`);
+    this.baseUrl = baseUrl;
+  }
+};
 
 // src/limiter.ts
 var ConcurrencyLimiter = class {
   maxInFlight;
   maxQueue;
-  enqueueTimeoutMs;
   inFlight = 0;
   queue = [];
   constructor(opts) {
@@ -48,17 +60,9 @@ var ConcurrencyLimiter = class {
     if (!Number.isFinite(opts.maxQueue) || opts.maxQueue < 0) {
       throw new Error(`maxQueue must be >= 0 (got ${opts.maxQueue})`);
     }
-    if (!Number.isFinite(opts.enqueueTimeoutMs) || opts.enqueueTimeoutMs <= 0) {
-      throw new Error(`enqueueTimeoutMs must be > 0 (got ${opts.enqueueTimeoutMs})`);
-    }
     this.maxInFlight = opts.maxInFlight;
     this.maxQueue = opts.maxQueue;
-    this.enqueueTimeoutMs = opts.enqueueTimeoutMs;
   }
-  /**
-   * Acquire a permit. Resolves once you are allowed to proceed.
-   * MUST be followed by `release()` exactly once.
-   */
   acquire() {
     if (this.inFlight < this.maxInFlight) {
       this.inFlight += 1;
@@ -68,32 +72,36 @@ var ConcurrencyLimiter = class {
       return Promise.reject(new QueueFullError(this.maxQueue));
     }
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        const idx = this.queue.findIndex((w) => w.resolve === resolve);
-        if (idx >= 0) {
-          const [w] = this.queue.splice(idx, 1);
-          clearTimeout(w.timer);
-        }
-        reject(new QueueTimeoutError(this.enqueueTimeoutMs));
-      }, this.enqueueTimeoutMs);
-      this.queue.push({ resolve, reject, timer });
+      this.queue.push({ resolve, reject });
     });
   }
   /**
-   * Release a permit. Always call this in a `finally` block.
+   * Acquire without queueing: either start now or fail.
+   * Used for HALF_OPEN probes so recovery never waits behind backlog.
    */
+  acquireNoQueue() {
+    if (this.inFlight < this.maxInFlight) {
+      this.inFlight += 1;
+      return Promise.resolve();
+    }
+    return Promise.reject(new QueueFullError(0));
+  }
   release() {
     if (this.inFlight <= 0) {
       throw new Error("release() called when inFlight is already 0");
     }
     const next = this.queue.shift();
     if (next) {
-      clearTimeout(next.timer);
       next.resolve();
       return;
     }
     this.inFlight -= 1;
   }
+  flush(err) {
+    const q = this.queue;
+    this.queue = [];
+    for (const w of q) w.reject(err);
+  }
   snapshot() {
     return {
       inFlight: this.inFlight,
@@ -151,6 +159,14 @@ function normalizeUrlForKey(rawUrl) {
   if (isHttpDefault || isHttpsDefault) u.port = "";
   return u.toString();
 }
+function baseUrlKey(rawUrl) {
+  const u = new URL(rawUrl);
+  u.hostname = u.hostname.toLowerCase();
+  const isHttpDefault = u.protocol === "http:" && u.port === "80";
+  const isHttpsDefault = u.protocol === "https:" && u.port === "443";
+  if (isHttpDefault || isHttpsDefault) u.port = "";
+  return `${u.protocol}//${u.host}`;
+}
 function defaultMicroCacheKeyFn(req) {
   return `GET ${normalizeUrlForKey(req.url)}`;
 }
@@ -163,16 +179,46 @@ function sleep(ms) {
 function clamp(n, lo, hi) {
   return Math.max(lo, Math.min(hi, n));
 }
+function jitterMs(ms) {
+  const mult = 0.8 + Math.random() * 0.4;
+  return Math.round(ms * mult);
+}
+var SOFT_FAIL_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+function classifyHttpStatus(status) {
+  if (status >= 200 && status < 300) return "SUCCESS";
+  if (SOFT_FAIL_STATUSES.has(status)) return "SOFT_FAIL";
+  return "SUCCESS";
+}
+function computeRates(window) {
+  const total = window.length;
+  let hard = 0;
+  let soft = 0;
+  for (const o of window) {
+    if (o === "HARD_FAIL") hard += 1;
+    else if (o === "SOFT_FAIL") soft += 1;
+  }
+  return {
+    total,
+    hard,
+    soft,
+    hardFailRate: total === 0 ? 0 : hard / total,
+    failRate: total === 0 ? 0 : (hard + soft) / total
+  };
+}
+function shouldCountAsHardFail(err) {
+  if (err instanceof UpstreamUnhealthyError) return false;
+  if (err instanceof HalfOpenRejectedError) return false;
+  if (err instanceof QueueFullError) return false;
+  if (err instanceof RequestTimeoutError) return true;
+  if (err instanceof ResilientHttpError) return false;
+  return true;
+}
 var ResilientHttpClient = class extends EventEmitter {
   constructor(opts) {
     super();
     this.opts = opts;
-    this.limiter = new ConcurrencyLimiter({
-      maxInFlight: opts.maxInFlight,
-      maxQueue: opts.maxQueue,
-      enqueueTimeoutMs: opts.enqueueTimeoutMs
-    });
     this.requestTimeoutMs = opts.requestTimeoutMs;
+    this.healthEnabled = opts.health?.enabled ?? true;
     const mc = opts.microCache;
     if (mc?.enabled) {
       const retry = mc.retry ? {
@@ -195,8 +241,10 @@ var ResilientHttpClient = class extends EventEmitter {
       this.inFlight = /* @__PURE__ */ new Map();
     }
   }
-  limiter;
   requestTimeoutMs;
+  healthEnabled;
+  limiters = /* @__PURE__ */ new Map();
+  health = /* @__PURE__ */ new Map();
   microCache;
   cache;
   inFlight;
@@ -206,14 +254,188 @@ var ResilientHttpClient = class extends EventEmitter {
     if (this.microCache?.enabled && req.method === "GET" && req.body == null) {
       return this.requestWithMicroCache(req);
     }
-    return this.existingPipeline(req);
+    return this.execute(req, { allowProbe: false });
+  }
+  snapshot() {
+    let inFlight = 0;
+    let queueDepth = 0;
+    for (const l of this.limiters.values()) {
+      const s = l.snapshot();
+      inFlight += s.inFlight;
+      queueDepth += s.queueDepth;
+    }
+    return { inFlight, queueDepth };
+  }
+  /* ---------------- internals ---------------- */
+  getLimiter(baseKey) {
+    let l = this.limiters.get(baseKey);
+    if (!l) {
+      l = new ConcurrencyLimiter({
+        maxInFlight: this.opts.maxInFlight,
+        maxQueue: this.opts.maxInFlight * 10
+        // hidden factor
+      });
+      this.limiters.set(baseKey, l);
+    }
+    return l;
+  }
+  getHealth(baseKey) {
+    let h = this.health.get(baseKey);
+    if (!h) {
+      h = {
+        state: "OPEN",
+        window: [],
+        windowSize: 20,
+        minSamples: 10,
+        consecutiveHardFails: 0,
+        cooldownBaseMs: 1e3,
+        cooldownCapMs: 3e4,
+        cooldownMs: 1e3,
+        cooldownUntil: 0,
+        probeInFlight: false,
+        probeRemaining: 0,
+        stableNonHard: 0
+      };
+      this.health.set(baseKey, h);
+    }
+    return h;
   }
+  closeHealth(baseKey, reason) {
+    const h = this.getHealth(baseKey);
+    if (h.state === "CLOSED") return;
+    h.state = "CLOSED";
+    h.cooldownUntil = Date.now() + jitterMs(h.cooldownMs);
+    h.cooldownMs = Math.min(h.cooldownMs * 2, h.cooldownCapMs);
+    this.getLimiter(baseKey).flush(new UpstreamUnhealthyError(baseKey, "CLOSED"));
+    const rates = computeRates(h.window);
+    this.emit("health:closed", {
+      baseUrl: baseKey,
+      reason,
+      cooldownMs: h.cooldownUntil - Date.now(),
+      hardFailRate: rates.hardFailRate,
+      failRate: rates.failRate,
+      samples: rates.total
+    });
+  }
+  halfOpenHealth(baseKey) {
+    const h = this.getHealth(baseKey);
+    if (h.state !== "CLOSED") return;
+    h.state = "HALF_OPEN";
+    h.probeInFlight = false;
+    h.probeRemaining = 1;
+    this.emit("health:half_open", { baseUrl: baseKey });
+  }
+  openHealth(baseKey) {
+    const h = this.getHealth(baseKey);
+    h.state = "OPEN";
+    h.window = [];
+    h.consecutiveHardFails = 0;
+    h.probeInFlight = false;
+    h.probeRemaining = 0;
+    h.stableNonHard = 0;
+    this.emit("health:open", { baseUrl: baseKey });
+  }
+  recordOutcome(baseKey, outcome) {
+    const h = this.getHealth(baseKey);
+    h.window.push(outcome);
+    while (h.window.length > h.windowSize) h.window.shift();
+    if (outcome === "HARD_FAIL") h.consecutiveHardFails += 1;
+    else h.consecutiveHardFails = 0;
+    if (h.state === "OPEN") {
+      if (outcome !== "HARD_FAIL") {
+        h.stableNonHard += 1;
+        if (h.stableNonHard >= 5) {
+          h.cooldownMs = h.cooldownBaseMs;
+        }
+      } else {
+        h.stableNonHard = 0;
+      }
+    }
+    if (!this.healthEnabled) return;
+    if (h.consecutiveHardFails >= 3) {
+      this.closeHealth(baseKey, "3 consecutive hard failures");
+      return;
+    }
+    const rates = computeRates(h.window);
+    if (rates.total >= h.minSamples) {
+      if (rates.hardFailRate >= 0.3) {
+        this.closeHealth(baseKey, "hardFailRate >= 30%");
+        return;
+      }
+      if (rates.failRate >= 0.5) {
+        this.closeHealth(baseKey, "failRate >= 50%");
+        return;
+      }
+    }
+  }
+  async execute(req, opts) {
+    const baseKey = baseUrlKey(req.url);
+    const h = this.getHealth(baseKey);
+    const limiter = this.getLimiter(baseKey);
+    if (this.healthEnabled) {
+      if (h.state === "CLOSED") {
+        if (Date.now() >= h.cooldownUntil) {
+          this.halfOpenHealth(baseKey);
+        } else {
+          throw new UpstreamUnhealthyError(baseKey, "CLOSED");
+        }
+      }
+      if (h.state === "HALF_OPEN") {
+        if (!opts.allowProbe) throw new HalfOpenRejectedError(baseKey);
+        if (h.probeRemaining <= 0 || h.probeInFlight) throw new HalfOpenRejectedError(baseKey);
+        h.probeInFlight = true;
+        h.probeRemaining -= 1;
+      }
+    }
+    const requestId = genRequestId();
+    const start = Date.now();
+    try {
+      if (this.healthEnabled && h.state === "HALF_OPEN") {
+        await limiter.acquireNoQueue();
+      } else {
+        await limiter.acquire();
+      }
+    } catch (err) {
+      this.emit("request:rejected", { requestId, request: req, error: err });
+      throw err;
+    }
+    this.emit("request:start", { requestId, request: req });
+    try {
+      const res = await doHttpRequest(req, this.requestTimeoutMs);
+      const durationMs = Date.now() - start;
+      const outcome = classifyHttpStatus(res.status);
+      this.recordOutcome(baseKey, outcome);
+      if (this.healthEnabled && h.state === "HALF_OPEN") {
+        this.emit("health:probe", { baseUrl: baseKey, outcome, status: res.status });
+        if (res.status >= 200 && res.status < 300) {
+          this.openHealth(baseKey);
+        } else {
+          this.closeHealth(baseKey, `probe failed status=${res.status}`);
+        }
+      }
+      this.emit("request:success", { requestId, request: req, status: res.status, durationMs });
+      return res;
+    } catch (err) {
+      const durationMs = Date.now() - start;
+      if (shouldCountAsHardFail(err)) {
+        this.recordOutcome(baseKey, "HARD_FAIL");
+      }
+      if (this.healthEnabled && h.state === "HALF_OPEN") {
+        this.emit("health:probe", { baseUrl: baseKey, outcome: "HARD_FAIL", error: err });
+        this.closeHealth(baseKey, "probe hard failure");
+      }
+      this.emit("request:failure", { requestId, request: req, error: err, durationMs });
+      throw err;
+    } finally {
+      if (this.healthEnabled && h.state === "HALF_OPEN") {
+        h.probeInFlight = false;
+      }
+      limiter.release();
+    }
+  }
+  /* ---------------- microcache ---------------- */
   cloneResponse(res) {
-    return {
-      status: res.status,
-      headers: { ...res.headers },
-      body: new Uint8Array(res.body)
-    };
+    return { status: res.status, headers: { ...res.headers }, body: new Uint8Array(res.body) };
   }
   maybeCleanupExpired(cache, maxStaleMs) {
     this.microCacheReqCount++;
@@ -242,21 +464,15 @@ var ResilientHttpClient = class extends EventEmitter {
   async fetchWithLeaderRetry(req) {
     const mc = this.microCache;
     const retry = mc.retry;
-    if (!retry) return this.existingPipeline(req);
+    if (!retry) return this.execute(req, { allowProbe: false });
     const { maxAttempts, baseDelayMs, maxDelayMs, retryOnStatus } = retry;
     let last;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      const res = await this.existingPipeline(req);
+      const res = await this.execute(req, { allowProbe: false });
       last = res;
       if (this.isRetryableStatus(res.status, retryOnStatus) && attempt < maxAttempts) {
         const delay = this.computeBackoffMs(attempt, baseDelayMs, maxDelayMs);
-        this.emit("microcache:retry", {
-          url: req.url,
-          attempt,
-          maxAttempts,
-          reason: `status ${res.status}`,
-          delayMs: delay
-        });
+        this.emit("microcache:retry", { url: req.url, attempt, maxAttempts, reason: `status ${res.status}`, delayMs: delay });
         await sleep(delay);
         continue;
       }
@@ -264,16 +480,6 @@ var ResilientHttpClient = class extends EventEmitter {
     }
     return last;
   }
-  /**
-   * Window behavior:
-   * - 0..ttlMs: return cache (fresh)
-   * - ttlMs..maxStaleMs: leader refreshes; others get old value until replaced (stale-while-revalidate)
-   * - >maxStaleMs: do not serve old; behave like no cache
-   *
-   * Follower controls (only when no cache is served):
-   * - maxWaiters: cap concurrent followers joining the leader
-   * - followerTimeoutMs: shared "join window" from first follower; after it expires, late followers fail fast until leader completes
-   */
   async requestWithMicroCache(req) {
     const mc = this.microCache;
     const cache = this.cache;
@@ -282,20 +488,23 @@ var ResilientHttpClient = class extends EventEmitter {
     const key = mc.keyFn(req);
     const now = Date.now();
     const hit0 = cache.get(key);
-    if (hit0 && now - hit0.createdAt > mc.maxStaleMs) {
-      cache.delete(key);
-    }
+    if (hit0 && now - hit0.createdAt > mc.maxStaleMs) cache.delete(key);
     const hit = cache.get(key);
-    if (hit && now < hit.expiresAt) {
-      return this.cloneResponse(hit.value);
+    if (hit && now < hit.expiresAt) return this.cloneResponse(hit.value);
+    if (this.healthEnabled) {
+      const baseKey = baseUrlKey(req.url);
+      const h = this.getHealth(baseKey);
+      if (h.state === "CLOSED") {
+        const staleAllowed = !!hit && now - hit.createdAt <= mc.maxStaleMs;
+        if (staleAllowed) return this.cloneResponse(hit.value);
+        throw new UpstreamUnhealthyError(baseKey, "CLOSED");
+      }
     }
     const group = inFlight.get(key);
     if (group) {
       const h = cache.get(key);
       const staleAllowed = !!h && now - h.createdAt <= mc.maxStaleMs;
-      if (h && staleAllowed) {
-        return this.cloneResponse(h.value);
-      }
+      if (h && staleAllowed) return this.cloneResponse(h.value);
       const age = now - group.windowStartMs;
       if (age > mc.followerTimeoutMs) {
         const err = new Error(`Follower window closed for key=${key}`);
@@ -318,24 +527,18 @@ var ResilientHttpClient = class extends EventEmitter {
     const prev = cache.get(key);
     const prevStaleAllowed = !!prev && now - prev.createdAt <= mc.maxStaleMs;
     const promise = (async () => {
-      const res = await this.fetchWithLeaderRetry(req);
+      const baseKey = baseUrlKey(req.url);
+      const h = this.getHealth(baseKey);
+      const allowProbe = this.healthEnabled && h.state === "HALF_OPEN";
+      const res = allowProbe ? await this.execute(req, { allowProbe: true }) : await this.fetchWithLeaderRetry(req);
       if (res.status >= 200 && res.status < 300) {
         this.evictIfNeeded(cache, mc.maxEntries);
         const t = Date.now();
-        cache.set(key, {
-          value: this.cloneResponse(res),
-          createdAt: t,
-          expiresAt: t + mc.ttlMs
-        });
+        cache.set(key, { value: this.cloneResponse(res), createdAt: t, expiresAt: t + mc.ttlMs });
       }
       return res;
     })();
-    const newGroup = {
-      promise,
-      windowStartMs: Date.now(),
-      waiters: 0
-    };
-    inFlight.set(key, newGroup);
+    inFlight.set(key, { promise, windowStartMs: Date.now(), waiters: 0 });
     try {
       const res = await promise;
       if (!(res.status >= 200 && res.status < 300) && prev && prevStaleAllowed) {
@@ -352,40 +555,15 @@ var ResilientHttpClient = class extends EventEmitter {
       inFlight.delete(key);
     }
   }
-  async existingPipeline(req) {
-    const requestId = genRequestId();
-    try {
-      await this.limiter.acquire();
-    } catch (err) {
-      this.emit("request:rejected", { requestId, request: req, error: err });
-      throw err;
-    }
-    const start = Date.now();
-    this.emit("request:start", { requestId, request: req });
-    try {
-      const res = await doHttpRequest(req, this.requestTimeoutMs);
-      const durationMs = Date.now() - start;
-      this.emit("request:success", { requestId, request: req, status: res.status, durationMs });
-      return res;
-    } catch (err) {
-      const durationMs = Date.now() - start;
-      this.emit("request:failure", { requestId, request: req, error: err, durationMs });
-      throw err;
-    } finally {
-      this.limiter.release();
-    }
-  }
-  snapshot() {
-    const s = this.limiter.snapshot();
-    return { inFlight: s.inFlight, queueDepth: s.queueDepth };
-  }
 };
 export {
+  HalfOpenRejectedError,
   QueueFullError,
   QueueTimeoutError,
   RequestTimeoutError,
   ResilientHttpClient,
   ResilientHttpError,
-  UpstreamError
+  UpstreamError,
+  UpstreamUnhealthyError
 };
 //# sourceMappingURL=index.js.map