brass-runtime 1.16.0 → 1.16.1

package/dist/http/index.js

@@ -1,17 +1,49 @@
 import {
-  registerHttpEffect
-} from "../chunk-H55LI6WY.js";
-import {
-  fixed,
   makeCircuitBreaker,
-  resource,
-  take
-} from "../chunk-KCPT2D6G.js";
+  resource
+} from "../chunk-B33ICAKP.js";
+import {
+  DEFAULT_CACHE_RELEVANT_HEADERS,
+  LRUCache,
+  LifecycleStatsTracker,
+  PriorityQueue,
+  SEPARATOR,
+  SUPPORTED_ENCODINGS,
+  buildHttpRequest,
+  clampPriority,
+  computeCacheKey,
+  decodeJsonBody,
+  decodeJsonBodyEffect,
+  defaultHttpClientPreset,
+  detectPlatform,
+  encodeJsonBodyEffect,
+  executeProbe,
+  makeBudgetSemaphore,
+  makeCompressionMiddleware,
+  makeConnectionStateMap,
+  makeDefaultHttpClient,
+  makeHttpClient,
+  makeLifecycleClient,
+  makePrewarmManager,
+  makeRequestCompressionMiddleware,
+  makeResponseCompressionMiddleware,
+  now,
+  parseCacheKey,
+  validateFetchAvailable,
+  validateOrigin,
+  validatedJson,
+  validatedJsonResponse,
+  withBatch,
+  withCache,
+  withDedup,
+  withPriority
+} from "../chunk-74ZTY6CP.js";
 import {
   AdaptiveLimiter,
   EmaComputer,
   HttpConcurrencyPool,
   LatencyWindow,
+  abortErrorForSignal,
   adaptiveLimiterPresets,
   backoffDelayMs,
   computeGradient,
@@ -20,38 +52,75 @@ import {
   defaultRetryOnError,
   defaultRetryOnStatus,
   defaultRetryableMethods,
+  headersOf,
+  isAbortError,
+  isTaggedHttpError,
+  linkAbortSignals,
   makeAdaptiveLimiterConfig,
+  makeFetchStreamTransport,
+  makeFetchTransport,
   makeHttp,
   makeHttpStream,
-  mergeHeaders,
+  makePromiseHttpTransport,
   normalizeHeadersInit,
+  normalizeHttpError,
+  normalizeHttpHeaders,
   normalizeRetryBudget,
+  promiseHttpTransport,
   resolveConfig,
   resolveHttpPoolKey,
   retryAfterMs,
   setHeaderIfMissing,
   validateConfig,
-  validateDefaultHttpClientConfig,
-  validateLifecycleClientConfig,
   withMiddleware,
   withRetry,
   withRetryStream
-} from "../chunk-7TL2LHQJ.js";
-import "../chunk-OOGJ73B6.js";
-import "../chunk-ROJC3NBJ.js";
+} from "../chunk-MIIYDLGM.js";
+import {
+  registerHttpEffect
+} from "../chunk-TRM4JUZQ.js";
+import "../chunk-7JIJOVCT.js";
+import "../chunk-UCUBNWM2.js";
+import {
+  fixed,
+  makeScheduleDriver,
+  take
+} from "../chunk-6IXXWIUM.js";
+import "../chunk-L2SYFEBS.js";
 import {
   healthToHttpResponse,
   makeRuntimeHealth,
   runObservedHttpServerEffect
-} from "../chunk-7XOPAB5Q.js";
-import "../chunk-XDZOO4L5.js";
-import "../chunk-G3XGCZDQ.js";
-import "../chunk-FM4W4QPL.js";
+} from "../chunk-CIZFIMK5.js";
+import "../chunk-RKGKFN2A.js";
+import {
+  defineHttpPolicyPresets,
+  formatHttpError,
+  getHttpRequestPolicy,
+  httpErrorStatus,
+  httpPolicy,
+  isAbortHttpError,
+  isCircuitBreakerOpen,
+  isExternalAbortError,
+  isExternalTimeoutError,
+  isFetchHttpError,
+  isHttpError,
+  isKnownHttpError,
+  isRetryableHttpError,
+  isRetryableHttpStatus,
+  isTimeoutHttpError,
+  isValidationError,
+  matchHttpError,
+  resolveHttpRequestPolicyPresets,
+  toHttpError,
+  withHttpPolicyPresets,
+  withHttpRequestPolicy
+} from "../chunk-3Y2RIUMM.js";
 import {
   Runtime,
   fromPromiseAbortable,
   toPromise
-} from "../chunk-7LVI2GIN.js";
+} from "../chunk-FH2X7BVP.js";
 import {
   Cause,
   asyncEffect,
@@ -61,122 +130,22 @@ import {
   asyncSucceed,
   mapTryAsync,
   withAsyncPromise
-} from "../chunk-PNVFW245.js";
+} from "../chunk-UB4B6OFY.js";
 import {
   ConfigValidationError,
   Schema,
   SchemaValidationException,
+  formatConfigError,
   formatIssues,
+  isConfigValidationError,
   isSchema,
   makeSchemaIssue,
   parseConfig,
   s,
   schema,
   validateValue
-} from "../chunk-TDVMADDN.js";
-import {
-  __require
-} from "../chunk-3RG5ZIWI.js";
-
-// src/http/validation.ts
-function decodeJsonBody(bodyText, validator, options = {}) {
-  let parsed;
-  try {
-    parsed = JSON.parse(bodyText);
-  } catch (error) {
-    return {
-      success: false,
-      error: {
-        _tag: "ValidationError",
-        message: `JSON parse error: ${error instanceof Error ? error.message : String(error)}`,
-        body: bodyText,
-        phase: "response",
-        schema: options.schemaName,
-        issues: [makeSchemaIssue([], "valid JSON", bodyText, "Response body is not valid JSON")]
-      }
-    };
-  }
-  if (!validator) return { success: true, data: parsed };
-  let legacyMessage;
-  const validation = isSchema(validator) ? validator.safeParse(parsed) : (() => {
-    const result = validator(parsed);
-    if (result.success) return { success: true, data: result.data };
-    legacyMessage = result.error;
-    return {
-      success: false,
-      issues: result.issues ?? [makeSchemaIssue([], "valid JSON shape", parsed, result.error)]
-    };
-  })();
-  if (validation.success) return { success: true, data: validation.data };
-  return {
-    success: false,
-    error: {
-      _tag: "ValidationError",
-      message: legacyMessage ?? `JSON response failed validation: ${formatIssues(validation.issues)}`,
-      body: bodyText,
-      phase: "response",
-      schema: options.schemaName,
-      issues: validation.issues
-    }
-  };
-}
-function encodeJsonBodyEffect(bodyObj, validator, options = {}) {
-  if (validator) {
-    const validation = validateValue(bodyObj, validator);
-    if (!validation.success) {
-      return asyncFail({
-        _tag: "ValidationError",
-        message: `JSON request body failed validation: ${formatIssues(validation.issues)}`,
-        body: previewJson(bodyObj),
-        phase: "request",
-        schema: options.schemaName,
-        issues: validation.issues
-      });
-    }
-  }
-  try {
-    return asyncSucceed(JSON.stringify(bodyObj ?? {}));
-  } catch (error) {
-    return asyncFail({
-      _tag: "ValidationError",
-      message: `JSON request body could not be serialized: ${error instanceof Error ? error.message : String(error)}`,
-      body: "",
-      phase: "request",
-      schema: options.schemaName,
-      issues: [
-        makeSchemaIssue([], "JSON-serializable value", bodyObj, "Request body could not be serialized to JSON")
-      ]
-    });
-  }
-}
-function decodeJsonBodyEffect(bodyText, validator, options) {
-  const result = decodeJsonBody(bodyText, validator, options);
-  return result.success ? asyncSucceed(result.data) : asyncFail(result.error);
-}
-function validatedJson(client, validator) {
-  return (req) => asyncFold(
-    client(req),
-    (error) => asyncFail(error),
-    (response) => decodeJsonBodyEffect(response.bodyText, validator)
-  );
-}
-function validatedJsonResponse(client, validator) {
-  return (req) => asyncFold(
-    client(req),
-    (error) => asyncFail(error),
-    (response) => asyncFlatMap(
-      decodeJsonBodyEffect(response.bodyText, validator),
-      (body) => asyncSucceed({ ...response, body })
-    )
-  );
-}
-function previewJson(value) {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "[unserializable]";
-  }
-}
+} from "../chunk-C3MDXTRZ.js";
+import "../chunk-3RG5ZIWI.js";
 
 // src/http/httpClient.ts
 var resolveFinalUrl = (baseUrl, url) => {
@@ -190,48 +159,24 @@ 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, schema: schema2, schemaName, bodySchema, bodySchemaName, ...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 buildReq2 = (method, url, init, body) => {
-    const s2 = splitInit(init);
-    const req = {
-      method,
-      url,
-      ...body && body.length > 0 ? { body } : {},
-      ...s2.timeoutMs !== void 0 ? { timeoutMs: s2.timeoutMs } : {},
-      ...s2.poolKey !== void 0 ? { poolKey: s2.poolKey } : {},
-      init: s2.init
-    };
-    return applyInitHeaders(s2.headers)(req);
-  };
-  const toResponse2 = (w, body) => ({
+  const toResponse = (w, body) => ({
     status: w.status,
     statusText: w.statusText,
     headers: w.headers,
     body
   });
-  const decodeResponse2 = (w, validator, schemaName) => asyncFlatMap(
+  const decodeResponse = (w, validator, schemaName) => asyncFlatMap(
     decodeJsonBodyEffect(w.bodyText, validator, { schemaName }),
-    (body) => asyncSucceed(toResponse2(w, body))
+    (body) => asyncSucceed(toResponse(w, body))
   );
   return {
     cfg,
     wire,
     withPromise,
     requestRaw,
-    splitInit,
-    applyInitHeaders,
-    buildReq: buildReq2,
-    toResponse: toResponse2,
-    decodeResponse: decodeResponse2
+    buildReq: buildHttpRequest,
+    toResponse,
+    decodeResponse
   };
 };
 function httpClient(cfg = {}) {
@@ -428,2252 +373,90 @@ function withCircuitBreaker(config = {}) {
     };
     return (next) => (req) => {
       const limiter = resolveAdaptiveLimiter(config, next);
-      const limiterKey = resolveAdaptiveLimiterKey(config, limiter, req);
-      const onOpen = () => limiterKey !== void 0 && limiter?.markCircuitOpen(limiterKey);
-      const breaker2 = getBreaker(req.url, onOpen);
-      return protectLazy(breaker2, next, req, onOpen);
-    };
-  }
-  const breaker = makeCircuitBreaker({
-    ...config,
-    onStateChange: (from, to) => {
-      config.onStateChange?.(from, to);
-    },
-    isFailure: config.isFailure ?? ((e) => {
-      const err = e;
-      return err._tag !== "BadUrl" && err._tag !== "Abort";
-    })
-  });
-  return (next) => (req) => {
-    const limiter = resolveAdaptiveLimiter(config, next);
-    const limiterKey = resolveAdaptiveLimiterKey(config, limiter, req);
-    const onOpen = () => limiterKey !== void 0 && limiter?.markCircuitOpen(limiterKey);
-    return protectLazy(breaker, next, req, onOpen);
-  };
-}
-function protectLazy(breaker, next, req, onOpen) {
-  return {
-    _tag: "Async",
-    register: (env, cb) => {
-      let cancel;
-      try {
-        if (breaker.state() === "open") onOpen?.();
-        const finish = (exit) => {
-          if (breaker.state() === "open") onOpen?.();
-          cb(exit);
-        };
-        const deferred = {
-          _tag: "Async",
-          register: (innerEnv, innerCb) => registerHttpEffect(next(req), innerEnv, innerCb)
-        };
-        cancel = registerHttpEffect(breaker.protect(deferred), env, finish);
-      } catch (error) {
-        cb({
-          _tag: "Failure",
-          cause: {
-            _tag: "Fail",
-            error: { _tag: "FetchError", message: String(error) }
-          }
-        });
-      }
-      return () => cancel?.();
-    }
-  };
-}
-function resolveAdaptiveLimiter(config, next) {
-  return config.adaptiveLimiter ?? next.adaptiveLimiter;
-}
-function resolveAdaptiveLimiterKey(config, limiter, req) {
-  if (!limiter) return void 0;
-  if (config.adaptiveLimiterKey) return config.adaptiveLimiterKey(req);
-  if (req.poolKey) return req.poolKey;
-  if (limiter.keyResolver === "global") return "global";
-  try {
-    const url = new URL(req.url);
-    if (limiter.keyResolver === "host") return url.host;
-    return url.origin;
-  } catch {
-    return "global";
-  }
-}
-
-// src/http/tracing.ts
-function withTracing(tracer) {
-  return (next) => (req) => {
-    return tracer.span(
-      `HTTP ${req.method} ${req.url}`,
-      next(req),
-      {
-        "http.method": req.method,
-        "http.url": req.url,
-        ...req.headers?.["content-type"] ? { "http.content_type": req.headers["content-type"] } : {}
-      }
-    );
-  };
-}
-
-// src/http/errors.ts
-var HTTP_ERROR_TAGS = /* @__PURE__ */ new Set([
-  "Abort",
-  "BadUrl",
-  "FetchError",
-  "Timeout",
-  "PoolRejected",
-  "PoolTimeout",
-  "PoolClosed",
-  "BatchSplitError"
-]);
-function isHttpError(error) {
-  return hasTag(error) && HTTP_ERROR_TAGS.has(error._tag);
-}
-function isValidationError(error) {
-  return hasTag(error) && error._tag === "ValidationError";
-}
-function isCircuitBreakerOpen(error) {
-  return hasTag(error) && error._tag === "CircuitBreakerOpen";
-}
-function isKnownHttpError(error) {
-  return isHttpError(error) || isValidationError(error) || isCircuitBreakerOpen(error);
-}
-function matchHttpError(error, handlers) {
-  if (isKnownHttpError(error)) {
-    const handler = handlers[error._tag];
-    if (handler) return handler(error);
-  }
-  return handlers.default?.(error);
-}
-function formatHttpError(error) {
-  if (isValidationError(error)) {
-    const phase = error.phase ? `${error.phase} ` : "";
-    return `${phase}validation failed: ${error.message}`;
-  }
-  if (isCircuitBreakerOpen(error)) {
-    return `Circuit breaker is open after ${error.failures} failure(s)`;
-  }
-  if (!isHttpError(error)) {
-    return error instanceof Error ? error.message : String(error);
-  }
-  switch (error._tag) {
-    case "Abort":
-      return "HTTP request aborted";
-    case "BadUrl":
-    case "FetchError":
-    case "PoolRejected":
-    case "PoolTimeout":
-    case "PoolClosed":
-    case "BatchSplitError":
-      return error.message;
-    case "Timeout":
-      return error.message;
-  }
-}
-function hasTag(error) {
-  return typeof error === "object" && error !== null && typeof error._tag === "string";
-}
-
-// 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/batch.ts
-function clamp(value, min, max) {
-  if (!Number.isFinite(value)) return min;
-  return Math.max(min, Math.min(max, Math.floor(value)));
-}
-function safeEmitBatch(onEvent, event) {
-  if (!onEvent) return;
-  try {
-    onEvent(event);
-  } catch {
-  }
-}
-function withBatch(config, onEvent) {
-  const windowMs = clamp(config.windowMs, 1, 5e3);
-  const maxBatchSize = clamp(config.maxBatchSize, 2, 1e4);
-  const { batch, batchKey } = config;
-  const groups = /* @__PURE__ */ new Map();
-  return (next) => {
-    function dispatch(group) {
-      group.dispatched = true;
-      if (group.timer !== null) {
-        clearTimeout(group.timer);
-        group.timer = null;
-      }
-      groups.delete(group.key);
-      const requests = group.waiters.map((w) => w.request);
-      const waiterCount = group.waiters.length;
-      let coalescedReq;
-      try {
-        coalescedReq = batch.coalesce(requests);
-      } catch (err) {
-        const error = { _tag: "FetchError", message: String(err) };
-        rejectAllWaiters(group, error);
-        return;
-      }
-      coalescedReq = {
-        ...coalescedReq,
-        init: {
-          ...coalescedReq.init ?? {},
-          signal: group.controller.signal
-        }
-      };
-      safeEmitBatch(onEvent, { type: "batch-dispatch", batchKey: group.key, batchSize: waiterCount });
-      const innerEffect = next(coalescedReq);
-      registerHttpEffect(innerEffect, void 0, (exit) => {
-        if (exit._tag === "Success") {
-          let responses;
-          try {
-            responses = batch.split(exit.value, requests);
-          } catch (err2) {
-            const error = { _tag: "FetchError", message: String(err2) };
-            rejectAllWaiters(group, error);
-            return;
-          }
-          if (responses.length !== waiterCount) {
-            const error = {
-              _tag: "BatchSplitError",
-              expected: waiterCount,
-              actual: responses.length,
-              message: `split returned ${responses.length} responses but expected ${waiterCount}`
-            };
-            rejectAllWaiters(group, error);
-            return;
-          }
-          const waiters = group.waiters.slice();
-          for (let i = 0; i < waiters.length; i++) {
-            waiters[i].resolve(responses[i]);
-          }
-          return;
-        }
-        if (exit.cause._tag === "Fail") {
-          rejectAllWaiters(group, exit.cause.error);
-          return;
-        }
-        if (exit.cause._tag === "Interrupt") {
-          rejectAllWaiters(group, { _tag: "Abort" });
-          return;
-        }
-        const err = { _tag: "FetchError", message: String(exit.cause.defect ?? "unknown") };
-        rejectAllWaiters(group, err);
-      });
-    }
-    return (req) => {
-      let key;
-      try {
-        key = batchKey(req);
-      } catch {
-        return next(req);
-      }
-      if (!key) {
-        return next(req);
-      }
-      return {
-        _tag: "Async",
-        register: (_env, cb) => {
-          let callerDone = false;
-          const finishCaller = (exit) => {
-            if (callerDone) return;
-            callerDone = true;
-            cb(exit);
-          };
-          const waiter = {
-            request: req,
-            resolve: (res) => {
-              finishCaller({ _tag: "Success", value: res });
-            },
-            reject: (err) => {
-              finishCaller({ _tag: "Failure", cause: Cause.fail(err) });
-            }
-          };
-          const existing = groups.get(key);
-          if (existing && !existing.dispatched) {
-            existing.waiters.push(waiter);
-            safeEmitBatch(onEvent, { type: "batch-hit", batchKey: key });
-            if (existing.waiters.length >= maxBatchSize) {
-              dispatch(existing);
-            }
-            return () => {
-              if (callerDone) return;
-              const idx = existing.waiters.indexOf(waiter);
-              if (idx >= 0) {
-                existing.waiters.splice(idx, 1);
-              }
-              if (existing.waiters.length === 0 && !existing.dispatched) {
-                if (existing.timer !== null) {
-                  clearTimeout(existing.timer);
-                  existing.timer = null;
-                }
-                groups.delete(key);
-              }
-              if (existing.waiters.length === 0 && existing.dispatched) {
-                existing.controller.abort();
-              }
-              finishCaller({ _tag: "Failure", cause: Cause.interrupt() });
-            };
-          }
-          const controller = new AbortController();
-          const group = {
-            key,
-            controller,
-            waiters: [waiter],
-            timer: null,
-            dispatched: false
-          };
-          group.timer = setTimeout(() => {
-            if (!group.dispatched && group.waiters.length > 0) {
-              dispatch(group);
-            }
-          }, windowMs);
-          groups.set(key, group);
-          return () => {
-            if (callerDone) return;
-            const idx = group.waiters.indexOf(waiter);
-            if (idx >= 0) {
-              group.waiters.splice(idx, 1);
-            }
-            if (group.waiters.length === 0 && !group.dispatched) {
-              if (group.timer !== null) {
-                clearTimeout(group.timer);
-                group.timer = null;
-              }
-              groups.delete(key);
-            }
-            if (group.waiters.length === 0 && group.dispatched) {
-              group.controller.abort();
-            }
-            finishCaller({ _tag: "Failure", cause: Cause.interrupt() });
-          };
-        }
-      };
-    };
-  };
-}
-function rejectAllWaiters(group, err) {
-  const waiters = group.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_CONCURRENCY = 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_CONCURRENCY;
-  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;
-  _batchDispatches = 0;
-  _batchedRequests = 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++;
-  }
-  /**
-   * Records a batch dispatch. Increments the batch dispatches counter by 1.
-   */
-  batchDispatch() {
-    this._batchDispatches++;
-  }
-  /**
-   * Records requests that were coalesced into a batch.
-   * @param count - The number of individual requests in the batch.
-   */
-  batchedRequests(count) {
-    this._batchedRequests += count;
-  }
-  // --- 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,
-      batchDispatches: this._batchDispatches,
-      batchedRequests: this._batchedRequests,
-      wire: this._wireStats()
-    });
-  }
-};
-
-// src/http/prewarm/validation.ts
-function validateOrigin(origin) {
-  if (!origin || typeof origin !== "string") {
-    throw new Error(`validateOrigin: origin must be a non-empty string, got "${origin}"`);
-  }
-  const trimmed = origin.trim();
-  if (!trimmed) {
-    throw new Error(`validateOrigin: origin must be a non-empty string, got "${origin}"`);
-  }
-  const stripped = stripTrailingSlashes(trimmed);
-  const lower = stripped.toLowerCase();
-  if (!lower.startsWith("http://") && !lower.startsWith("https://")) {
-    throw new Error(
-      `validateOrigin: invalid origin "${origin}" \u2014 must start with http:// or https://`
-    );
-  }
-  let parsed;
-  try {
-    parsed = new URL(stripped);
-  } catch {
-    throw new Error(
-      `validateOrigin: invalid origin "${origin}" \u2014 must be a valid URL origin (scheme + host + optional port)`
-    );
-  }
-  if (parsed.pathname !== "/" && parsed.pathname !== "") {
-    throw new Error(
-      `validateOrigin: invalid origin "${origin}" \u2014 must not contain a path`
-    );
-  }
-  if (parsed.search) {
-    throw new Error(
-      `validateOrigin: invalid origin "${origin}" \u2014 must not contain query parameters`
-    );
-  }
-  if (parsed.hash) {
-    throw new Error(
-      `validateOrigin: invalid origin "${origin}" \u2014 must not contain a fragment`
-    );
-  }
-  return parsed.origin;
-}
-function stripTrailingSlashes(value) {
-  let end = value.length;
-  while (end > 0 && value.charCodeAt(end - 1) === 47) {
-    end--;
-  }
-  return end === value.length ? value : value.slice(0, end);
-}
-
-// src/http/prewarm/platform.ts
-function detectPlatform() {
-  return typeof window !== "undefined" && typeof window.document !== "undefined" ? "browser" : "node";
-}
-function validateFetchAvailable() {
-  if (typeof globalThis.fetch !== "function") {
-    throw new Error(
-      "makePrewarmManager: global fetch is not available. Requires Node.js 18+ or modern browser."
-    );
-  }
-  if (typeof globalThis.AbortController !== "function") {
-    throw new Error(
-      "makePrewarmManager: global AbortController is not available."
-    );
-  }
-}
-
-// src/http/prewarm/probe.ts
-async function executeProbe(origin, options) {
-  const { timeoutMs, signal, platform } = options;
-  const url = `${origin}/`;
-  const start = Date.now();
-  const timeoutController = new AbortController();
-  const timeoutId = setTimeout(() => timeoutController.abort(), timeoutMs);
-  const onExternalAbort = () => timeoutController.abort();
-  signal.addEventListener("abort", onExternalAbort);
-  try {
-    if (options.client) {
-      const result = await executeProbeViaClient(options.client, url, timeoutController.signal);
-      const durationMs2 = Date.now() - start;
-      if (result.ok) {
-        return { ok: true, durationMs: durationMs2 };
-      }
-      return { ok: false, durationMs: durationMs2, error: result.error };
-    }
-    const fetchOptions = {
-      method: "HEAD",
-      signal: timeoutController.signal,
-      // Prevent caching of probe requests
-      cache: "no-store"
-    };
-    if (platform === "browser") {
-      fetchOptions.mode = "no-cors";
-    }
-    await globalThis.fetch(url, fetchOptions);
-    const durationMs = Date.now() - start;
-    return { ok: true, durationMs };
-  } catch (err) {
-    const durationMs = Date.now() - start;
-    if (signal.aborted) {
-      return { ok: false, durationMs, error: "cancelled" };
-    }
-    if (timeoutController.signal.aborted && !signal.aborted) {
-      return { ok: false, durationMs, error: `Probe timed out after ${timeoutMs}ms` };
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    return { ok: false, durationMs, error: message };
-  } finally {
-    clearTimeout(timeoutId);
-    signal.removeEventListener("abort", onExternalAbort);
-  }
-}
-async function executeProbeViaClient(client, url, signal) {
-  const { registerHttpEffect: registerHttpEffect2 } = await import("../effectRunner-A4CHJXJI.js");
-  return new Promise((resolve) => {
-    const effect = client({
-      method: "HEAD",
-      url,
-      init: { signal }
-    });
-    const cancel = registerHttpEffect2(effect, {}, (exit) => {
-      if (exit._tag === "Success") {
-        resolve({ ok: true });
-      } else {
-        const cause = exit.cause;
-        if (cause?._tag === "Fail") {
-          const err = cause.error;
-          resolve({ ok: false, error: err?.message ?? err?._tag ?? "Unknown error" });
-        } else {
-          resolve({ ok: false, error: "cancelled" });
-        }
-      }
-    });
-    if (signal.aborted) {
-      cancel();
-    } else {
-      signal.addEventListener("abort", () => {
-        cancel();
-      }, { once: true });
-    }
-  });
-}
-
-// src/http/prewarm/connectionState.ts
-function makeConnectionStateMap(origins, keepAliveDurationMs) {
-  const entries = /* @__PURE__ */ new Map();
-  for (const origin of origins) {
-    entries.set(origin, {
-      origin,
-      status: "idle",
-      lastProbeAt: void 0,
-      warmUntil: void 0
-    });
-  }
-  function markWarm(origin, now2) {
-    const entry = entries.get(origin);
-    if (!entry) return;
-    const timestamp = now2 ?? Date.now();
-    entry.status = "warm";
-    entry.lastProbeAt = timestamp;
-    entry.warmUntil = timestamp + keepAliveDurationMs;
-  }
-  function markExpired(origin) {
-    const entry = entries.get(origin);
-    if (!entry) return;
-    entry.status = "expired";
-  }
-  function markIdle(origin) {
-    const entry = entries.get(origin);
-    if (!entry) return;
-    entry.status = "idle";
-    entry.lastProbeAt = void 0;
-    entry.warmUntil = void 0;
-  }
-  function markProbing(origin) {
-    const entry = entries.get(origin);
-    if (!entry) return;
-    entry.status = "probing";
-  }
-  function isWarm(origin, now2) {
-    const entry = entries.get(origin);
-    if (!entry) return false;
-    if (entry.status !== "warm") return false;
-    if (entry.lastProbeAt === void 0 || entry.warmUntil === void 0) return false;
-    const currentTime = now2 ?? Date.now();
-    if (currentTime >= entry.warmUntil) {
-      entry.status = "expired";
-      return false;
-    }
-    return true;
-  }
-  function getState(origin) {
-    const entry = entries.get(origin);
-    if (!entry) return void 0;
-    return {
-      origin: entry.origin,
-      status: entry.status,
-      lastProbeAt: entry.lastProbeAt,
-      warmUntil: entry.warmUntil
-    };
-  }
-  function snapshot() {
-    const result = [];
-    for (const entry of entries.values()) {
-      result.push({
-        origin: entry.origin,
-        status: entry.status,
-        lastProbeAt: entry.lastProbeAt,
-        warmUntil: entry.warmUntil
-      });
-    }
-    return { origins: result };
-  }
-  return { markWarm, markExpired, markIdle, markProbing, isWarm, getState, snapshot };
-}
-
-// src/http/prewarm/budgetSemaphore.ts
-function makeBudgetSemaphore(capacity) {
-  if (capacity < 1 || !Number.isFinite(capacity)) {
-    throw new Error(`makeBudgetSemaphore: capacity must be >= 1, got ${capacity}`);
-  }
-  capacity = Math.floor(capacity);
-  let active = 0;
-  const waiters = [];
-  function release() {
-    active--;
-    if (waiters.length > 0) {
-      const next = waiters.shift();
-      active++;
-      next({ release });
-    }
-  }
-  function acquire() {
-    if (active < capacity) {
-      active++;
-      return Promise.resolve({ release });
-    }
-    return new Promise((resolve) => {
-      waiters.push(resolve);
-    });
-  }
-  function tryAcquire() {
-    if (active < capacity) {
-      active++;
-      return { release };
-    }
-    return void 0;
-  }
-  function available() {
-    return capacity - active;
-  }
-  function queued() {
-    return waiters.length;
-  }
-  return { acquire, tryAcquire, available, queued };
-}
-
-// src/http/prewarm/prewarmManager.ts
-var DEFAULTS = {
-  keepAliveDurationMs: 55e3,
-  budget: 4,
-  probeTimeoutMs: 5e3,
-  autoRefresh: false,
-  useClientPool: false
-};
-function makePrewarmManager(config) {
-  validateFetchAvailable();
-  const keepAliveDurationMs = config.keepAliveDurationMs ?? DEFAULTS.keepAliveDurationMs;
-  const budget = config.budget ?? DEFAULTS.budget;
-  const probeTimeoutMs = config.probeTimeoutMs ?? DEFAULTS.probeTimeoutMs;
-  const autoRefresh = config.autoRefresh ?? DEFAULTS.autoRefresh;
-  const useClientPool = config.useClientPool ?? DEFAULTS.useClientPool;
-  const onEvent = config.onEvent;
-  const client = config.client;
-  const origins = config.origins.map((o) => validateOrigin(o));
-  const platform = detectPlatform();
-  const stateMap = makeConnectionStateMap(origins, keepAliveDurationMs);
-  const semaphore = makeBudgetSemaphore(budget);
-  const abortControllers = /* @__PURE__ */ new Map();
-  const refreshTimers = /* @__PURE__ */ new Map();
-  let disposed = false;
-  function emit3(event) {
-    if (onEvent) {
-      try {
-        onEvent(event);
-      } catch {
-      }
-    }
-  }
-  function scheduleAutoRefresh(origin) {
-    if (!autoRefresh || disposed) return;
-    clearRefreshTimer(origin);
-    const delay = Math.floor(0.8 * keepAliveDurationMs);
-    const timer = setTimeout(() => {
-      refreshTimers.delete(origin);
-      if (disposed) return;
-      if (stateMap.isWarm(origin)) {
-        stateMap.markExpired(origin);
-        emit3({
-          type: "connection-expired",
-          origin,
-          timestamp: Date.now()
-        });
-      }
-      warm(origin).catch(() => {
-      });
-    }, delay);
-    if (typeof timer === "object" && "unref" in timer) {
-      timer.unref();
-    }
-    refreshTimers.set(origin, timer);
-  }
-  function clearRefreshTimer(origin) {
-    const timer = refreshTimers.get(origin);
-    if (timer !== void 0) {
-      clearTimeout(timer);
-      refreshTimers.delete(origin);
-    }
-  }
-  function clearAllRefreshTimers() {
-    for (const [, timer] of refreshTimers) {
-      clearTimeout(timer);
-    }
-    refreshTimers.clear();
-  }
-  async function warm(origin) {
-    if (disposed) {
-      return { origin, status: "cancelled", durationMs: 0 };
-    }
-    if (stateMap.isWarm(origin)) {
-      return { origin, status: "already-warm", durationMs: 0 };
-    }
-    const { release } = await semaphore.acquire();
-    if (disposed) {
-      release();
-      return { origin, status: "cancelled", durationMs: 0 };
-    }
-    const controller = new AbortController();
-    abortControllers.set(origin, controller);
-    stateMap.markProbing(origin);
-    try {
-      const probeOptions = {
-        timeoutMs: probeTimeoutMs,
-        signal: controller.signal,
-        platform,
-        client: useClientPool ? client : void 0
-      };
-      const outcome = await executeProbe(origin, probeOptions);
-      if (controller.signal.aborted) {
-        stateMap.markIdle(origin);
-        emit3({
-          type: "connection-cancelled",
-          origin,
-          timestamp: Date.now()
-        });
-        return { origin, status: "cancelled", durationMs: outcome.durationMs };
-      }
-      if (outcome.ok) {
-        stateMap.markWarm(origin);
-        emit3({
-          type: "connection-warmed",
-          origin,
-          timestamp: Date.now(),
-          durationMs: outcome.durationMs
-        });
-        scheduleAutoRefresh(origin);
-        return { origin, status: "warmed", durationMs: outcome.durationMs };
-      } else {
-        stateMap.markIdle(origin);
-        emit3({
-          type: "connection-failed",
-          origin,
-          timestamp: Date.now(),
-          error: outcome.error
-        });
-        return { origin, status: "failed", durationMs: outcome.durationMs, error: outcome.error };
-      }
-    } catch (err) {
-      stateMap.markIdle(origin);
-      const error = err instanceof Error ? err.message : String(err);
-      emit3({
-        type: "connection-failed",
-        origin,
-        timestamp: Date.now(),
-        error
-      });
-      return { origin, status: "failed", durationMs: 0, error };
-    } finally {
-      abortControllers.delete(origin);
-      release();
-    }
-  }
-  async function warmAll() {
-    const results = await Promise.all(origins.map((o) => warm(o)));
-    return results;
-  }
-  function cancel(origin) {
-    const controller = abortControllers.get(origin);
-    if (controller) {
-      controller.abort();
-    }
-    clearRefreshTimer(origin);
-  }
-  function cancelAll() {
-    for (const [, controller] of abortControllers) {
-      controller.abort();
-    }
-    clearAllRefreshTimers();
-  }
-  function isWarm(origin) {
-    if (disposed) return false;
-    return stateMap.isWarm(origin);
-  }
-  function status() {
-    return stateMap.snapshot();
-  }
-  function dispose() {
-    if (disposed) return;
-    disposed = true;
-    cancelAll();
-    for (const origin of origins) {
-      stateMap.markIdle(origin);
-    }
-  }
-  return {
-    warm,
-    warmAll,
-    isWarm,
-    cancel,
-    cancelAll,
-    status,
-    dispose
-  };
-}
-
-// 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, batch, cache, priority, retry, prewarm, onEvent, ...wireConfig } = config;
-  return wireConfig;
-}
-function makeLifecycleClient(config = {}) {
-  validateLifecycleClientConfig(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 hasBatch = config.batch !== void 0 && config.batch !== 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 && !hasBatch && !hasCache && !hasPriority && !hasRetry) {
-    let prewarmMgr2;
-    const hasPrewarm2 = config.prewarm !== void 0 && config.prewarm !== false;
-    if (hasPrewarm2) {
-      const prewarmConfig = config.prewarm;
-      const prewarmOrigins = prewarmConfig.origins ?? [];
-      if (prewarmOrigins.length > 0) {
-        prewarmMgr2 = makePrewarmManager({
-          origins: prewarmOrigins,
-          keepAliveDurationMs: prewarmConfig.keepAliveDurationMs,
-          budget: prewarmConfig.budget,
-          probeTimeoutMs: prewarmConfig.probeTimeoutMs,
-          autoRefresh: prewarmConfig.autoRefresh,
-          useClientPool: prewarmConfig.useClientPool,
-          client: prewarmConfig.useClientPool ? wireClient : void 0,
-          onEvent: prewarmConfig.onEvent
-        });
-      }
-    }
-    return buildLifecycleClient(wireClient, tracker, {
-      cacheInvalidate: noopInvalidate,
-      cacheClear: noopClear,
-      cancelAll: () => cancelControllers(activeControllers, prewarmMgr2),
-      shutdown: () => shutdownClient(activeControllers, prewarmMgr2, wireClient.shutdown),
-      activeControllers,
-      adaptiveLimiter: wireClient.adaptiveLimiter,
-      prewarmManager: prewarmMgr2,
-      afterResponse: hasPrewarm2 ? config.prewarm.afterResponse : void 0
-    });
-  }
-  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 batchMiddleware;
-  if (hasBatch) {
-    const batchConfig = config.batch;
-    batchMiddleware = withBatch(batchConfig, (event) => {
-      if (event.type === "batch-dispatch") {
-        tracker.batchDispatch();
-        tracker.batchedRequests(event.batchSize ?? 0);
-      }
-      tracker.emit(event.type, { batchKey: event.batchKey, batchSize: event.batchSize });
-    });
-  }
-  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 (batchMiddleware) {
-    composedFn = batchMiddleware(composedFn);
-  }
-  if (dedupMiddleware) {
-    composedFn = dedupMiddleware(composedFn);
-  }
-  let prewarmMgr;
-  const hasPrewarm = config.prewarm !== void 0 && config.prewarm !== false;
-  if (hasPrewarm) {
-    const prewarmConfig = config.prewarm;
-    const prewarmOrigins = prewarmConfig.origins ?? [];
-    if (prewarmOrigins.length > 0) {
-      prewarmMgr = makePrewarmManager({
-        origins: prewarmOrigins,
-        keepAliveDurationMs: prewarmConfig.keepAliveDurationMs,
-        budget: prewarmConfig.budget,
-        probeTimeoutMs: prewarmConfig.probeTimeoutMs,
-        autoRefresh: prewarmConfig.autoRefresh,
-        useClientPool: prewarmConfig.useClientPool,
-        client: prewarmConfig.useClientPool ? wireClient : void 0,
-        onEvent: prewarmConfig.onEvent
-      });
-    }
+      const limiterKey = resolveAdaptiveLimiterKey(config, limiter, req);
+      const onOpen = () => limiterKey !== void 0 && limiter?.markCircuitOpen(limiterKey);
+      const breaker2 = getBreaker(req.url, onOpen);
+      return protectLazy(breaker2, next, req, onOpen);
+    };
   }
