brass-runtime 1.14.0 → 1.15.0

package/dist/http/index.mjs

@@ -1,9 +1,15 @@
 import {
-  makeCircuitBreaker,
-  sleep,
   streamFromReadableStream
-} from "../chunk-UWMMYKVK.mjs";
+} from "../chunk-4NHES7VK.mjs";
+import {
+  makeCircuitBreaker,
+  sleep
+} from "../chunk-UMAZLXAB.mjs";
+import "../chunk-ELOOF35R.mjs";
 import {
+  Cause,
+  __require,
+  asyncEffect,
   asyncFail,
   asyncFlatMap,
   asyncFold,
@@ -13,7 +19,7 @@ import {
   resolveWasmModule,
   toPromise,
   withAsyncPromise
-} from "../chunk-4N2JEK4H.mjs";
+} from "../chunk-BDF4AMWX.mjs";
 
 // src/http/optics/lens.ts
 var Lens = {
@@ -42,6 +48,211 @@ var mergeHeaders = (extra) => (req) => Lens.over(Request.headers, (h) => ({ ...h
 var mergeHeadersUnder = (under) => (req) => Lens.over(Request.headers, (h) => ({ ...under, ...h }))(req);
 var setHeaderIfMissing = (k, v) => (req) => Lens.over(Request.headers, (h) => h[k] ? h : { ...h, [k]: v })(req);
 
+// src/http/retry/wasmRetryPlanner.ts
+var WasmRetryPlannerBridge = class {
+  planner;
+  constructor(Ctor) {
+    this.planner = new Ctor();
+  }
+  start(options) {
+    return this.planner.start(
+      options.nowMs,
+      options.maxRetries,
+      options.baseDelayMs,
+      options.maxDelayMs,
+      options.maxElapsedMs ?? -1,
+      BigInt(this.seed())
+    );
+  }
+  nextDelayMs(retryId, options) {
+    const delay = this.planner.next_delay_ms(retryId, options.nowMs, options.retryable, options.retryAfterMs ?? -1);
+    return delay < 0 ? void 0 : delay;
+  }
+  drop(retryId) {
+    this.planner.drop_state(retryId);
+  }
+  stats() {
+    return {
+      live: this.planner.metric_u64(0),
+      planned: this.planner.metric_u64(1),
+      exhausted: this.planner.metric_u64(2),
+      dropped: this.planner.metric_u64(3)
+    };
+  }
+  seed() {
+    return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+  }
+};
+function makeWasmRetryPlanner() {
+  const mod = resolveWasmModule();
+  const Ctor = mod?.BrassWasmRetryPlanner;
+  if (!Ctor) throw new Error("brass-runtime wasm retry planner is not available. Run npm run build:wasm first.");
+  return new WasmRetryPlannerBridge(Ctor);
+}
+
+// src/http/retry/retry.ts
+var defaultRetryableMethods = ["GET", "HEAD", "OPTIONS"];
+var defaultRetryOnStatus = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
+var defaultRetryOnError = (e) => e._tag === "FetchError" || e._tag === "Timeout" || e._tag === "PoolTimeout";
+var clamp = (n, min, max) => Math.max(min, Math.min(max, n));
+var backoffDelayMs = (attempt, base, cap) => {
+  const b = Math.max(0, base);
+  const c = Math.max(0, cap);
+  const exp = b * Math.pow(2, attempt);
+  const lim = clamp(exp, 0, c);
+  return Math.floor(Math.random() * lim);
+};
+var headerCI = (h, name) => {
+  const k = Object.keys(h).find((x) => x.toLowerCase() === name.toLowerCase());
+  return k ? h[k] : void 0;
+};
+var retryAfterMs = (headers) => {
+  const v = headerCI(headers, "retry-after")?.trim();
+  if (!v) return void 0;
+  const secs = Number(v);
+  if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
+  const t = Date.parse(v);
+  if (Number.isFinite(t)) return Math.max(0, t - Date.now());
+  return void 0;
+};
+var normalizeRetryBudget = (ms) => {
+  if (ms === void 0 || !Number.isFinite(ms)) return void 0;
+  return Math.max(0, Math.floor(ms));
+};
+var resolveEffectivePolicy = (req, basePolicy) => {
+  const override = req.retry;
+  if (override === false) return null;
+  if (override === void 0) return basePolicy;
+  return {
+    ...basePolicy,
+    ...override.maxRetries !== void 0 && { maxRetries: override.maxRetries },
+    ...override.baseDelayMs !== void 0 && { baseDelayMs: override.baseDelayMs },
+    ...override.maxDelayMs !== void 0 && { maxDelayMs: override.maxDelayMs },
+    ...override.retryOnStatus !== void 0 && { retryOnStatus: override.retryOnStatus }
+  };
+};
+var resolveRetryEngine = (p) => {
+  if (p.engine !== void 0) {
+    if (p.engine === "ts" || p.engine === "wasm") return p.engine;
+    throw new Error(`brass-runtime retry engine must be 'ts' or 'wasm'; received '${String(p.engine)}'`);
+  }
+  if (p.wasm === true) return "wasm";
+  if (p.wasm === false) return "ts";
+  return "ts";
+};
+var withRetry = (p) => (next) => {
+  const retryOnMethods = p.retryOnMethods ?? defaultRetryableMethods;
+  const retryEngine = resolveRetryEngine(p);
+  const wasmPlanner = retryEngine === "wasm" ? makeWasmRetryPlanner() : void 0;
+  const isMethodRetryable = (req) => retryOnMethods.includes(req.method);
+  const nextDelay = (ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable, retryAfter) => {
+    if (!retryable) return void 0;
+    if (wasmPlanner && retryId !== void 0) {
+      return wasmPlanner.nextDelayMs(retryId, {
+        nowMs: performance.now(),
+        retryable,
+        retryAfterMs: retryAfter
+      });
+    }
+    const remainingBudget = epMaxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : epMaxElapsedMs - (performance.now() - startedAt);
+    if (remainingBudget <= 0) return void 0;
+    const rawDelay = retryAfter === void 0 ? backoffDelayMs(attempt, ep.baseDelayMs, ep.maxDelayMs) : Math.min(retryAfter, ep.maxDelayMs);
+    return Math.max(0, Math.min(rawDelay, remainingBudget));
+  };
+  const sleepWithCleanup = (ms, onCancel) => {
+    return asyncEffect((_env, cb) => {
+      const delay = Math.max(0, Math.floor(ms));
+      const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), delay);
+      return () => {
+        clearTimeout(id);
+        onCancel();
+      };
+    });
+  };
+  const loop = (req, attempt, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop) => {
+    if (!isMethodRetryable(req)) return next(req);
+    const effectiveReq = attempt > 0 ? (() => {
+      const boostedReq = { ...req };
+      boostedReq.priority = Math.max(0, originalPriority - 1);
+      return boostedReq;
+    })() : req;
+    const remainingBudget = () => epMaxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : epMaxElapsedMs - (performance.now() - startedAt);
+    return asyncFold(
+      next(effectiveReq),
+      (e) => {
+        if (e._tag === "Abort" || e._tag === "BadUrl" || e._tag === "PoolRejected" || e._tag === "CircuitBreakerOpen") {
+          safeDrop(retryId);
+          return asyncFail(e);
+        }
+        const retryable = attempt < ep.maxRetries && epRetryOnError(e) && remainingBudget() > 0;
+        const d = nextDelay(ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable);
+        if (d === void 0 || d <= 0 && epMaxElapsedMs !== void 0) {
+          safeDrop(retryId);
+          return asyncFail(e);
+        }
+        if (ep.onRetry) {
+          ep.onRetry({
+            attempt,
+            delayMs: d,
+            error: e,
+            status: void 0,
+            url: req.url,
+            method: req.method,
+            timestamp: Date.now()
+          });
+        }
+        return asyncFlatMap(sleepWithCleanup(d, () => safeDrop(retryId)), () => loop(req, attempt + 1, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop));
+      },
+      (w) => {
+        const retryable = attempt < ep.maxRetries && epRetryOnStatus(w.status) && remainingBudget() > 0;
+        const ra = ep.respectRetryAfter === false ? void 0 : retryAfterMs(w.headers);
+        const d = nextDelay(ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable, ra);
+        if (d === void 0 || d <= 0 && epMaxElapsedMs !== void 0) {
+          safeDrop(retryId);
+          return asyncSucceed(w);
+        }
+        if (ep.onRetry) {
+          ep.onRetry({
+            attempt,
+            delayMs: d,
+            error: void 0,
+            status: w.status,
+            url: req.url,
+            method: req.method,
+            timestamp: Date.now()
+          });
+        }
+        return asyncFlatMap(sleepWithCleanup(d, () => safeDrop(retryId)), () => loop(req, attempt + 1, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop));
+      }
+    );
+  };
+  return (req) => {
+    const effectivePolicy = resolveEffectivePolicy(req, p);
+    if (effectivePolicy === null) return next(req);
+    if (!isMethodRetryable(req)) return next(req);
+    const epRetryOnStatus = effectivePolicy.retryOnStatus ?? defaultRetryOnStatus;
+    const epRetryOnError = effectivePolicy.retryOnError ?? defaultRetryOnError;
+    const epMaxElapsedMs = normalizeRetryBudget(effectivePolicy.maxElapsedMs);
+    const originalPriority = req.priority ?? 5;
+    const startedAt = performance.now();
+    const retryId = wasmPlanner?.start({
+      nowMs: startedAt,
+      maxRetries: effectivePolicy.maxRetries,
+      baseDelayMs: effectivePolicy.baseDelayMs,
+      maxDelayMs: effectivePolicy.maxDelayMs,
+      maxElapsedMs: epMaxElapsedMs
+    });
+    let plannerDropped = false;
+    const safeDrop = (id) => {
+      if (id !== void 0 && !plannerDropped) {
+        plannerDropped = true;
+        wasmPlanner?.drop(id);
+      }
+    };
+    return loop(req, 0, startedAt, retryId, effectivePolicy, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop);
+  };
+};
+
 // src/http/wasmPermitPool.ts
 var DECISION_RUN_NOW = 0;
 var DECISION_QUEUED = 1;
@@ -528,6 +739,30 @@ var timeoutReason = (req, url, timeoutMs) => ({
   phase: "request",
   message: `HTTP ${req.method} ${url.origin} timed out after ${timeoutMs}ms`
 });
+var linkAbortSignals = (runtimeSignal, requestSignal) => {
+  if (!requestSignal) return { signal: runtimeSignal, cleanup: () => void 0 };
+  const controller = new AbortController();
+  const abort = (source) => {
+    try {
+      controller.abort(source.reason);
+    } catch {
+      controller.abort();
+    }
+  };
+  const abortFromRuntime = () => abort(runtimeSignal);
+  const abortFromRequest = () => abort(requestSignal);
+  if (runtimeSignal.aborted) abortFromRuntime();
+  else runtimeSignal.addEventListener("abort", abortFromRuntime, { once: true });
+  if (requestSignal.aborted) abortFromRequest();
+  else requestSignal.addEventListener("abort", abortFromRequest, { once: true });
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      runtimeSignal.removeEventListener("abort", abortFromRuntime);
+      requestSignal.removeEventListener("abort", abortFromRequest);
+    }
+  };
+};
 function makeHttpStream(cfg = {}) {
   const baseUrl = cfg.baseUrl ?? "";
   const defaultHeaders = cfg.headers ?? {};
@@ -542,10 +777,12 @@ function makeHttpStream(cfg = {}) {
     return fromPromiseAbortable(
       async (signal) => {
         let lease;
+        const linkedSignal = linkAbortSignals(signal, req.init?.signal);
+        let cleanupTransferredToBody = false;
         try {
           if (pool) {
             const key = resolveHttpPoolKey(pool.keyResolver, req, url);
-            lease = await pool.acquire(key, signal);
+            lease = await pool.acquire(key, linkedSignal.signal);
           }
           const started = performance.now();
           const res = await fetch(url, {
@@ -553,10 +790,14 @@ function makeHttpStream(cfg = {}) {
             method: req.method,
             headers: Request.headers.get(req),
             body: req.body,
-            signal
+            signal: linkedSignal.signal
           });
           const headers = headersOf(res);
-          const body = streamFromReadableStream(res.body, normalizeHttpError);
+          const body = streamFromReadableStream(res.body, normalizeHttpError, {
+            signal: linkedSignal.signal,
+            onRelease: linkedSignal.cleanup
+          });
+          cleanupTransferredToBody = res.body !== null;
           lease?.release();
           lease = void 0;
           return {
@@ -567,6 +808,9 @@ function makeHttpStream(cfg = {}) {
             ms: Math.round(performance.now() - started)
           };
         } finally {
+          if (!cleanupTransferredToBody) {
+            linkedSignal.cleanup();
+          }
           lease?.release();
         }
       },
@@ -596,10 +840,11 @@ function makeHttp(cfg = {}) {
     return fromPromiseAbortable(
       async (signal) => {
         let lease;
+        const linkedSignal = linkAbortSignals(signal, req.init?.signal);
         try {
           if (pool) {
             const key = resolveHttpPoolKey(pool.keyResolver, req, url);
-            lease = await pool.acquire(key, signal);
+            lease = await pool.acquire(key, linkedSignal.signal);
           }
           const started = performance.now();
           const res = await fetch(url, {
@@ -607,7 +852,7 @@ function makeHttp(cfg = {}) {
             method: req.method,
             headers: Request.headers.get(req),
             body: req.body,
-            signal
+            signal: linkedSignal.signal
           });
           const bodyText = await res.text();
           const headers = headersOf(res);
@@ -619,6 +864,7 @@ function makeHttp(cfg = {}) {
             ms: Math.round(performance.now() - started)
           };
         } finally {
+          linkedSignal.cleanup();
           lease?.release();
         }
       },
@@ -634,30 +880,13 @@ function makeHttp(cfg = {}) {
   };
   return decorate(run, metrics.snapshot);
 }
-var clamp = (n, min, max) => Math.max(min, Math.min(max, n));
-var defaultRetryOnError = (e) => e._tag === "FetchError" || e._tag === "Timeout" || e._tag === "PoolTimeout";
-var defaultRetryOnStatus = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
-var backoffDelayMs = (attempt, base, cap) => {
-  const exp = base * Math.pow(2, attempt);
-  const lim = clamp(exp, 0, cap);
-  return Math.floor(Math.random() * lim);
-};
-var retryAfterMs = (headers) => {
-  const key = Object.keys(headers).find((k) => k.toLowerCase() === "retry-after");
-  if (!key) return void 0;
-  const v = headers[key]?.trim();
-  if (!v) return void 0;
-  const secs = Number(v);
-  if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
-  const t = Date.parse(v);
-  if (Number.isFinite(t)) return Math.max(0, t - Date.now());
-  return void 0;
-};
 var withRetryStream = (p) => (next) => {
   const retryOnStatus = p.retryOnStatus ?? defaultRetryOnStatus;
   const retryOnError = p.retryOnError ?? defaultRetryOnError;
-  const maxElapsedMs = p.maxElapsedMs !== void 0 && Number.isFinite(p.maxElapsedMs) ? Math.max(0, Math.floor(p.maxElapsedMs)) : void 0;
+  const retryOnMethods = p.retryOnMethods ?? defaultRetryableMethods;
+  const maxElapsedMs = normalizeRetryBudget(p.maxElapsedMs);
   const run = (req) => {
+    if (!retryOnMethods.includes(req.method)) return next(req);
     const startedAt = performance.now();
     const remainingBudget = () => maxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : maxElapsedMs - (performance.now() - startedAt);
     const delayWithinBudget = (delayMs) => Math.max(0, Math.min(delayMs, remainingBudget()));
@@ -669,6 +898,15 @@ var withRetryStream = (p) => (next) => {
         if (!canRetry) return asyncFail(e);
         const d = delayWithinBudget(backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs));
         if (d <= 0 && maxElapsedMs !== void 0) return asyncFail(e);
+        p.onRetry?.({
+          attempt,
+          delayMs: d,
+          error: e,
+          status: void 0,
+          url: req.url,
+          method: req.method,
+          timestamp: Date.now()
+        });
         return asyncFlatMap(sleep(d), () => loop(attempt + 1));
       },
       (w) => {
@@ -678,6 +916,15 @@ var withRetryStream = (p) => (next) => {
         const rawDelay = ra === void 0 ? backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs) : Math.min(ra, p.maxDelayMs);
         const d = delayWithinBudget(rawDelay);
         if (d <= 0 && maxElapsedMs !== void 0) return asyncSucceed(w);
+        p.onRetry?.({
+          attempt,
+          delayMs: d,
+          error: void 0,
+          status: w.status,
+          url: req.url,
+          method: req.method,
+          timestamp: Date.now()
+        });
         return asyncFlatMap(sleep(d), () => loop(attempt + 1));
       }
     );
@@ -686,205 +933,56 @@ var withRetryStream = (p) => (next) => {
   return decorateStream(run, next.stats);
 };
 
-// src/http/retry/wasmRetryPlanner.ts
-var WasmRetryPlannerBridge = class {
-  planner;
-  constructor(Ctor) {
-    this.planner = new Ctor();
-  }
-  start(options) {
-    return this.planner.start(
-      options.nowMs,
-      options.maxRetries,
-      options.baseDelayMs,
-      options.maxDelayMs,
-      options.maxElapsedMs ?? -1,
-      BigInt(this.seed())
-    );
-  }
-  nextDelayMs(retryId, options) {
-    const delay = this.planner.next_delay_ms(retryId, options.nowMs, options.retryable, options.retryAfterMs ?? -1);
-    return delay < 0 ? void 0 : delay;
-  }
-  drop(retryId) {
-    this.planner.drop_state(retryId);
+// src/http/httpClient.ts
+var resolveFinalUrl = (baseUrl, url) => {
+  try {
+    return new URL(url, baseUrl ?? "").toString();
+  } catch {
+    return (baseUrl ?? "") + url;
   }
-  stats() {
+};
+var createHttpCore = (cfg = {}) => {
+  const wire = makeHttp(cfg);
+  const withPromise = (eff) => withAsyncPromise((e, env) => toPromise(e, env))(eff);
+  const requestRaw = (req) => wire(req);
+  const splitInit = (init) => {
+    const { headers, timeoutMs, poolKey, ...rest } = init ?? {};
     return {
-      live: this.planner.metric_u64(0),
-      planned: this.planner.metric_u64(1),
-      exhausted: this.planner.metric_u64(2),
-      dropped: this.planner.metric_u64(3)
+      headers: normalizeHeadersInit(headers),
+      timeoutMs: typeof timeoutMs === "number" ? timeoutMs : void 0,
+      poolKey: typeof poolKey === "string" ? poolKey : void 0,
+      init: rest
     };
-  }
-  seed() {
-    return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
-  }
-};
-function makeWasmRetryPlanner() {
-  const mod = resolveWasmModule();
-  const Ctor = mod?.BrassWasmRetryPlanner;
-  if (!Ctor) throw new Error("brass-runtime wasm retry planner is not available. Run npm run build:wasm first.");
-  return new WasmRetryPlannerBridge(Ctor);
-}
-
-// src/http/retry/retry.ts
-var defaultRetryableMethods = ["GET", "HEAD", "OPTIONS"];
-var defaultRetryOnStatus2 = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
-var defaultRetryOnError2 = (e) => e._tag === "FetchError" || e._tag === "Timeout" || e._tag === "PoolTimeout";
-var clamp2 = (n, min, max) => Math.max(min, Math.min(max, n));
-var backoffDelayMs2 = (attempt, base, cap) => {
-  const b = Math.max(0, base);
-  const c = Math.max(0, cap);
-  const exp = b * Math.pow(2, attempt);
-  const lim = clamp2(exp, 0, c);
-  return Math.floor(Math.random() * lim);
-};
-var headerCI = (h, name) => {
-  const k = Object.keys(h).find((x) => x.toLowerCase() === name.toLowerCase());
-  return k ? h[k] : void 0;
-};
-var retryAfterMs2 = (headers) => {
-  const v = headerCI(headers, "retry-after")?.trim();
-  if (!v) return void 0;
-  const secs = Number(v);
-  if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
-  const t = Date.parse(v);
-  if (Number.isFinite(t)) return Math.max(0, t - Date.now());
-  return void 0;
-};
-var normalizeBudget = (ms) => {
-  if (ms === void 0 || !Number.isFinite(ms)) return void 0;
-  return Math.max(0, Math.floor(ms));
-};
-var resolveRetryEngine = (p) => {
-  if (p.engine !== void 0) {
-    if (p.engine === "ts" || p.engine === "wasm") return p.engine;
-    throw new Error(`brass-runtime retry engine must be 'ts' or 'wasm'; received '${String(p.engine)}'`);
-  }
-  if (p.wasm === true) return "wasm";
-  if (p.wasm === false) return "ts";
-  return "ts";
-};
-var withRetry = (p) => (next) => {
-  const retryOnMethods = p.retryOnMethods ?? defaultRetryableMethods;
-  const retryOnStatus = p.retryOnStatus ?? defaultRetryOnStatus2;
-  const retryOnError = p.retryOnError ?? defaultRetryOnError2;
-  const maxElapsedMs = normalizeBudget(p.maxElapsedMs);
-  const retryEngine = resolveRetryEngine(p);
-  const wasmPlanner = retryEngine === "wasm" ? makeWasmRetryPlanner() : void 0;
-  const isMethodRetryable = (req) => retryOnMethods.includes(req.method);
-  const nextDelay = (retryId, attempt, startedAt, retryable, retryAfter) => {
-    if (!retryable) return void 0;
-    if (wasmPlanner && retryId !== void 0) {
-      return wasmPlanner.nextDelayMs(retryId, {
-        nowMs: performance.now(),
-        retryable,
-        retryAfterMs: retryAfter
-      });
-    }
-    const remainingBudget = maxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : maxElapsedMs - (performance.now() - startedAt);
-    if (remainingBudget <= 0) return void 0;
-    const rawDelay = retryAfter === void 0 ? backoffDelayMs2(attempt, p.baseDelayMs, p.maxDelayMs) : Math.min(retryAfter, p.maxDelayMs);
-    return Math.max(0, Math.min(rawDelay, remainingBudget));
-  };
-  const dropPlanner = (retryId) => {
-    if (retryId !== void 0) wasmPlanner?.drop(retryId);
-  };
-  const loop = (req, attempt, startedAt, retryId) => {
-    if (!isMethodRetryable(req)) return next(req);
-    const remainingBudget = () => maxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : maxElapsedMs - (performance.now() - startedAt);
-    return asyncFold(
-      next(req),
-      (e) => {
-        if (e._tag === "Abort" || e._tag === "BadUrl" || e._tag === "PoolRejected") {
-          dropPlanner(retryId);
-          return asyncFail(e);
-        }
-        const retryable = attempt < p.maxRetries && retryOnError(e) && remainingBudget() > 0;
-        const d = nextDelay(retryId, attempt, startedAt, retryable);
-        if (d === void 0 || d <= 0 && maxElapsedMs !== void 0) {
-          dropPlanner(retryId);
-          return asyncFail(e);
-        }
-        return asyncFlatMap(sleep(d), () => loop(req, attempt + 1, startedAt, retryId));
-      },
-      (w) => {
-        const retryable = attempt < p.maxRetries && retryOnStatus(w.status) && remainingBudget() > 0;
-        const ra = p.respectRetryAfter === false ? void 0 : retryAfterMs2(w.headers);
-        const d = nextDelay(retryId, attempt, startedAt, retryable, ra);
-        if (d === void 0 || d <= 0 && maxElapsedMs !== void 0) {
-          dropPlanner(retryId);
-          return asyncSucceed(w);
-        }
-        return asyncFlatMap(sleep(d), () => loop(req, attempt + 1, startedAt, retryId));
-      }
-    );
-  };
-  return (req) => {
-    if (!isMethodRetryable(req)) return next(req);
-    const startedAt = performance.now();
-    const retryId = wasmPlanner?.start({
-      nowMs: startedAt,
-      maxRetries: p.maxRetries,
-      baseDelayMs: p.baseDelayMs,
-      maxDelayMs: p.maxDelayMs,
-      maxElapsedMs
-    });
-    return loop(req, 0, startedAt, retryId);
-  };
-};
-
-// src/http/httpClient.ts
-var resolveFinalUrl = (baseUrl, url) => {
-  try {
-    return new URL(url, baseUrl ?? "").toString();
-  } catch {
-    return (baseUrl ?? "") + url;
-  }
-};
-var createHttpCore = (cfg = {}) => {
-  const wire = makeHttp(cfg);
-  const withPromise = (eff) => withAsyncPromise((e, env) => toPromise(e, env))(eff);
-  const requestRaw = (req) => wire(req);
-  const splitInit = (init) => {
-    const { headers, timeoutMs, poolKey, ...rest } = init ?? {};
-    return {
-      headers: normalizeHeadersInit(headers),
-      timeoutMs: typeof timeoutMs === "number" ? timeoutMs : void 0,
-      poolKey: typeof poolKey === "string" ? poolKey : void 0,
-      init: rest
-    };
-  };
-  const applyInitHeaders = (headers) => (req) => headers ? mergeHeaders(headers)(req) : req;
-  const buildReq = (method, url, init, body) => {
-    const s = splitInit(init);
-    const req = {
-      method,
-      url,
-      ...body && body.length > 0 ? { body } : {},
-      ...s.timeoutMs !== void 0 ? { timeoutMs: s.timeoutMs } : {},
-      ...s.poolKey !== void 0 ? { poolKey: s.poolKey } : {},
-      init: s.init
-    };
-    return applyInitHeaders(s.headers)(req);
-  };
-  const toResponse = (w, body) => ({
-    status: w.status,
-    statusText: w.statusText,
-    headers: w.headers,
-    body
-  });
-  return {
-    cfg,
-    wire,
-    withPromise,
-    requestRaw,
-    splitInit,
-    applyInitHeaders,
-    buildReq,
-    toResponse
-  };
+  };
+  const applyInitHeaders = (headers) => (req) => headers ? mergeHeaders(headers)(req) : req;
+  const buildReq = (method, url, init, body) => {
+    const s = splitInit(init);
+    const req = {
+      method,
+      url,
+      ...body && body.length > 0 ? { body } : {},
+      ...s.timeoutMs !== void 0 ? { timeoutMs: s.timeoutMs } : {},
+      ...s.poolKey !== void 0 ? { poolKey: s.poolKey } : {},
+      init: s.init
+    };
+    return applyInitHeaders(s.headers)(req);
+  };
+  const toResponse = (w, body) => ({
+    status: w.status,
+    statusText: w.statusText,
+    headers: w.headers,
+    body
+  });
+  return {
+    cfg,
+    wire,
+    withPromise,
+    requestRaw,
+    splitInit,
+    applyInitHeaders,
+    buildReq,
+    toResponse
+  };
 };
 function httpClient(cfg = {}) {
   const core = createHttpCore(cfg);
@@ -1026,6 +1124,92 @@ function httpClientStream(cfg = {}) {
   return make(wire);
 }
 
+// src/http/effectRunner.ts
+function registerHttpEffect(effect, env, cb) {
+  let done = false;
+  let currentCancel;
+  const finish = (exit) => {
+    if (done) return;
+    done = true;
+    currentCancel = void 0;
+    cb(exit);
+  };
+  const run = (current, cont) => {
+    if (done) return;
+    switch (current._tag) {
+      case "Succeed":
+        cont({ _tag: "Success", value: current.value });
+        return;
+      case "Fail":
+        cont({ _tag: "Failure", cause: Cause.fail(current.error) });
+        return;
+      case "Sync":
+        try {
+          cont({ _tag: "Success", value: current.thunk(env) });
+        } catch (e) {
+          cont({ _tag: "Failure", cause: Cause.die(e) });
+        }
+        return;
+      case "Async": {
+        const cancel = current.register(env, (exit) => {
+          currentCancel = void 0;
+          if (done) return;
+          cont(exit);
+        });
+        currentCancel = typeof cancel === "function" ? cancel : void 0;
+        return;
+      }
+      case "FlatMap":
+        run(current.first, (exit) => {
+          if (done) return;
+          if (exit._tag === "Failure") {
+            cont(exit);
+            return;
+          }
+          try {
+            run(current.andThen(exit.value), cont);
+          } catch (e) {
+            cont({ _tag: "Failure", cause: Cause.die(e) });
+          }
+        });
+        return;
+      case "Fold":
+        run(current.first, (exit) => {
+          if (done) return;
+          try {
+            if (exit._tag === "Success") {
+              run(current.onSuccess(exit.value), cont);
+              return;
+            }
+            if (exit.cause._tag === "Fail") {
+              run(current.onFailure(exit.cause.error), cont);
+              return;
+            }
+            cont(exit);
+          } catch (e) {
+            cont({ _tag: "Failure", cause: Cause.die(e) });
+          }
+        });
+        return;
+      case "Fork":
+        cont({ _tag: "Success", value: void 0 });
+        return;
+    }
+  };
+  run(effect, finish);
+  return () => {
+    if (done) return;
+    const cancel = currentCancel;
+    currentCancel = void 0;
+    done = true;
+    try {
+      cancel?.();
+    } finally {
+      cb({ _tag: "Failure", cause: Cause.interrupt() });
+    }
+  };
+}
+
 // src/http/circuitBreaker.ts
 function withCircuitBreaker(config = {}) {
   if (config.perOrigin) {
@@ -1046,7 +1230,7 @@ function withCircuitBreaker(config = {}) {
     };
     return (next) => (req) => {
       const breaker2 = getBreaker(req.url);
-      return breaker2.protect(next(req));
+      return protectLazy(breaker2, next, req);
     };
   }
   const breaker = makeCircuitBreaker({
@@ -1057,7 +1241,31 @@ function withCircuitBreaker(config = {}) {
     })
   });
   return (next) => (req) => {
-    return breaker.protect(next(req));
+    return protectLazy(breaker, next, req);
+  };
+}
+function protectLazy(breaker, next, req) {
+  return {
+    _tag: "Async",
+    register: (env, cb) => {
+      let cancel;
+      try {
+        const deferred = {
+          _tag: "Async",
+          register: (innerEnv, innerCb) => registerHttpEffect(next(req), innerEnv, innerCb)
+        };
+        cancel = registerHttpEffect(breaker.protect(deferred), env, cb);
+      } catch (error) {
+        cb({
+          _tag: "Failure",
+          cause: {
+            _tag: "Fail",
+            error: { _tag: "FetchError", message: String(error) }
+          }
+        });
+      }
+      return () => cancel?.();
+    }
   };
 }
 
@@ -1103,19 +1311,2133 @@ function validatedJson(client, validator) {
     }
   );
 }
+
+// src/http/body.ts
+function httpBodyByteLength(body) {
+  if (body === void 0) return 0;
+  if (typeof body === "string") return Buffer.byteLength(body, "utf8");
+  if (body instanceof ArrayBuffer) return body.byteLength;
+  return body.byteLength;
+}
+function httpBodyToBuffer(body) {
+  if (typeof body === "string") return Buffer.from(body, "utf8");
+  if (body instanceof ArrayBuffer) return Buffer.from(body);
+  return Buffer.from(body);
+}
+function httpBodyKeyPart(body) {
+  if (body === void 0) return "";
+  if (typeof body === "string") return body;
+  return `base64:${httpBodyToBuffer(body).toString("base64")}`;
+}
+
+// src/http/lifecycle/cacheKey.ts
+var SEPARATOR = "\0";
+var DEFAULT_CACHE_RELEVANT_HEADERS = ["accept", "authorization", "content-type"];
+function computeCacheKey(req, baseUrl, extraHeaders = []) {
+  const method = req.method.toUpperCase();
+  const resolvedUrl = new URL(req.url, baseUrl || void 0).toString();
+  const relevantSet = /* @__PURE__ */ new Set([
+    ...DEFAULT_CACHE_RELEVANT_HEADERS,
+    ...extraHeaders.map((h) => h.toLowerCase())
+  ]);
+  const headers = req.headers ?? {};
+  const sortedHeaders = Object.keys(headers).filter((k) => relevantSet.has(k.toLowerCase())).sort().map((k) => `${k.toLowerCase()}:${headers[k]}`).join(",");
+  const body = httpBodyKeyPart(req.body);
+  return `${method}${SEPARATOR}${resolvedUrl}${SEPARATOR}${sortedHeaders}${SEPARATOR}${body}`;
+}
+function parseCacheKey(key) {
+  const [method, resolvedUrl, headersStr, ...bodyParts] = key.split(SEPARATOR);
+  const body = bodyParts.join(SEPARATOR);
+  const headers = {};
+  if (headersStr) {
+    for (const entry of headersStr.split(",")) {
+      const colonIdx = entry.indexOf(":");
+      if (colonIdx > 0) {
+        headers[entry.slice(0, colonIdx)] = entry.slice(colonIdx + 1);
+      }
+    }
+  }
+  return { method, resolvedUrl, headers, body };
+}
+
+// src/http/lifecycle/dedupKey.ts
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+function computeDedupKey(req, baseUrl) {
+  const method = req.method.toUpperCase();
+  const resolvedUrl = new URL(req.url, baseUrl || void 0).toString();
+  const headers = req.headers ?? {};
+  const sortedHeaders = Object.keys(headers).filter((k) => {
+    const lower = k.toLowerCase();
+    return !HOP_BY_HOP.has(lower) && lower !== "authorization";
+  }).sort().map((k) => `${k.toLowerCase()}:${headers[k]}`).join(",");
+  const body = httpBodyKeyPart(req.body);
+  return `${method}${SEPARATOR}${resolvedUrl}${SEPARATOR}${sortedHeaders}${SEPARATOR}${body}`;
+}
+
+// src/http/lifecycle/dedup.ts
+function safeEmit(onEvent, event) {
+  if (!onEvent) return;
+  try {
+    onEvent(event);
+  } catch {
+  }
+}
+function withDedup(config) {
+  const inFlight = /* @__PURE__ */ new Map();
+  const customKeyFn = config?.dedupKey;
+  const onEvent = config?.onEvent;
+  return (next) => {
+    return (req) => {
+      if (!SAFE_METHODS.has(req.method.toUpperCase())) {
+        return next(req);
+      }
+      let key;
+      if (customKeyFn) {
+        try {
+          key = customKeyFn(req);
+        } catch {
+          return next(req);
+        }
+        if (!key) {
+          return next(req);
+        }
+      } else {
+        key = computeDedupKey(req, "");
+      }
+      return {
+        _tag: "Async",
+        register: (_env, cb) => {
+          const existing = inFlight.get(key);
+          let callerDone = false;
+          const finishCaller = (exit) => {
+            if (callerDone) return;
+            callerDone = true;
+            cb(exit);
+          };
+          if (existing) {
+            safeEmit(onEvent, { type: "dedup-hit", cacheKey: key });
+            existing.refCount++;
+            const waiter = {
+              resolve: (res) => {
+                finishCaller({ _tag: "Success", value: res });
+              },
+              reject: (err) => {
+                finishCaller({ _tag: "Failure", cause: Cause.fail(err) });
+              }
+            };
+            existing.waiters.push(waiter);
+            return () => {
+              if (callerDone) return;
+              existing.refCount--;
+              const idx = existing.waiters.indexOf(waiter);
+              if (idx >= 0) {
+                existing.waiters.splice(idx, 1);
+              }
+              if (existing.refCount <= 0) {
+                inFlight.delete(key);
+                safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
+                existing.controller.abort();
+              }
+              finishCaller({ _tag: "Failure", cause: Cause.interrupt() });
+            };
+          }
+          safeEmit(onEvent, { type: "dedup-miss", cacheKey: key });
+          const controller = new AbortController();
+          const entry = {
+            key,
+            controller,
+            refCount: 1,
+            waiters: []
+          };
+          inFlight.set(key, entry);
+          safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
+          const dedupReq = {
+            ...req,
+            init: {
+              ...req.init ?? {},
+              signal: controller.signal
+            }
+          };
+          const innerEffect = next(dedupReq);
+          const innerCancel = registerHttpEffect(innerEffect, _env, (exit) => {
+            inFlight.delete(key);
+            safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
+            if (exit._tag === "Success") {
+              resolveAll(entry, exit.value);
+              finishCaller(exit);
+              return;
+            }
+            if (exit.cause._tag === "Interrupt") {
+              rejectAll(entry, { _tag: "Abort" });
+              finishCaller({ _tag: "Failure", cause: Cause.interrupt() });
+              return;
+            }
+            if (exit.cause._tag === "Fail") {
+              rejectAll(entry, exit.cause.error);
+              finishCaller(exit);
+              return;
+            }
+            const err = { _tag: "FetchError", message: String(exit.cause.defect ?? "unknown") };
+            rejectAll(entry, err);
+            finishCaller({ _tag: "Failure", cause: Cause.fail(err) });
+          });
+          return () => {
+            if (callerDone) return;
+            entry.refCount--;
+            if (entry.refCount <= 0) {
+              inFlight.delete(key);
+              safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
+              controller.abort();
+              if (innerCancel) {
+                innerCancel();
+              }
+            }
+            finishCaller({ _tag: "Failure", cause: Cause.interrupt() });
+          };
+        }
+      };
+    };
+  };
+}
+function resolveAll(entry, res) {
+  const waiters = entry.waiters.slice();
+  for (const w of waiters) {
+    w.resolve(res);
+  }
+}
+function rejectAll(entry, err) {
+  const waiters = entry.waiters.slice();
+  for (const w of waiters) {
+    w.reject(err);
+  }
+}
+
+// src/http/lifecycle/timing.ts
+var now = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
+
+// src/http/lifecycle/lruCache.ts
+function isExpired(node) {
+  return now() - node.storedAt >= node.ttlMs;
+}
+var LRUCache = class {
+  map = /* @__PURE__ */ new Map();
+  head = null;
+  tail = null;
+  maxEntries;
+  onEvict;
+  /**
+   * Creates a new LRU cache instance.
+   *
+   * @param config - Cache configuration options.
+   * @param config.maxEntries - Maximum number of entries. Must be >= 1. Default: 1024.
+   * @param config.onEvict - Optional eviction callback.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<number>({ maxEntries: 50 });
+   * ```
+   */
+  constructor(config = {}) {
+    const max = config.maxEntries ?? 1024;
+    this.maxEntries = Math.max(1, Math.floor(max));
+    this.onEvict = config.onEvict;
+  }
+  /**
+   * Returns the number of entries currently in the cache.
+   *
+   * @returns The current entry count.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<string>();
+   * cache.set("a", "1", 10_000);
+   * console.log(cache.size); // 1
+   * ```
+   */
+  get size() {
+    return this.map.size;
+  }
+  /**
+   * Retrieves a value by key.
+   *
+   * Returns `undefined` if the key is not found or the entry has expired.
+   * On a hit (non-expired), the entry is moved to the head (most recently used).
+   * Expired entries are lazily removed on access.
+   *
+   * @param key - The cache key to look up.
+   * @returns The cached value, or `undefined` if not found or expired.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<string>();
+   * cache.set("greeting", "hello", 30_000);
+   * const val = cache.get("greeting"); // "hello"
+   * const miss = cache.get("unknown"); // undefined
+   * ```
+   */
+  get(key) {
+    const node = this.map.get(key);
+    if (!node) return void 0;
+    if (isExpired(node)) {
+      this.removeNode(node);
+      this.map.delete(key);
+      return void 0;
+    }
+    this.moveToHead(node);
+    return node.value;
+  }
+  /**
+   * Inserts or updates an entry in the cache.
+   *
+   * If the key already exists, the value and TTL are updated and the entry is
+   * moved to the head. If inserting a new entry causes the cache to exceed
+   * `maxEntries` (must be >= 1), the least recently used entry is evicted.
+   *
+   * @param key - The cache key.
+   * @param value - The value to store.
+   * @param ttlMs - Time-to-live in milliseconds. The entry expires after this duration.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<string>({ maxEntries: 2 });
+   * cache.set("a", "alpha", 60_000);
+   * cache.set("b", "beta", 60_000);
+   * cache.set("c", "gamma", 60_000); // evicts "a" (LRU)
+   * ```
+   */
+  set(key, value, ttlMs) {
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      existing.storedAt = now();
+      existing.ttlMs = ttlMs;
+      this.moveToHead(existing);
+      return;
+    }
+    const node = {
+      key,
+      value,
+      storedAt: now(),
+      ttlMs,
+      prev: null,
+      next: null
+    };
+    this.map.set(key, node);
+    this.addToHead(node);
+    if (this.map.size > this.maxEntries) {
+      this.evictTail();
+    }
+  }
+  /**
+   * Removes an entry by key.
+   *
+   * @param key - The cache key to remove.
+   * @returns `true` if the entry was found and removed, `false` otherwise.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<string>();
+   * cache.set("x", "value", 10_000);
+   * cache.delete("x"); // true
+   * cache.delete("x"); // false (already removed)
+   * ```
+   */
+  delete(key) {
+    const node = this.map.get(key);
+    if (!node) return false;
+    this.removeNode(node);
+    this.map.delete(key);
+    return true;
+  }
+  /**
+   * Removes all entries from the cache, resetting it to an empty state.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<string>();
+   * cache.set("a", "1", 10_000);
+   * cache.clear();
+   * console.log(cache.size); // 0
+   * ```
+   */
+  clear() {
+    this.map.clear();
+    this.head = null;
+    this.tail = null;
+  }
+  // --- Doubly-linked list operations ---
+  /** Adds a node to the head of the list (most recently used position). */
+  addToHead(node) {
+    node.prev = null;
+    node.next = this.head;
+    if (this.head) {
+      this.head.prev = node;
+    }
+    this.head = node;
+    if (!this.tail) {
+      this.tail = node;
+    }
+  }
+  /** Removes a node from its current position in the list. */
+  removeNode(node) {
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.tail = node.prev;
+    }
+    node.prev = null;
+    node.next = null;
+  }
+  /** Moves an existing node to the head of the list. */
+  moveToHead(node) {
+    if (this.head === node) return;
+    this.removeNode(node);
+    this.addToHead(node);
+  }
+  /** Evicts the tail node (least recently used) and notifies via callback. */
+  evictTail() {
+    if (!this.tail) return;
+    const evicted = this.tail;
+    this.removeNode(evicted);
+    this.map.delete(evicted.key);
+    if (this.onEvict) {
+      this.onEvict(1);
+    }
+  }
+};
+
+// src/http/lifecycle/responseCache.ts
+function clamp2(n, min, max) {
+  return Math.max(min, Math.min(max, n));
+}
+function safeEmit2(onEvent, event) {
+  if (!onEvent) return;
+  try {
+    onEvent(event);
+  } catch {
+  }
+}
+function withCache(config) {
+  const ttlSeconds = clamp2(config?.ttlSeconds ?? 60, 1, 86400);
+  const ttlMs = ttlSeconds * 1e3;
+  const maxEntries = Math.max(1, Math.floor(config?.maxEntries ?? 1024));
+  const staleWhileRevalidate = config?.staleWhileRevalidate ?? false;
+  const cachePolicy = config?.cachePolicy;
+  const cacheRelevantHeaders = config?.cacheRelevantHeaders ?? [];
+  const baseUrl = config?.baseUrl ?? "";
+  const onEvent = config?.onEvent;
+  const onLifecycleEvent = config?.onLifecycleEvent;
+  const cache = new LRUCache({
+    maxEntries,
+    onEvict: (count) => onLifecycleEvent?.({ type: "cache-eviction", count })
+  });
+  const revalidating = /* @__PURE__ */ new Set();
+  const invalidate = (key) => {
+    cache.delete(key);
+  };
+  const clear = () => {
+    cache.clear();
+  };
+  const middleware = (next) => {
+    return (req) => {
+      const method = req.method.toUpperCase();
+      if (!SAFE_METHODS.has(method) && !cachePolicy) {
+        return next(req);
+      }
+      const key = computeCacheKey(req, baseUrl, cacheRelevantHeaders);
+      return {
+        _tag: "Async",
+        register: (env, cb) => {
+          const cached = cache.get(key);
+          if (cached !== void 0) {
+            onLifecycleEvent?.({ type: "cache-hit", cacheKey: key });
+            cb({ _tag: "Success", value: cached });
+            return;
+          }
+          onLifecycleEvent?.({ type: "cache-miss", cacheKey: key });
+          const innerEffect = next(req);
+          return registerHttpEffect(innerEffect, env, (exit) => {
+            if (exit._tag === "Success") {
+              storeIfCacheable(req, exit.value, key);
+            }
+            cb(exit);
+          });
+        }
+      };
+    };
+  };
+  function storeIfCacheable(req, res, key) {
+    const method = req.method.toUpperCase();
+    if (cachePolicy) {
+      const result = cachePolicy(req, res);
+      if (!result.cacheable) return;
+      const entryTtlMs = result.ttlSeconds !== void 0 ? clamp2(result.ttlSeconds, 1, 86400) * 1e3 : ttlMs;
+      cache.set(key, res, entryTtlMs);
+      return;
+    }
+    if (!SAFE_METHODS.has(method)) return;
+    cache.set(key, res, ttlMs);
+  }
+  function triggerRevalidation(next, req, key) {
+    if (revalidating.has(key)) return;
+    revalidating.add(key);
+    const innerEffect = next(req);
+    const handleExit = (exit) => {
+      revalidating.delete(key);
+      if (exit._tag === "Success") {
+        storeIfCacheable(req, exit.value, key);
+      } else {
+        safeEmit2(onEvent, {
+          type: "revalidation-failure",
+          cacheKey: key,
+          error: exit.cause._tag === "Fail" ? exit.cause.error : void 0
+        });
+      }
+    };
+    registerHttpEffect(innerEffect, void 0, handleExit);
+  }
+  const expirationMap = /* @__PURE__ */ new Map();
+  const swrMiddleware = (next) => {
+    return (req) => {
+      const method = req.method.toUpperCase();
+      if (!SAFE_METHODS.has(method) && !cachePolicy) {
+        return next(req);
+      }
+      const key = computeCacheKey(req, baseUrl, cacheRelevantHeaders);
+      return {
+        _tag: "Async",
+        register: (env, cb) => {
+          const cached = cache.get(key);
+          if (cached !== void 0) {
+            const expiresAt = expirationMap.get(key);
+            if (expiresAt !== void 0 && now() < expiresAt) {
+              onLifecycleEvent?.({ type: "cache-hit", cacheKey: key });
+              cb({ _tag: "Success", value: cached });
+              return;
+            }
+            onLifecycleEvent?.({ type: "cache-hit", cacheKey: key });
+            cb({ _tag: "Success", value: cached });
+            triggerRevalidation(next, req, key);
+            return;
+          }
+          onLifecycleEvent?.({ type: "cache-miss", cacheKey: key });
+          const innerEffect = next(req);
+          const handleSuccess = (res) => {
+            swrStoreIfCacheable(req, res, key);
+          };
+          return registerHttpEffect(innerEffect, env, (exit) => {
+            if (exit._tag === "Success") {
+              handleSuccess(exit.value);
+            }
+            cb(exit);
+          });
+        }
+      };
+    };
+  };
+  function swrStoreIfCacheable(req, res, key) {
+    const method = req.method.toUpperCase();
+    let entryTtlMs = ttlMs;
+    if (cachePolicy) {
+      const result = cachePolicy(req, res);
+      if (!result.cacheable) return;
+      entryTtlMs = result.ttlSeconds !== void 0 ? clamp2(result.ttlSeconds, 1, 86400) * 1e3 : ttlMs;
+    } else if (!SAFE_METHODS.has(method)) {
+      return;
+    }
+    const lruTtl = Number.MAX_SAFE_INTEGER;
+    cache.set(key, res, lruTtl);
+    expirationMap.set(key, now() + entryTtlMs);
+  }
+  const swrInvalidate = (key) => {
+    cache.delete(key);
+    expirationMap.delete(key);
+  };
+  const swrClear = () => {
+    cache.clear();
+    expirationMap.clear();
+  };
+  if (staleWhileRevalidate) {
+    return {
+      middleware: swrMiddleware,
+      invalidate: swrInvalidate,
+      clear: swrClear
+    };
+  }
+  return {
+    middleware,
+    invalidate,
+    clear
+  };
+}
+
+// src/http/lifecycle/priorityQueue.ts
+function clampPriority(value) {
+  if (value === void 0 || !Number.isFinite(value)) return 5;
+  return Math.max(0, Math.min(9, Math.trunc(value)));
+}
+function comparePriority(a, b) {
+  if (a.priority !== b.priority) return a.priority - b.priority;
+  return a.arrivalOrder - b.arrivalOrder;
+}
+var PriorityQueue = class {
+  heap = [];
+  counter = 0;
+  /**
+   * Returns the number of entries in the queue (including cancelled entries).
+   *
+   * @returns The total number of entries in the internal heap.
+   *
+   * @example
+   * ```typescript
+   * import { PriorityQueue } from "./priorityQueue";
+   *
+   * const queue = new PriorityQueue<string>();
+   * queue.enqueue("task", 5);
+   * console.log(queue.size); // 1
+   * ```
+   */
+  get size() {
+    return this.heap.length;
+  }
+  /** Returns the number of entries that have not been cancelled. */
+  get activeSize() {
+    return this.heap.reduce((n, entry) => n + (entry.cancelled ? 0 : 1), 0);
+  }
+  /**
+   * Adds a value to the queue with the given priority.
+   *
+   * Priority is clamped to the valid range [0, 9] via `clampPriority`.
+   * Returns the created entry, which can be used for later cancellation
+   * by setting `entry.cancelled = true`.
+   *
+   * @param value - The value to enqueue.
+   * @param priority - Priority level, integer from 0 (highest) to 9 (lowest).
+   *   Clamped to [0, 9]. Defaults to 5 if undefined.
+   * @returns The created queue entry.
+   *
+   * @example
+   * ```typescript
+   * import { PriorityQueue } from "./priorityQueue";
+   *
+   * const queue = new PriorityQueue<string>();
+   * const entry = queue.enqueue("urgent-task", 0);
+   * entry.cancelled = true; // cancel later if needed
+   * ```
+   */
+  enqueue(value, priority) {
+    const entry = {
+      priority: clampPriority(priority),
+      arrivalOrder: this.counter++,
+      value,
+      cancelled: false
+    };
+    this.heap.push(entry);
+    this.bubbleUp(this.heap.length - 1);
+    return entry;
+  }
+  /**
+   * Removes and returns the highest-priority non-cancelled entry.
+   *
+   * Skips (and discards) any cancelled entries at the top of the heap.
+   * Returns `undefined` if the queue is empty or all entries are cancelled.
+   *
+   * @returns The highest-priority non-cancelled entry, or `undefined` if none available.
+   *
+   * @example
+   * ```typescript
+   * import { PriorityQueue } from "./priorityQueue";
+   *
+   * const queue = new PriorityQueue<string>();
+   * queue.enqueue("first", 1);
+   * queue.enqueue("second", 2);
+   * const entry = queue.dequeue(); // { value: "first", priority: 1, ... }
+   * ```
+   */
+  dequeue() {
+    while (this.heap.length > 0) {
+      const top = this.heap[0];
+      if (top.cancelled) {
+        this.removeTop();
+        continue;
+      }
+      this.removeTop();
+      return top;
+    }
+    return void 0;
+  }
+  /**
+   * Returns the highest-priority non-cancelled entry without removing it.
+   *
+   * Discards cancelled entries at the top of the heap as a side effect.
+   * Returns `undefined` if the queue is empty or all entries are cancelled.
+   *
+   * @returns The highest-priority non-cancelled entry, or `undefined` if none available.
+   *
+   * @example
+   * ```typescript
+   * import { PriorityQueue } from "./priorityQueue";
+   *
+   * const queue = new PriorityQueue<string>();
+   * queue.enqueue("task", 3);
+   * const top = queue.peek(); // { value: "task", priority: 3, ... }
+   * console.log(queue.size);  // 1 (not removed)
+   * ```
+   */
+  peek() {
+    while (this.heap.length > 0) {
+      const top = this.heap[0];
+      if (top.cancelled) {
+        this.removeTop();
+        continue;
+      }
+      return top;
+    }
+    return void 0;
+  }
+  /**
+   * Marks all entries matching the predicate as cancelled (lazy removal).
+   *
+   * Cancelled entries are skipped on subsequent dequeue/peek calls.
+   * This does not immediately remove entries from the heap; they are
+   * discarded lazily when encountered at the top during dequeue or peek.
+   *
+   * @param predicate - A function that returns `true` for entries to cancel.
+   * @returns The number of entries marked as cancelled.
+   *
+   * @example
+   * ```typescript
+   * import { PriorityQueue } from "./priorityQueue";
+   *
+   * const queue = new PriorityQueue<string>();
+   * queue.enqueue("a", 1);
+   * queue.enqueue("b", 2);
+   * const removed = queue.remove((e) => e.value === "a"); // 1
+   * ```
+   */
+  remove(predicate) {
+    let count = 0;
+    for (const entry of this.heap) {
+      if (!entry.cancelled && predicate(entry)) {
+        entry.cancelled = true;
+        count++;
+      }
+    }
+    return count;
+  }
+  // --- Binary heap operations ---
+  /** Removes the top element from the heap and restores heap property. */
+  removeTop() {
+    const last = this.heap.pop();
+    if (this.heap.length > 0 && last !== void 0) {
+      this.heap[0] = last;
+      this.sinkDown(0);
+    }
+  }
+  /** Moves an element up the heap until the heap property is restored. */
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = index - 1 >>> 1;
+      const current = this.heap[index];
+      const parent = this.heap[parentIndex];
+      if (comparePriority(current, parent) >= 0) break;
+      this.heap[index] = parent;
+      this.heap[parentIndex] = current;
+      index = parentIndex;
+    }
+  }
+  /** Moves an element down the heap until the heap property is restored. */
+  sinkDown(index) {
+    const length = this.heap.length;
+    while (true) {
+      const leftIndex = 2 * index + 1;
+      const rightIndex = 2 * index + 2;
+      let smallest = index;
+      if (leftIndex < length && comparePriority(this.heap[leftIndex], this.heap[smallest]) < 0) {
+        smallest = leftIndex;
+      }
+      if (rightIndex < length && comparePriority(this.heap[rightIndex], this.heap[smallest]) < 0) {
+        smallest = rightIndex;
+      }
+      if (smallest === index) break;
+      const temp = this.heap[index];
+      this.heap[index] = this.heap[smallest];
+      this.heap[smallest] = temp;
+      index = smallest;
+    }
+  }
+};
+
+// src/http/lifecycle/priorityScheduler.ts
+var DEFAULT_CONCURRENCY2 = 32;
+function extractPriority(req) {
+  const fromReq = req.priority;
+  if (fromReq !== void 0) return clampPriority(fromReq);
+  const fromInit = req.init?.priority;
+  if (fromInit !== void 0) return clampPriority(fromInit);
+  return 5;
+}
+function safeEmit3(onEvent, event) {
+  if (!onEvent) return;
+  try {
+    onEvent(event);
+  } catch {
+  }
+}
+function withPriority(config) {
+  const concurrency = resolveConcurrency(config?.concurrency);
+  const queueTimeoutMs = resolveQueueTimeout(config?.queueTimeoutMs);
+  const onEvent = config?.onEvent;
+  const queue = new PriorityQueue();
+  let inFlight = 0;
+  const queueDepth = () => {
+    return queue.activeSize;
+  };
+  const middleware = (next) => {
+    return (req) => {
+      const priority = extractPriority(req);
+      return {
+        _tag: "Async",
+        register: (env, cb) => {
+          if (inFlight < concurrency) {
+            return dispatchRequest(next, req, env, cb);
+          }
+          const queued = { req, env, cb, signal: getSignal(req) };
+          const entry = queue.enqueue(queued, priority);
+          safeEmit3(onEvent, { type: "queue-enqueue", priority });
+          if (queueTimeoutMs !== void 0) {
+            queued.timer = setTimeout(() => {
+              entry.cancelled = true;
+              queued.timer = void 0;
+              cb({
+                _tag: "Failure",
+                cause: Cause.fail({
+                  _tag: "PoolTimeout",
+                  key: "priority",
+                  timeoutMs: queueTimeoutMs,
+                  message: `Priority queue did not dispatch within ${queueTimeoutMs}ms`
+                })
+              });
+            }, queueTimeoutMs);
+          }
+          const signal = queued.signal;
+          let abortHandler;
+          if (signal && !signal.aborted) {
+            abortHandler = () => {
+              entry.cancelled = true;
+              if (queued.timer !== void 0) {
+                clearTimeout(queued.timer);
+                queued.timer = void 0;
+              }
+              cb({ _tag: "Failure", cause: Cause.fail({ _tag: "Abort" }) });
+            };
+            signal.addEventListener("abort", abortHandler, { once: true });
+          } else if (signal?.aborted) {
+            entry.cancelled = true;
+            cb({ _tag: "Failure", cause: Cause.fail({ _tag: "Abort" }) });
+            return;
+          }
+          return () => {
+            entry.cancelled = true;
+            if (queued.timer !== void 0) {
+              clearTimeout(queued.timer);
+              queued.timer = void 0;
+            }
+            if (abortHandler && signal) {
+              signal.removeEventListener("abort", abortHandler);
+            }
+            cb({ _tag: "Failure", cause: Cause.interrupt() });
+          };
+        }
+      };
+    };
+    function dispatchRequest(downstream, req, env, cb) {
+      inFlight++;
+      safeEmit3(onEvent, { type: "queue-dispatch", priority: extractPriority(req) });
+      const innerEffect = downstream(req);
+      let completed = false;
+      const onComplete = (exit) => {
+        if (completed) return;
+        completed = true;
+        inFlight--;
+        cb(exit);
+        drainNext(downstream);
+      };
+      const innerCancel = registerHttpEffect(innerEffect, env, onComplete);
+      return () => {
+        innerCancel();
+      };
+    }
+    function drainNext(downstream) {
+      while (inFlight < concurrency) {
+        const entry = queue.dequeue();
+        if (!entry) break;
+        if (entry.cancelled) continue;
+        const queued = entry.value;
+        if (queued.timer !== void 0) {
+          clearTimeout(queued.timer);
+          queued.timer = void 0;
+        }
+        if (queued.signal?.aborted) {
+          queued.cb({ _tag: "Failure", cause: Cause.fail({ _tag: "Abort" }) });
+          continue;
+        }
+        dispatchRequest(downstream, queued.req, queued.env, queued.cb);
+      }
+    }
+  };
+  return Object.assign(middleware, { queueDepth });
+}
+function resolveConcurrency(value) {
+  if (value === void 0 || !Number.isFinite(value)) return DEFAULT_CONCURRENCY2;
+  return Math.max(1, Math.floor(value));
+}
+function resolveQueueTimeout(value) {
+  if (value === void 0 || !Number.isFinite(value)) return void 0;
+  const n = Math.floor(value);
+  return n > 0 ? n : void 0;
+}
+function getSignal(req) {
+  return req.init?.signal;
+}
+
+// src/http/lifecycle/stats.ts
+var LifecycleStatsTracker = class {
+  _cacheHits = 0;
+  _cacheMisses = 0;
+  _cacheEvictions = 0;
+  _dedupHits = 0;
+  _dedupActive = 0;
+  _queueDepth = 0;
+  _requestsStarted = 0;
+  _requestsCompleted = 0;
+  _requestsFailed = 0;
+  _retries = 0;
+  _onEvent;
+  _wireStats;
+  /**
+   * Creates a new lifecycle stats tracker.
+   *
+   * @param opts - Configuration options for the tracker.
+   * @param opts.onEvent - Optional callback invoked on each lifecycle event.
+   *   Errors thrown by this callback are silently discarded.
+   * @param opts.wireStats - A function returning the current wire-level HTTP client stats.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({
+   *   wireStats: () => ({ requestCount: 0, errorCount: 0 }),
+   * });
+   * ```
+   */
+  constructor(opts) {
+    this._onEvent = opts.onEvent;
+    this._wireStats = opts.wireStats;
+  }
+  // --- Increment methods ---
+  /**
+   * Records a cache hit. Increments the cache hit counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.cacheHit();
+   * ```
+   */
+  cacheHit() {
+    this._cacheHits++;
+  }
+  /**
+   * Records a cache miss. Increments the cache miss counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.cacheMiss();
+   * ```
+   */
+  cacheMiss() {
+    this._cacheMisses++;
+  }
+  /**
+   * Records a cache eviction. Increments the cache eviction counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.cacheEviction();
+   * ```
+   */
+  cacheEviction() {
+    this._cacheEvictions++;
+  }
+  /**
+   * Records a dedup hit (a request that joined an in-flight duplicate).
+   * Increments the dedup hit counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.dedupHit();
+   * ```
+   */
+  dedupHit() {
+    this._dedupHits++;
+  }
+  /**
+   * Sets the current number of active dedup groups.
+   *
+   * @param n - The current count of active dedup groups. Must be >= 0.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.setDedupActive(3);
+   * ```
+   */
+  setDedupActive(n) {
+    this._dedupActive = n;
+  }
+  /**
+   * Sets the current priority queue depth.
+   *
+   * @param n - The current number of entries in the priority queue. Must be >= 0.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.setQueueDepth(5);
+   * ```
+   */
+  setQueueDepth(n) {
+    this._queueDepth = n;
+  }
+  /**
+   * Records that a request has started. Increments the requests started counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.requestStarted();
+   * ```
+   */
+  requestStarted() {
+    this._requestsStarted++;
+  }
+  /**
+   * Records that a request has completed successfully.
+   * Increments the requests completed counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.requestCompleted();
+   * ```
+   */
+  requestCompleted() {
+    this._requestsCompleted++;
+  }
+  /**
+   * Records that a request has failed.
+   * Increments the requests failed counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.requestFailed();
+   * ```
+   */
+  requestFailed() {
+    this._requestsFailed++;
+  }
+  retry() {
+    this._retries++;
+  }
+  // --- Event emission ---
+  /**
+   * Emits a lifecycle event to the registered `onEvent` callback.
+   *
+   * The callback is wrapped in a try-catch so that any exception thrown by
+   * the callback is silently discarded and request processing continues
+   * unaffected. If no `onEvent` callback was provided, this is a no-op.
+   *
+   * @param type - The lifecycle event type to emit (e.g., `"cache-hit"`, `"request-start"`).
+   * @param extra - Optional additional event data.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({
+   *   onEvent: (event) => console.log(event.type, event.timestamp),
+   *   wireStats: () => ({ requestCount: 0, errorCount: 0 }),
+   * });
+   * tracker.emit("cache-hit", { cacheKey: "GET|/api/users" });
+   * ```
+   */
+  emit(type, extra) {
+    if (!this._onEvent) return;
+    try {
+      const event = {
+        type,
+        timestamp: now(),
+        ...extra
+      };
+      this._onEvent(event);
+    } catch {
+    }
+  }
+  // --- Snapshot ---
+  /**
+   * Returns a frozen snapshot of all lifecycle statistics including wire stats.
+   *
+   * The returned object is frozen (immutable) and represents a point-in-time
+   * view of all counters and gauges.
+   *
+   * @returns A frozen `LifecycleStats` object containing all current statistics.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({
+   *   wireStats: () => ({ requestCount: 10, errorCount: 1 }),
+   * });
+   * tracker.cacheHit();
+   * tracker.cacheHit();
+   * const stats = tracker.snapshot();
+   * console.log(stats.cacheHits); // 2
+   * ```
+   */
+  snapshot() {
+    return Object.freeze({
+      cacheHits: this._cacheHits,
+      cacheMisses: this._cacheMisses,
+      cacheEvictions: this._cacheEvictions,
+      dedupHits: this._dedupHits,
+      dedupActive: this._dedupActive,
+      queueDepth: this._queueDepth,
+      requestsStarted: this._requestsStarted,
+      requestsCompleted: this._requestsCompleted,
+      requestsFailed: this._requestsFailed,
+      retries: this._retries,
+      wire: this._wireStats()
+    });
+  }
+};
+
+// src/http/lifecycle/lifecycleClient.ts
+function validateGlobals() {
+  if (typeof fetch === "undefined") {
+    throw new Error(
+      "makeLifecycleClient: global `fetch` is not available. Ensure you are running in an environment with fetch support (Node.js 18+ or modern browser)."
+    );
+  }
+  if (typeof AbortController === "undefined") {
+    throw new Error(
+      "makeLifecycleClient: global `AbortController` is not available. Ensure you are running in an environment with AbortController support (Node.js 15+ or modern browser)."
+    );
+  }
+}
+function extractWireConfig(config) {
+  const { dedup, cache, priority, retry, onEvent, ...wireConfig } = config;
+  return wireConfig;
+}
+function makeLifecycleClient(config = {}) {
+  validateGlobals();
+  const wireConfig = extractWireConfig(config);
+  const wireClient = makeHttp(wireConfig);
+  const activeControllers = /* @__PURE__ */ new Set();
+  const tracker = new LifecycleStatsTracker({
+    onEvent: config.onEvent,
+    wireStats: wireClient.stats
+  });
+  const hasDedup = config.dedup !== void 0 && config.dedup !== false;
+  const hasCache = config.cache !== void 0 && config.cache !== false;
+  const hasPriority = config.priority !== void 0 && config.priority !== false;
+  const hasRetry = config.retry !== void 0 && config.retry !== false;
+  if (!hasDedup && !hasCache && !hasPriority && !hasRetry) {
+    return buildLifecycleClient(wireClient, tracker, {
+      cacheInvalidate: noopInvalidate,
+      cacheClear: noopClear,
+      cancelAll: () => cancelControllers(activeControllers),
+      activeControllers
+    });
+  }
+  let priorityMiddleware;
+  if (hasPriority) {
+    const priorityConfig = config.priority;
+    priorityMiddleware = withPriority({
+      ...priorityConfig,
+      onEvent: (event) => {
+        tracker.setQueueDepth(priorityMiddleware?.queueDepth() ?? 0);
+        tracker.emit(event.type, { priority: event.priority });
+      }
+    });
+  }
+  let cacheLayer;
+  if (hasCache) {
+    const cacheConfig = config.cache;
+    cacheLayer = withCache({
+      ...cacheConfig,
+      baseUrl: wireConfig.baseUrl,
+      onLifecycleEvent: (event) => {
+        if (event.type === "cache-hit") tracker.cacheHit();
+        if (event.type === "cache-miss") tracker.cacheMiss();
+        if (event.type === "cache-eviction") tracker.cacheEviction();
+        if (event.type === "cache-hit" || event.type === "cache-miss") {
+          tracker.emit(event.type, { cacheKey: event.cacheKey });
+        }
+      }
+    });
+  }
+  let dedupMiddleware;
+  if (hasDedup) {
+    const dedupConfig = config.dedup;
+    const baseUrl = wireConfig.baseUrl ?? "";
+    const effectiveDedupConfig = dedupConfig.dedupKey || !baseUrl ? dedupConfig : { ...dedupConfig, dedupKey: (req) => computeDedupKey(req, baseUrl) };
+    dedupMiddleware = withDedup({
+      ...effectiveDedupConfig,
+      onEvent: (event) => {
+        if (event.type === "dedup-hit") tracker.dedupHit();
+        if (event.type === "dedup-active") {
+          tracker.setDedupActive(event.active ?? 0);
+          return;
+        }
+        tracker.emit(event.type, { cacheKey: event.cacheKey });
+      }
+    });
+  }
+  let composedFn = wireClient;
+  if (priorityMiddleware) {
+    composedFn = priorityMiddleware(composedFn);
+  }
+  if (hasRetry) {
+    const retryConfig = config.retry;
+    composedFn = withRetry({
+      ...retryConfig,
+      onRetry: (event) => {
+        tracker.retry();
+        tracker.emit("retry", {
+          attempt: event.attempt,
+          delayMs: event.delayMs,
+          status: event.status,
+          errorTag: event.error?._tag
+        });
+        retryConfig.onRetry?.(event);
+      }
+    })(composedFn);
+  }
+  if (cacheLayer) {
+    composedFn = cacheLayer.middleware(composedFn);
+  }
+  if (dedupMiddleware) {
+    composedFn = dedupMiddleware(composedFn);
+  }
+  return buildLifecycleClient(composedFn, tracker, {
+    cacheInvalidate: cacheLayer?.invalidate ?? noopInvalidate,
+    cacheClear: cacheLayer?.clear ?? noopClear,
+    cancelAll: () => cancelControllers(activeControllers),
+    activeControllers,
+    queueDepth: priorityMiddleware?.queueDepth
+  });
+}
+function makeHttpClient(config = {}) {
+  return makeLifecycleClient(config);
+}
+function noopInvalidate(_key) {
+}
+function noopClear() {
+}
+function buildLifecycleClient(fn, tracker, internals) {
+  const client = (req) => trackRequest(fn, req, tracker, internals);
+  const stats = () => {
+    tracker.setQueueDepth(internals.queueDepth?.() ?? 0);
+    return tracker.snapshot();
+  };
+  const withMw = (mw) => {
+    const wrappedFn = mw(fn);
+    return buildLifecycleClient(wrappedFn, tracker, internals);
+  };
+  const lifecycleClient = Object.assign(client, {
+    with: withMw,
+    stats,
+    cancelAll: internals.cancelAll,
+    cache: {
+      invalidate: internals.cacheInvalidate,
+      clear: internals.cacheClear
+    }
+  });
+  return lifecycleClient;
+}
+function cancelControllers(activeControllers) {
+  for (const controller of Array.from(activeControllers)) {
+    try {
+      controller.abort();
+    } catch {
+    }
+  }
+  return asyncSucceed(void 0);
+}
+function trackRequest(fn, req, tracker, internals) {
+  return {
+    _tag: "Async",
+    register: (env, cb) => {
+      const controller = new AbortController();
+      const previousSignal = req.init?.signal;
+      let done = false;
+      let abortedByPreviousSignal = false;
+      let cancelInner;
+      const abortFromPrevious = () => {
+        abortedByPreviousSignal = true;
+        try {
+          controller.abort(previousSignal?.reason);
+        } catch {
+          controller.abort();
+        }
+        cancelInner?.();
+      };
+      if (previousSignal?.aborted) {
+        abortFromPrevious();
+      } else {
+        previousSignal?.addEventListener("abort", abortFromPrevious, { once: true });
+      }
+      internals.activeControllers.add(controller);
+      tracker.requestStarted();
+      tracker.emit("request-start");
+      const finish = (exit0) => {
+        if (done) return;
+        done = true;
+        const exit = abortedByPreviousSignal && exit0._tag === "Failure" && exit0.cause._tag === "Interrupt" ? { _tag: "Failure", cause: Cause.fail({ _tag: "Abort" }) } : exit0;
+        previousSignal?.removeEventListener("abort", abortFromPrevious);
+        internals.activeControllers.delete(controller);
+        if (exit._tag === "Success") {
+          tracker.requestCompleted();
+        } else {
+          tracker.requestFailed();
+        }
+        tracker.emit("request-end");
+        cb(exit);
+      };
+      const trackedReq = {
+        ...req,
+        init: {
+          ...req.init ?? {},
+          signal: controller.signal
+        }
+      };
+      try {
+        cancelInner = registerHttpEffect(fn(trackedReq), env, finish);
+      } catch (error) {
+        finish({
+          _tag: "Failure",
+          cause: Cause.fail({ _tag: "FetchError", message: String(error) })
+        });
+      }
+      return () => {
+        if (done) return;
+        try {
+          controller.abort();
+        } catch {
+        }
+        if (cancelInner) {
+          cancelInner();
+        } else {
+          finish({ _tag: "Failure", cause: Cause.interrupt() });
+        }
+      };
+    }
+  };
+}
+
+// src/http/lifecycle/middleware.ts
+function withAuth(tokenProvider) {
+  return (next) => {
+    return (req) => {
+      return asyncFlatMap(tokenProvider(), (token) => {
+        const modifiedReq = {
+          ...req,
+          headers: {
+            ...req.headers ?? {},
+            Authorization: `Bearer ${token}`
+          }
+        };
+        return next(modifiedReq);
+      });
+    };
+  };
+}
+function withLogging(logger) {
+  return (next) => {
+    return (req) => {
+      try {
+        logger({ phase: "request", req });
+      } catch {
+      }
+      const startedAt = now();
+      return asyncFold(
+        next(req),
+        (error) => {
+          const durationMs = Math.round(now() - startedAt);
+          try {
+            logger({ phase: "error", req, error, durationMs });
+          } catch {
+          }
+          return asyncFail(error);
+        },
+        (res) => {
+          const durationMs = Math.round(now() - startedAt);
+          try {
+            logger({ phase: "response", req, res, durationMs });
+          } catch {
+          }
+          return asyncSucceed(res);
+        }
+      );
+    };
+  };
+}
+function withResponseTransform(fn) {
+  return (next) => {
+    return (req) => {
+      return asyncFold(
+        next(req),
+        (error) => {
+          return asyncFail(error);
+        },
+        (res) => {
+          try {
+            const transformed = fn(res, req);
+            return asyncSucceed(transformed);
+          } catch (e) {
+            return asyncFail({ _tag: "FetchError", message: String(e) });
+          }
+        }
+      );
+    };
+  };
+}
+
+// src/http/compression/decompressor.ts
+import zlib from "zlib";
+
+// src/http/compression/environment.ts
+function isNodeEnvironment() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+
+// src/http/compression/decompressorNode.ts
+function createNodeDecompressor(zlib2) {
+  return {
+    isPassthrough: false,
+    decompress(data, encoding) {
+      try {
+        const input = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        let result;
+        switch (encoding) {
+          case "gzip":
+            result = zlib2.gunzipSync(input);
+            break;
+          case "br":
+            result = zlib2.brotliDecompressSync(input);
+            break;
+          case "deflate":
+            result = zlib2.inflateSync(input);
+            break;
+          default:
+            return { ok: false, error: `Unsupported encoding: ${encoding}` };
+        }
+        return { ok: true, data: result };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: message };
+      }
+    }
+  };
+}
+
+// src/http/compression/decompressor.noop.ts
+function createNoopDecompressor() {
+  return {
+    isPassthrough: true,
+    decompress(data, _encoding) {
+      const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      return { ok: true, data: buf };
+    }
+  };
+}
+
+// src/http/compression/decompressor.ts
+function createDecompressor() {
+  if (isNodeEnvironment()) {
+    return createNodeDecompressor(zlib);
+  }
+  return createNoopDecompressor();
+}
+
+// src/http/compression/types.ts
+var SUPPORTED_ENCODINGS = ["br", "gzip", "deflate"];
+function emptyStats2() {
+  return {
+    decompressed: { gzip: 0, br: 0, deflate: 0 },
+    compressedBytes: 0,
+    decompressedBytes: 0,
+    passthroughCount: 0,
+    errorCount: 0,
+    unsupportedEncodingCount: 0
+  };
+}
+function emptyRequestCompressionStats() {
+  return {
+    compressedCount: 0,
+    skippedCount: 0,
+    errorCount: 0,
+    originalBytes: 0,
+    compressedBytes: 0
+  };
+}
+
+// src/http/compression/middleware.ts
+function injectAcceptEncoding(req, encodings) {
+  const headers = req.headers ?? {};
+  const hasAcceptEncoding = Object.keys(headers).some(
+    (k) => k.toLowerCase() === "accept-encoding"
+  );
+  if (hasAcceptEncoding) return req;
+  return {
+    ...req,
+    headers: {
+      ...headers,
+      "Accept-Encoding": encodings.join(", ")
+    }
+  };
+}
+function isSupportedEncoding(enc) {
+  return SUPPORTED_ENCODINGS.includes(enc);
+}
+function processResponse(res, decompressor, enabledEncodings, stats) {
+  const contentEncodingKey = Object.keys(res.headers).find(
+    (k) => k.toLowerCase() === "content-encoding"
+  );
+  const contentEncodingValue = contentEncodingKey ? res.headers[contentEncodingKey]?.trim() : void 0;
+  if (!contentEncodingValue || contentEncodingValue.toLowerCase() === "identity") {
+    stats.passthroughCount++;
+    return res;
+  }
+  const encodings = contentEncodingValue.split(",").map((e) => e.trim().toLowerCase());
+  const reversedEncodings = [...encodings].reverse();
+  let currentData = Buffer.from(res.bodyText, "latin1");
+  const originalData = currentData;
+  let decompressedCount = 0;
+  for (let i = 0; i < reversedEncodings.length; i++) {
+    const enc = reversedEncodings[i];
+    if (!isSupportedEncoding(enc)) {
+      stats.unsupportedEncodingCount++;
+      if (decompressedCount === 0) {
+        stats.passthroughCount++;
+        return res;
+      }
+      const remainingEncodings = reversedEncodings.slice(i).reverse();
+      const newHeaders2 = { ...res.headers };
+      if (contentEncodingKey) {
+        newHeaders2[contentEncodingKey] = remainingEncodings.join(", ");
+      }
+      newHeaders2["Content-Length"] = String(currentData.byteLength);
+      return {
+        ...res,
+        headers: newHeaders2,
+        bodyText: currentData.toString("latin1")
+      };
+    }
+    if (!enabledEncodings.includes(enc)) {
+      stats.passthroughCount++;
+      if (decompressedCount === 0) {
+        return res;
+      }
+      const remainingEncodings = reversedEncodings.slice(i).reverse();
+      const newHeaders2 = { ...res.headers };
+      if (contentEncodingKey) {
+        newHeaders2[contentEncodingKey] = remainingEncodings.join(", ");
+      }
+      newHeaders2["Content-Length"] = String(currentData.byteLength);
+      return {
+        ...res,
+        headers: newHeaders2,
+        bodyText: currentData.toString("latin1")
+      };
+    }
+    const result = decompressor.decompress(currentData, enc);
+    if (!result.ok) {
+      stats.errorCount++;
+      return res;
+    }
+    stats.compressedBytes += currentData.byteLength;
+    stats.decompressedBytes += result.data.byteLength;
+    stats.decompressed[enc]++;
+    decompressedCount++;
+    currentData = result.data;
+  }
+  const newHeaders = { ...res.headers };
+  if (contentEncodingKey) {
+    delete newHeaders[contentEncodingKey];
+  }
+  const lowerKey = Object.keys(newHeaders).find(
+    (k) => k.toLowerCase() === "content-encoding"
+  );
+  if (lowerKey) {
+    delete newHeaders[lowerKey];
+  }
+  newHeaders["Content-Length"] = String(currentData.byteLength);
+  return {
+    ...res,
+    headers: newHeaders,
+    bodyText: currentData.toString("utf-8")
+  };
+}
+function makeCompressionMiddleware(config) {
+  const enabledEncodings = config?.encodings ?? [...SUPPORTED_ENCODINGS];
+  const decompressor = createDecompressor();
+  const mutableStats = emptyStats2();
+  const middleware = (next) => {
+    return (req) => {
+      const modifiedReq = injectAcceptEncoding(req, enabledEncodings);
+      return asyncFold(
+        next(modifiedReq),
+        // Pass HttpErrors through unchanged
+        (error) => asyncFail(error),
+        // Process successful responses
+        (res) => {
+          if (decompressor.isPassthrough) {
+            mutableStats.passthroughCount++;
+            return asyncSucceed(res);
+          }
+          const processed = processResponse(
+            res,
+            decompressor,
+            enabledEncodings,
+            mutableStats
+          );
+          return asyncSucceed(processed);
+        }
+      );
+    };
+  };
+  const stats = () => Object.freeze({
+    decompressed: Object.freeze({ ...mutableStats.decompressed }),
+    compressedBytes: mutableStats.compressedBytes,
+    decompressedBytes: mutableStats.decompressedBytes,
+    passthroughCount: mutableStats.passthroughCount,
+    errorCount: mutableStats.errorCount,
+    unsupportedEncodingCount: mutableStats.unsupportedEncodingCount
+  });
+  return { middleware, stats };
+}
+var makeResponseCompressionMiddleware = makeCompressionMiddleware;
+var DEFAULT_REQUEST_COMPRESS_METHODS = ["POST", "PUT", "PATCH"];
+function makeRequestCompressionMiddleware(config) {
+  const encoding = config?.encoding ?? "gzip";
+  const minBytes = Math.max(0, Math.floor(config?.minBytes ?? 1024));
+  const methods = new Set((config?.methods ?? DEFAULT_REQUEST_COMPRESS_METHODS).map((m) => m.toUpperCase()));
+  const mutableStats = emptyRequestCompressionStats();
+  const middleware = (next) => {
+    return (req) => {
+      const compressed = compressRequest(req, encoding, minBytes, methods, mutableStats);
+      return next(compressed);
+    };
+  };
+  const stats = () => Object.freeze({
+    compressedCount: mutableStats.compressedCount,
+    skippedCount: mutableStats.skippedCount,
+    errorCount: mutableStats.errorCount,
+    originalBytes: mutableStats.originalBytes,
+    compressedBytes: mutableStats.compressedBytes
+  });
+  return { middleware, stats };
+}
+function compressRequest(req, encoding, minBytes, methods, stats) {
+  if (!methods.has(req.method.toUpperCase())) {
+    stats.skippedCount++;
+    return req;
+  }
+  if (req.body === void 0 || hasHeader(req.headers, "content-encoding")) {
+    stats.skippedCount++;
+    return req;
+  }
+  const originalBytes = httpBodyByteLength(req.body);
+  if (originalBytes < minBytes) {
+    stats.skippedCount++;
+    return req;
+  }
+  try {
+    const compressed = compressBuffer(httpBodyToBuffer(req.body), encoding);
+    stats.compressedCount++;
+    stats.originalBytes += originalBytes;
+    stats.compressedBytes += compressed.byteLength;
+    return {
+      ...req,
+      body: compressed,
+      headers: setHeaders(req.headers, {
+        "Content-Encoding": encoding,
+        "Content-Length": String(compressed.byteLength)
+      })
+    };
+  } catch {
+    stats.errorCount++;
+    return req;
+  }
+}
+function compressBuffer(input, encoding) {
+  const zlib2 = __require("zlib");
+  switch (encoding) {
+    case "gzip":
+      return zlib2.gzipSync(input);
+    case "br":
+      return zlib2.brotliCompressSync(input);
+    case "deflate":
+      return zlib2.deflateSync(input);
+  }
+}
+function hasHeader(headers, name) {
+  if (!headers) return false;
+  const lower = name.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === lower);
+}
+function setHeaders(headers, values) {
+  const out = { ...headers ?? {} };
+  for (const [key, value] of Object.entries(values)) {
+    const existing = Object.keys(out).find((h) => h.toLowerCase() === key.toLowerCase());
+    if (existing) out[existing] = value;
+    else out[key] = value;
+  }
+  return out;
+}
+
+// src/http/batching.ts
+var DEFAULT_MAX_BATCH_SIZE = 16;
+var DEFAULT_MAX_WAIT_MS = 5;
+function withRequestBatching(config) {
+  const maxBatchSize = Math.max(1, Math.floor(config.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE));
+  const maxWaitMs = Math.max(0, Math.floor(config.maxWaitMs ?? DEFAULT_MAX_WAIT_MS));
+  const keyOf = config.key ?? ((req) => `${req.method}:${req.url}`);
+  const pending = /* @__PURE__ */ new Map();
+  return (next) => {
+    return (req) => {
+      let key;
+      try {
+        if (config.shouldBatch && !config.shouldBatch(req)) return next(req);
+        key = keyOf(req) ?? void 0;
+      } catch {
+        return next(req);
+      }
+      if (!key) return next(req);
+      return {
+        _tag: "Async",
+        register: (env, cb) => {
+          const entry = { req, env, cb, cancelled: false, done: false };
+          const batch = getOrCreatePending(key);
+          batch.entries.push(entry);
+          emit(config, { type: "batch-enqueue", key, size: batch.entries.length, request: req });
+          if (batch.entries.length >= maxBatchSize) {
+            flush(key, next, "size");
+          } else if (batch.timer === void 0) {
+            batch.timer = setTimeout(() => flush(key, next, "timer"), maxWaitMs);
+          }
+          return () => cancelEntry(key, entry);
+        }
+      };
+    };
+    function getOrCreatePending(key) {
+      const existing = pending.get(key);
+      if (existing) return existing;
+      const created = { key, entries: [] };
+      pending.set(key, created);
+      return created;
+    }
+    function cancelEntry(key, entry) {
+      if (entry.done || entry.cancelled) return;
+      entry.cancelled = true;
+      complete(entry, { _tag: "Failure", cause: Cause.interrupt() });
+      const queued = pending.get(key);
+      if (queued) {
+        queued.entries = queued.entries.filter((e) => e !== entry);
+        emit(config, { type: "batch-cancel", key, remaining: queued.entries.length });
+        if (queued.entries.length === 0) {
+          if (queued.timer !== void 0) clearTimeout(queued.timer);
+          pending.delete(key);
+        }
+        return;
+      }
+      const group = entry.group;
+      if (!group || group.cancelled) return;
+      if (group.entries.every((e) => e.cancelled || e.done)) {
+        group.cancelled = true;
+        group.cancel?.();
+      }
+    }
+    function flush(key, downstream, reason) {
+      const batch = pending.get(key);
+      if (!batch) return;
+      pending.delete(key);
+      if (batch.timer !== void 0) clearTimeout(batch.timer);
+      const entries = batch.entries.filter((entry) => !entry.cancelled && !entry.done);
+      if (entries.length === 0) return;
+      emit(config, { type: "batch-flush", key, size: entries.length, reason });
+      let batchReq;
+      try {
+        batchReq = config.encode(entries.map((entry) => entry.req));
+      } catch (e) {
+        failEntries(config, key, entries, toFetchError(e));
+        return;
+      }
+      const group = { key, entries, cancelled: false };
+      for (const entry of entries) entry.group = group;
+      const effect = downstream(batchReq);
+      group.cancel = runEffect(effect, entries[0].env, (exit) => {
+        if (exit._tag === "Failure") {
+          const err = exit.cause._tag === "Fail" ? exit.cause.error : exit.cause._tag === "Interrupt" ? { _tag: "Abort" } : toFetchError(exit.cause.defect);
+          failEntries(config, key, entries, err);
+          return;
+        }
+        let decoded;
+        try {
+          decoded = config.decode(exit.value, entries.map((entry) => entry.req));
+          if (decoded.length !== entries.length) {
+            throw new Error(`batch decoder returned ${decoded.length} responses for ${entries.length} requests`);
+          }
+        } catch (e) {
+          failEntries(config, key, entries, toFetchError(e));
+          return;
+        }
+        for (let i = 0; i < entries.length; i++) {
+          complete(entries[i], { _tag: "Success", value: decoded[i] });
+        }
+      });
+    }
+  };
+}
+function complete(entry, exit) {
+  if (entry.done) return;
+  entry.done = true;
+  entry.cb(exit);
+}
+function failEntries(config, key, entries, error) {
+  emit(config, { type: "batch-error", key, size: entries.length, error });
+  for (const entry of entries) {
+    complete(entry, { _tag: "Failure", cause: Cause.fail(error) });
+  }
+}
+function toFetchError(error) {
+  if (isHttpError(error)) return error;
+  return { _tag: "FetchError", message: error instanceof Error ? error.message : String(error) };
+}
+function isHttpError(error) {
+  if (typeof error !== "object" || error === null || !("_tag" in error)) return false;
+  const tag = error._tag;
+  return tag === "Abort" || tag === "BadUrl" || tag === "FetchError" || tag === "Timeout" || tag === "PoolRejected" || tag === "PoolTimeout";
+}
+function emit(config, event) {
+  if (!config.onEvent) return;
+  try {
+    config.onEvent(event);
+  } catch {
+  }
+}
+function runEffect(effect, env, cb) {
+  let cancelled = false;
+  let currentCancel;
+  const finish = (exit) => {
+    if (cancelled) return;
+    cb(exit);
+  };
+  const run = (eff, k) => {
+    if (cancelled) return;
+    switch (eff._tag) {
+      case "Succeed":
+        k({ _tag: "Success", value: eff.value });
+        return;
+      case "Fail":
+        k({ _tag: "Failure", cause: Cause.fail(eff.error) });
+        return;
+      case "Sync":
+        try {
+          k({ _tag: "Success", value: eff.thunk(env) });
+        } catch (e) {
+          k({ _tag: "Failure", cause: Cause.die(e) });
+        }
+        return;
+      case "Async": {
+        const cancel = eff.register(env, (exit) => {
+          currentCancel = void 0;
+          k(exit);
+        });
+        currentCancel = typeof cancel === "function" ? cancel : void 0;
+        return;
+      }
+      case "FlatMap":
+        run(eff.first, (exit) => {
+          if (exit._tag === "Failure") {
+            k(exit);
+            return;
+          }
+          try {
+            run(eff.andThen(exit.value), k);
+          } catch (e) {
+            k({ _tag: "Failure", cause: Cause.die(e) });
+          }
+        });
+        return;
+      case "Fold":
+        run(eff.first, (exit) => {
+          try {
+            if (exit._tag === "Success") {
+              run(eff.onSuccess(exit.value), k);
+            } else if (exit.cause._tag === "Fail") {
+              run(eff.onFailure(exit.cause.error), k);
+            } else {
+              k(exit);
+            }
+          } catch (e) {
+            k({ _tag: "Failure", cause: Cause.die(e) });
+          }
+        });
+        return;
+      case "Fork":
+        k({ _tag: "Success", value: void 0 });
+        return;
+    }
+  };
+  run(effect, finish);
+  return () => {
+    if (cancelled) return;
+    cancelled = true;
+    currentCancel?.();
+  };
+}
+
+// src/http/prewarm.ts
+function prewarmConnections(config = {}) {
+  const fetchImpl = config.fetchImpl ?? globalThis.fetch;
+  const method = config.method ?? "HEAD";
+  const targets = resolveTargets(config);
+  return fromPromiseAbortable(
+    async (signal) => {
+      if (typeof fetchImpl !== "function" || targets.length === 0) {
+        return { attempted: 0, warmed: 0, failed: 0, skipped: targets.length, attempts: [] };
+      }
+      const attempts = [];
+      for (const url of targets) {
+        const origin = new URL(url).origin;
+        const started = performance.now();
+        emit2(config, { type: "prewarm-start", url, origin });
+        try {
+          const res = await fetchImpl(url, {
+            method,
+            headers: config.headers,
+            cache: "no-store",
+            signal
+          });
+          const ms = Math.round(performance.now() - started);
+          attempts.push({ url, origin, ok: true, status: res.status, ms });
+          emit2(config, { type: "prewarm-success", url, origin, status: res.status, ms });
+        } catch (e) {
+          const ms = Math.round(performance.now() - started);
+          const error = normalizePrewarmError(e);
+          attempts.push({ url, origin, ok: false, error, ms });
+          emit2(config, { type: "prewarm-failure", url, origin, error, ms });
+          if (config.failFast) throw error;
+        }
+      }
+      return {
+        attempted: attempts.length,
+        warmed: attempts.filter((attempt) => attempt.ok).length,
+        failed: attempts.filter((attempt) => !attempt.ok).length,
+        skipped: 0,
+        attempts
+      };
+    },
+    normalizePrewarmError,
+    {
+      label: "http:prewarm",
+      timeoutMs: config.timeoutMs,
+      timeoutReason: config.timeoutMs ? () => ({
+        _tag: "Timeout",
+        timeoutMs: config.timeoutMs,
+        phase: "request",
+        message: `HTTP prewarm timed out after ${config.timeoutMs}ms`
+      }) : void 0
+    }
+  );
+}
+var prewarmHttpConnections = prewarmConnections;
+function withConnectionPrewarming(config = {}) {
+  const once = config.once ?? true;
+  const warmed = /* @__PURE__ */ new Set();
+  const warming = /* @__PURE__ */ new Set();
+  return (next) => (req) => {
+    if (config.shouldPrewarm && !config.shouldPrewarm(req)) return next(req);
+    const target = config.target?.(req) ?? req.url;
+    if (!target) return next(req);
+    const resolved = resolveUrl(target, config.baseUrl);
+    if (!resolved) return next(req);
+    const key = resolved.origin;
+    if (once && (warmed.has(key) || warming.has(key))) return next(req);
+    warming.add(key);
+    return asyncFold(
+      prewarmConnections({
+        ...config,
+        urls: [resolved.toString()],
+        origins: void 0,
+        onEvent: (event) => {
+          if (event.type === "prewarm-success") warmed.add(key);
+          config.onEvent?.(event);
+        }
+      }),
+      (error) => {
+        warming.delete(key);
+        if (config.failFast || error._tag === "Abort") return asyncFail(error);
+        return next(req);
+      },
+      () => {
+        warming.delete(key);
+        return next(req);
+      }
+    );
+  };
+}
+function resolveTargets(config) {
+  const out = [];
+  const path = config.path ?? "/";
+  for (const url of config.urls ?? []) {
+    const resolved = resolveUrl(url, config.baseUrl);
+    if (resolved) out.push(resolved.toString());
+  }
+  for (const origin of config.origins ?? []) {
+    const resolved = resolveUrl(path, origin);
+    if (resolved) out.push(resolved.toString());
+  }
+  if (out.length === 0 && config.baseUrl) {
+    const resolved = resolveUrl(path, config.baseUrl);
+    if (resolved) out.push(resolved.toString());
+  }
+  return Array.from(new Set(out));
+}
+function resolveUrl(value, baseUrl) {
+  try {
+    return new URL(value, baseUrl || void 0);
+  } catch {
+    return void 0;
+  }
+}
+function normalizePrewarmError(error) {
+  if (isHttpError2(error)) return error;
+  if (typeof error === "object" && error !== null && error.name === "AbortError") {
+    return { _tag: "Abort" };
+  }
+  return { _tag: "FetchError", message: error instanceof Error ? error.message : String(error) };
+}
+function isHttpError2(error) {
+  if (typeof error !== "object" || error === null || !("_tag" in error)) return false;
+  const tag = error._tag;
+  return tag === "Abort" || tag === "BadUrl" || tag === "FetchError" || tag === "Timeout" || tag === "PoolRejected" || tag === "PoolTimeout";
+}
+function emit2(config, event) {
+  if (!config.onEvent) return;
+  try {
+    config.onEvent(event);
+  } catch {
+  }
+}
 export {
+  DEFAULT_CACHE_RELEVANT_HEADERS,
   HttpConcurrencyPool,
+  LRUCache,
+  LifecycleStatsTracker,
+  PriorityQueue,
+  SEPARATOR,
+  SUPPORTED_ENCODINGS,
+  backoffDelayMs,
+  clampPriority,
+  computeCacheKey,
   decorate,
+  defaultRetryOnError,
+  defaultRetryOnStatus,
+  defaultRetryableMethods,
   httpClient,
   httpClientStream,
   httpClientWithMeta,
+  makeCompressionMiddleware,
   makeHttp,
+  makeHttpClient,
   makeHttpStream,
+  makeLifecycleClient,
+  makeRequestCompressionMiddleware,
+  makeResponseCompressionMiddleware,
   normalizeHeadersInit,
+  normalizeRetryBudget,
+  parseCacheKey,
+  prewarmConnections,
+  prewarmHttpConnections,
   resolveHttpPoolKey,
+  retryAfterMs,
   validatedJson,
+  withAuth,
+  withCache,
   withCircuitBreaker,
+  withConnectionPrewarming,
+  withDedup,
+  withLogging,
   withMiddleware,
+  withPriority,
+  withRequestBatching,
+  withResponseTransform,
+  withRetry,
   withRetryStream,
   withTracing
 };