-  return buildLifecycleClient(composedFn, tracker, {
-    cacheInvalidate: cacheLayer?.invalidate ?? noopInvalidate,
-    cacheClear: cacheLayer?.clear ?? noopClear,
-    cancelAll: () => cancelControllers(activeControllers, prewarmMgr),
-    shutdown: () => shutdownClient(activeControllers, prewarmMgr, wireClient.shutdown),
-    activeControllers,
-    adaptiveLimiter: wireClient.adaptiveLimiter,
-    queueDepth: priorityMiddleware?.queueDepth,
-    prewarmManager: prewarmMgr,
-    afterResponse: hasPrewarm ? config.prewarm.afterResponse : void 0
+  const breaker = makeCircuitBreaker({
+    ...config,
+    onStateChange: (from, to) => {
+      config.onStateChange?.(from, to);
+    },
+    isFailure: config.isFailure ?? ((e) => {
+      const err = e;
+      return err._tag !== "BadUrl" && err._tag !== "Abort";
+    })
   });
-}
-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(withLifecycleMetadata(fn, internals));
-    return buildLifecycleClient(wrappedFn, tracker, internals);
+  return (next) => (req) => {
+    const limiter = resolveAdaptiveLimiter(config, next);
+    const limiterKey = resolveAdaptiveLimiterKey(config, limiter, req);
+    const onOpen = () => limiterKey !== void 0 && limiter?.markCircuitOpen(limiterKey);
+    return protectLazy(breaker, next, req, onOpen);
   };
-  const lifecycleClient = Object.assign(client, {
-    with: withMw,
-    stats,
-    cancelAll: internals.cancelAll,
-    shutdown: internals.shutdown,
-    adaptiveLimiter: internals.adaptiveLimiter,
-    cache: {
-      invalidate: internals.cacheInvalidate,
-      clear: internals.cacheClear
-    }
-  });
-  return lifecycleClient;
-}
-function withLifecycleMetadata(fn, internals) {
-  if (!internals.adaptiveLimiter) return fn;
-  return Object.assign(((req) => fn(req)), {
-    adaptiveLimiter: internals.adaptiveLimiter
-  });
-}
-function cancelControllers(activeControllers, prewarmMgr) {
-  for (const controller of Array.from(activeControllers)) {
-    try {
-      controller.abort();
-    } catch {
-    }
-  }
-  if (prewarmMgr) {
-    prewarmMgr.cancelAll();
-  }
-  return asyncSucceed(void 0);
 }
-function shutdownClient(activeControllers, prewarmMgr, wireShutdown) {
-  cancelControllers(activeControllers, prewarmMgr);
-  wireShutdown?.();
-  return asyncSucceed(void 0);
-}
-function trackRequest(fn, req, tracker, internals) {
+function protectLazy(breaker, next, req, onOpen) {
   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();
-          if (internals.afterResponse && internals.prewarmManager) {
-            try {
-              const originsToWarm = internals.afterResponse(exit.value, req);
-              if (originsToWarm && originsToWarm.length > 0) {
-                for (const origin of originsToWarm) {
-                  internals.prewarmManager.warm(origin).catch(() => {
-                  });
-                }
-              }
-            } catch {
-            }
-          }
-        } else {
-          tracker.requestFailed();
-        }
-        tracker.emit("request-end");
-        cb(exit);
-      };
-      const trackedReq = {
-        ...req,
-        init: {
-          ...req.init ?? {},
-          signal: controller.signal
-        }
-      };
+      let cancel;
       try {
-        cancelInner = registerHttpEffect(fn(trackedReq), env, finish);
+        if (breaker.state() === "open") onOpen?.();
+        const finish = (exit) => {
+          if (breaker.state() === "open") onOpen?.();
+          cb(exit);
+        };
+        const deferred = {
+          _tag: "Async",
+          register: (innerEnv, innerCb) => registerHttpEffect(next(req), innerEnv, innerCb)
+        };
+        cancel = registerHttpEffect(breaker.protect(deferred), env, finish);
       } catch (error) {
-        finish({
+        cb({
           _tag: "Failure",
-          cause: Cause.fail({ _tag: "FetchError", message: String(error) })
+          cause: {
+            _tag: "Fail",
+            error: { _tag: "FetchError", message: String(error) }
+          }
         });
       }
-      return () => {
-        if (done) return;
-        try {
-          controller.abort();
-        } catch {
-        }
-        if (cancelInner) {
-          cancelInner();
-        } else {
-          finish({ _tag: "Failure", cause: Cause.interrupt() });
-        }
-      };
+      return () => cancel?.();
     }
   };
 }
+function resolveAdaptiveLimiter(config, next) {
+  return config.adaptiveLimiter ?? next.adaptiveLimiter;
+}
+function resolveAdaptiveLimiterKey(config, limiter, req) {
+  if (!limiter) return void 0;
+  if (config.adaptiveLimiterKey) return config.adaptiveLimiterKey(req);
+  const poolKey = getHttpRequestPolicy(req).poolKey;
+  if (poolKey) return poolKey;
+  if (limiter.keyResolver === "global") return "global";
+  try {
+    const url = new URL(req.url);
+    if (limiter.keyResolver === "host") return url.host;
+    return url.origin;
+  } catch {
+    return "global";
+  }
+}
+
+// src/http/tracing.ts
+function withTracing(tracer) {
+  return (next) => (req) => {
+    return tracer.span(
+      `HTTP ${req.method} ${req.url}`,
+      next(req),
+      {
+        "http.method": req.method,
+        "http.url": req.url,
+        ...req.headers?.["content-type"] ? { "http.content_type": req.headers["content-type"] } : {}
+      }
+    );
+  };
+}
 
 // src/http/lifecycle/middleware.ts
 function withAuth(tokenProvider) {
@@ -2743,299 +526,6 @@ function withResponseTransform(fn) {
   };
 }
 
-// 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/decompressor.node.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 emptyStats() {
-  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");
-  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 = emptyStats();
-  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;
@@ -3118,7 +608,7 @@ function withRequestBatching(config) {
       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);
+          const err = causeToHttpError(exit.cause);
           failEntries(config, key, entries, err);
           return;
         }
@@ -3154,6 +644,12 @@ function toFetchError(error) {
   if (isHttpError2(error)) return error;
   return { _tag: "FetchError", message: error instanceof Error ? error.message : String(error) };
 }
+function causeToHttpError(cause) {
+  const failure = Cause.firstFailure(cause);
+  if (failure._tag === "Some") return failure.value;
+  if (Cause.isInterruptedOnly(cause)) return { _tag: "Abort" };
+  return toFetchError(Cause.toError(cause));
+}
 function isHttpError2(error) {
   if (typeof error !== "object" || error === null || !("_tag" in error)) return false;
   const tag = error._tag;
@@ -3215,10 +711,13 @@ function runEffect(effect, env, cb) {
           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);
+              const failure = Cause.isFailureOnly(exit.cause) ? Cause.firstFailure(exit.cause) : void 0;
+              if (failure?._tag === "Some") {
+                run(eff.onFailure(failure.value), k);
+              } else {
+                k(exit);
+              }
             }
           } catch (e) {
             k({ _tag: "Failure", cause: Cause.die(e) });
@@ -3228,6 +727,14 @@ function runEffect(effect, env, cb) {
       case "Fork":
         k({ _tag: "Success", value: void 0 });
         return;
+      case "Interruptibility":
+      case "InterruptibilityRestore":
+      case "FiberRefLocally":
+        run(eff.effect, k);
+        return;
+      case "InterruptibilityMask":
+        run(eff.body((effect2) => effect2), k);
+        return;
     }
   };
   run(effect, finish);
@@ -3372,220 +879,6 @@ function emit2(config, event) {
   }
 }
 
-// src/http/defaultClient.ts
-var MINIMAL_PRESET_CONFIG = {
-  timeoutMs: 3e4
-};
-var BALANCED_PRESET_CONFIG = {
-  ...MINIMAL_PRESET_CONFIG,
-  dedup: {},
-  priority: {
-    concurrency: 32,
-    queueTimeoutMs: 3e4
-  },
-  retry: {
-    maxRetries: 2,
-    baseDelayMs: 100,
-    maxDelayMs: 1e3,
-    maxElapsedMs: 5e3,
-    respectRetryAfter: true
-  },
-  adaptiveLimiter: makeAdaptiveLimiterConfig("balanced")
-};
-var DEFAULT_CACHEABLE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
-var DEFAULT_PRESET_CONFIG = {
-  ...BALANCED_PRESET_CONFIG,
-  cache: {
-    ttlSeconds: 60,
-    maxEntries: 1024,
-    staleWhileRevalidate: true,
-    cachePolicy: (req, res) => ({
-      cacheable: DEFAULT_CACHEABLE_METHODS.has(req.method) && res.status >= 200 && res.status < 400
-    })
-  },
-  priority: {
-    concurrency: 64,
-    queueTimeoutMs: 3e4
-  },
-  retry: {
-    maxRetries: 3,
-    baseDelayMs: 100,
-    maxDelayMs: 2e3,
-    maxElapsedMs: 1e4,
-    respectRetryAfter: true
-  },
-  adaptiveLimiter: makeAdaptiveLimiterConfig("aggressive")
-};
-var PRESET_CONFIGS = {
-  minimal: MINIMAL_PRESET_CONFIG,
-  balanced: BALANCED_PRESET_CONFIG,
-  default: DEFAULT_PRESET_CONFIG
-};
-var defaultHttpClientPreset = "default";
-function makeDefaultHttpClient(config = {}) {
-  validateDefaultHttpClientConfig(config);
-  const {
-    preset = defaultHttpClientPreset,
-    compression,
-    middleware = [],
-    ...lifecycleOverrides
-  } = config;
-  const lifecycleConfig = mergeLifecycleConfig(PRESET_CONFIGS[preset], lifecycleOverrides);
-  let wire = makeLifecycleClient(lifecycleConfig);
-  const compressionResult = compression === false || compression === void 0 && preset === "minimal" ? void 0 : makeCompressionMiddleware(compression === void 0 ? void 0 : compression);
-  if (compressionResult) {
-    wire = wire.with(compressionResult.middleware);
-  }
-  for (const mw of middleware) {
-    wire = wire.with(mw);
-  }
-  const features = featureSnapshot(lifecycleConfig, compressionResult !== void 0, middleware.length);
-  return buildDefaultClient(wire, {
-    preset,
-    features,
-    compressionStats: compressionResult?.stats
-  });
-}
-function buildDefaultClient(wire, meta) {
-  const withPromise = (eff) => withAsyncPromise((e, env) => toPromise(e, env))(eff);
-  const requestRaw = (req) => wire(req);
-  const request = (req) => withPromise(requestRaw(req));
-  const get = (url, init) => request(buildReq("GET", url, init));
-  const post = (url, body, init) => request(buildReq("POST", url, init, body));
-  const getText = (url, init) => {
-    const req = buildReq("GET", url, init);
-    return withPromise(
-      mapTryAsync(requestRaw(req), (w) => toResponse(w, w.bodyText))
-    );
-  };
-  const getJson = ((url, init) => {
-    const req = setHeaderIfMissing("accept", "application/json")(
-      buildReq("GET", url, init)
-    );
-    return withPromise(
-      asyncFlatMap(requestRaw(req), (w) => decodeResponse(w, init?.schema, init?.schemaName))
-    );
-  });
-  const postJson = ((url, bodyObj, init) => {
-    return withPromise(
-      asyncFlatMap(
-        encodeJsonBodyEffect(bodyObj, init?.bodySchema, { schemaName: init?.bodySchemaName }),
-        (bodyText) => {
-          const req = setHeaderIfMissing("content-type", "application/json")(
-            setHeaderIfMissing("accept", "application/json")(
-              buildReq("POST", url, init, bodyText)
-            )
-          );
-          return asyncFlatMap(requestRaw(req), (w) => decodeResponse(w, init?.schema, init?.schemaName));
-        }
-      )
-    );
-  });
-  return {
-    request,
-    get,
-    post,
-    getText,
-    getJson,
-    postJson,
-    with: (mw) => buildDefaultClient(wire.with(mw), {
-      ...meta,
-      features: {
-        ...meta.features,
-        middleware: meta.features.middleware + 1
-      }
-    }),
-    wire,
-    stats: () => wire.stats(),
-    cache: wire.cache,
-    cancelAll: wire.cancelAll,
-    shutdown: wire.shutdown,
-    preset: meta.preset,
-    features: meta.features,
-    ...meta.compressionStats ? {
-      compression: {
-        stats: meta.compressionStats
-      }
-    } : {}
-  };
-}
-function buildReq(method, url, init, body) {
-  const { headers, timeoutMs, poolKey, schema: schema2, schemaName, bodySchema, bodySchemaName, ...rest } = init ?? {};
-  const normalizedHeaders = normalizeHeadersInit(headers);
-  const req = {
-    method,
-    url,
-    ...body && body.length > 0 ? { body } : {},
-    ...typeof timeoutMs === "number" ? { timeoutMs } : {},
-    ...typeof poolKey === "string" ? { poolKey } : {},
-    init: rest
-  };
-  return normalizedHeaders ? mergeHeaders(normalizedHeaders)(req) : req;
-}
-function toResponse(wire, body) {
-  return {
-    status: wire.status,
-    statusText: wire.statusText,
-    headers: wire.headers,
-    body
-  };
-}
-function decodeResponse(wire, schema2, schemaName) {
-  return asyncFlatMap(
-    decodeJsonBodyEffect(wire.bodyText, schema2, { schemaName }),
-    (body) => asyncSucceed(toResponse(wire, body))
-  );
-}
-function mergeLifecycleConfig(defaults, overrides) {
-  return {
-    ...defaults,
-    ...overrides,
-    headers: mergeRecord(defaults.headers, overrides.headers),
-    dedup: mergeLayer(defaults.dedup, overrides.dedup),
-    batch: mergeLayer(defaults.batch, overrides.batch),
-    cache: mergeLayer(defaults.cache, overrides.cache),
-    priority: mergeLayer(defaults.priority, overrides.priority),
-    retry: mergeLayer(defaults.retry, overrides.retry),
-    prewarm: mergeLayer(defaults.prewarm, overrides.prewarm),
-    adaptiveLimiter: mergeAdaptiveLimiterLayer(defaults.adaptiveLimiter, overrides.adaptiveLimiter),
-    pool: mergeLayer(defaults.pool, overrides.pool)
-  };
-}
-function mergeRecord(defaults, overrides) {
-  if (!defaults) return overrides;
-  if (!overrides) return defaults;
-  return { ...defaults, ...overrides };
-}
-function mergeLayer(defaults, overrides) {
-  if (overrides === void 0) return defaults;
-  if (overrides === false) return false;
-  if (defaults === void 0 || defaults === false) return overrides;
-  return { ...defaults, ...overrides };
-}
-function mergeAdaptiveLimiterLayer(defaults, overrides) {
-  if (overrides === void 0) return defaults;
-  if (overrides === false) return false;
-  if (defaults === void 0 || defaults === false) return overrides;
-  if (overrides.preset !== void 0) return overrides;
-  return { ...defaults, ...overrides };
-}
-function featureSnapshot(config, compression, middleware) {
-  return Object.freeze({
-    dedup: isEnabled(config.dedup),
-    batch: isEnabled(config.batch),
-    cache: isEnabled(config.cache),
-    priority: isEnabled(config.priority),
-    retry: isEnabled(config.retry),
-    prewarm: isEnabled(config.prewarm),
-    adaptiveLimiter: isEnabled(config.adaptiveLimiter),
-    compression,
-    middleware
-  });
-}
-function isEnabled(value) {
-  return value !== void 0 && value !== false;
-}
-
 // src/http/builder.ts
 var DEFAULT_BUILDER_RETRY = {
   maxRetries: 2,
@@ -3645,10 +938,12 @@ function makeBuilder(config) {
     }),
     timeoutMs: (timeoutMs) => replace({ timeoutMs }),
     timeout: (timeoutMs) => replace({ timeoutMs }),
+    transport: (transport) => replace({ transport }),
     preset: (preset) => replace({ preset }),
     minimal: () => replace({ preset: "minimal" }),
     balanced: () => replace({ preset: "balanced" }),
     defaultPreset: () => replace({ preset: "default" }),
+    production: () => replace({ preset: "production" }),
     dedup: (layer = {}) => setLayer("dedup", layer),
     noDedup: () => setLayer("dedup", false),
     batch: (layer) => setLayer("batch", layer),
@@ -3838,6 +1133,21 @@ function nodeHttpServerResource(options) {
 }
 var makeNodeHttpServerResource = nodeHttpServerResource;
 var makeHttpServerResource = nodeHttpServerResource;
+var HttpServer = Object.freeze({
+  route,
+  httpRoute,
+  router: makeHttpRouter,
+  listen: makeNodeHttpServer,
+  resource: nodeHttpServerResource,
+  json,
+  text,
+  empty,
+  healthRoute: makeRuntimeHealthRoute,
+  readinessRoute: makeRuntimeReadinessRoute,
+  middleware: Object.freeze({
+    header: withResponseHeader
+  })
+});
 function handleRouteMatch(request, match, options) {
   if (match._tag === "NotFound") {
     return asyncSucceed(json({ error: "Not Found" }, { status: 404 }));
@@ -3923,7 +1233,7 @@ function validateResponseBody(response, routeWithSchemas) {
     success: false,
     error: makeValidationError({
       message: `HTTP response failed validation: ${formatIssues(result.issues)}`,
-      body: previewJson2(response.body),
+      body: previewJson(response.body),
       phase: "response",
       schema: routeWithSchemas.options.responseSchemaName ?? "response",
       issues: result.issues
@@ -4091,7 +1401,7 @@ function closeNodeServer(server, options) {
   return new Promise((resolve, reject) => {
     const startedAt = Date.now();
     const schedule = options.shutdownPollSchedule ?? defaultShutdownPollSchedule(options.gracefulShutdownMs ?? 5e3);
-    let state = schedule.initial();
+    const driver = makeScheduleDriver(schedule, { name: schedule.name ?? "http.server.shutdown", startedAtMs: startedAt });
     let finished = false;
     const done = (error) => {
       if (finished) return;
@@ -4107,11 +1417,10 @@ function closeNodeServer(server, options) {
         done();
         return;
       }
-      const [decision, nextState] = schedule.step(state, {
+      const decision = driver.next({
         listening: server.listening,
         elapsedMs: Date.now() - startedAt
       });
-      state = nextState;
       if (!decision.continue) {
         server.closeAllConnections?.();
         done();
@@ -4238,7 +1547,7 @@ function serverUrl(server) {
   const host = address.address === "::" || address.address === "0.0.0.0" ? "127.0.0.1" : address.address;
   return `http://${host}:${address.port}`;
 }
-function previewJson2(value) {
+function previewJson(value) {
   try {
     return JSON.stringify(value);
   } catch {
@@ -4261,6 +1570,7 @@ export {
   DEFAULT_CACHE_RELEVANT_HEADERS,
   EmaComputer,
   HttpConcurrencyPool,
+  HttpServer,
   LRUCache,
   LatencyWindow,
   LifecycleStatsTracker,
@@ -4269,6 +1579,7 @@ export {
   SUPPORTED_ENCODINGS,
   Schema,
   SchemaValidationException,
+  abortErrorForSignal,
   adaptiveLimiterPresets,
   backoffDelayMs,
   clampPriority,
@@ -4282,29 +1593,48 @@ export {
   defaultRetryOnError,
   defaultRetryOnStatus,
   defaultRetryableMethods,
+  defineHttpPolicyPresets,
   detectPlatform,
   empty,
   encodeJsonBodyEffect,
   executeProbe,
+  formatConfigError,
   formatHttpError,
   formatIssues,
+  getHttpRequestPolicy,
+  headersOf,
   httpBuilder,
   httpClient,
   httpClientBuilder,
   httpClientStream,
   httpClientWithMeta,
+  httpErrorStatus,
+  httpPolicy,
   httpRoute,
+  isAbortError,
+  isAbortHttpError,
   isCircuitBreakerOpen,
+  isConfigValidationError,
+  isExternalAbortError,
+  isExternalTimeoutError,
+  isFetchHttpError,
   isHttpError,
   isKnownHttpError,
+  isRetryableHttpError,
+  isRetryableHttpStatus,
   isSchema,
+  isTaggedHttpError,
+  isTimeoutHttpError,
   isValidationError,
   json,
+  linkAbortSignals,
   makeAdaptiveLimiterConfig,
   makeBudgetSemaphore,
   makeCompressionMiddleware,
   makeConnectionStateMap,
   makeDefaultHttpClient,
+  makeFetchStreamTransport,
+  makeFetchTransport,
   makeHttp,
   makeHttpClient,
   makeHttpClientBuilder,
@@ -4315,6 +1645,7 @@ export {
   makeNodeHttpServer,
   makeNodeHttpServerResource,
   makePrewarmManager,
+  makePromiseHttpTransport,
   makeRequestCompressionMiddleware,
   makeResponseCompressionMiddleware,
   makeRuntimeHealthRoute,
@@ -4323,13 +1654,17 @@ export {
   matchHttpError,
   nodeHttpServerResource,
   normalizeHeadersInit,
+  normalizeHttpError,
+  normalizeHttpHeaders,
   normalizeRetryBudget,
   parseCacheKey,
   parseConfig,
   prewarmConnections,
   prewarmHttpConnections,
+  promiseHttpTransport,
   resolveConfig,
   resolveHttpPoolKey,
+  resolveHttpRequestPolicyPresets,
   retryAfterMs,
   route,
   runtimeHealthRoute,
@@ -4337,6 +1672,7 @@ export {
   s,
   schema,
   text,
+  toHttpError,
   validateConfig,
   validateFetchAvailable,
   validateOrigin,
@@ -4349,6 +1685,8 @@ export {
   withCircuitBreaker,
   withConnectionPrewarming,
   withDedup,
+  withHttpPolicyPresets,
+  withHttpRequestPolicy,
   withLogging,
   withMiddleware,
   withPriority,