brass-runtime 1.15.0 → 1.16.1

package/dist/http/index.js

@@ -1,937 +1,151 @@
-import {
-  streamFromReadableStream
-} from "../chunk-PPUXIH5R.js";
 import {
   makeCircuitBreaker,
-  sleep
-} from "../chunk-BDYEENHT.js";
-import "../chunk-TO7IKXYT.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,
+  computeNewLimit,
+  decorate,
+  defaultRetryOnError,
+  defaultRetryOnStatus,
+  defaultRetryableMethods,
+  headersOf,
+  isAbortError,
+  isTaggedHttpError,
+  linkAbortSignals,
+  makeAdaptiveLimiterConfig,
+  makeFetchStreamTransport,
+  makeFetchTransport,
+  makeHttp,
+  makeHttpStream,
+  makePromiseHttpTransport,
+  normalizeHeadersInit,
+  normalizeHttpError,
+  normalizeHttpHeaders,
+  normalizeRetryBudget,
+  promiseHttpTransport,
+  resolveConfig,
+  resolveHttpPoolKey,
+  retryAfterMs,
+  setHeaderIfMissing,
+  validateConfig,
+  withMiddleware,
+  withRetry,
+  withRetryStream
+} 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-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-FH2X7BVP.js";
 import {
   Cause,
-  __require,
   asyncEffect,
   asyncFail,
   asyncFlatMap,
   asyncFold,
   asyncSucceed,
-  fromPromiseAbortable,
   mapTryAsync,
-  resolveWasmModule,
-  toPromise,
   withAsyncPromise
-} from "../chunk-BMH5AV44.js";
-
-// src/http/optics/lens.ts
-var Lens = {
-  make(get, set) {
-    return { get, set };
-  },
-  over(ln, f) {
-    return (s) => ln.set(f(ln.get(s)))(s);
-  },
-  compose(ab, sa) {
-    return Lens.make(
-      (s) => ab.get(sa.get(s)),
-      (b) => (s) => sa.set(ab.set(b)(sa.get(s)))(s)
-    );
-  }
-};
-
-// src/http/optics/request.ts
-var Request = {
-  headers: Lens.make(
-    (req) => req.headers ?? {},
-    (headers) => (req) => ({ ...req, headers })
-  )
-};
-var mergeHeaders = (extra) => (req) => Lens.over(Request.headers, (h) => ({ ...h, ...extra }))(req);
-var mergeHeadersUnder = (under) => (req) => Lens.over(Request.headers, (h) => ({ ...under, ...h }))(req);
-var setHeaderIfMissing = (k, v) => (req) => Lens.over(Request.headers, (h) => h[k] ? h : { ...h, [k]: v })(req);
-
-// src/http/retry/wasmRetryPlanner.ts
-var WasmRetryPlannerBridge = class {
-  planner;
-  constructor(Ctor) {
-    this.planner = new Ctor();
-  }
-  start(options) {
-    return this.planner.start(
-      options.nowMs,
-      options.maxRetries,
-      options.baseDelayMs,
-      options.maxDelayMs,
-      options.maxElapsedMs ?? -1,
-      BigInt(this.seed())
-    );
-  }
-  nextDelayMs(retryId, options) {
-    const delay = this.planner.next_delay_ms(retryId, options.nowMs, options.retryable, options.retryAfterMs ?? -1);
-    return delay < 0 ? void 0 : delay;
-  }
-  drop(retryId) {
-    this.planner.drop_state(retryId);
-  }
-  stats() {
-    return {
-      live: this.planner.metric_u64(0),
-      planned: this.planner.metric_u64(1),
-      exhausted: this.planner.metric_u64(2),
-      dropped: this.planner.metric_u64(3)
-    };
-  }
-  seed() {
-    return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
-  }
-};
-function makeWasmRetryPlanner() {
-  const mod = resolveWasmModule();
-  const Ctor = mod?.BrassWasmRetryPlanner;
-  if (!Ctor) throw new Error("brass-runtime wasm retry planner is not available. Run npm run build:wasm first.");
-  return new WasmRetryPlannerBridge(Ctor);
-}
-
-// src/http/retry/retry.ts
-var defaultRetryableMethods = ["GET", "HEAD", "OPTIONS"];
-var defaultRetryOnStatus = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
-var defaultRetryOnError = (e) => e._tag === "FetchError" || e._tag === "Timeout" || e._tag === "PoolTimeout";
-var clamp = (n, min, max) => Math.max(min, Math.min(max, n));
-var backoffDelayMs = (attempt, base, cap) => {
-  const b = Math.max(0, base);
-  const c = Math.max(0, cap);
-  const exp = b * Math.pow(2, attempt);
-  const lim = clamp(exp, 0, c);
-  return Math.floor(Math.random() * lim);
-};
-var headerCI = (h, name) => {
-  const k = Object.keys(h).find((x) => x.toLowerCase() === name.toLowerCase());
-  return k ? h[k] : void 0;
-};
-var retryAfterMs = (headers) => {
-  const v = headerCI(headers, "retry-after")?.trim();
-  if (!v) return void 0;
-  const secs = Number(v);
-  if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
-  const t = Date.parse(v);
-  if (Number.isFinite(t)) return Math.max(0, t - Date.now());
-  return void 0;
-};
-var normalizeRetryBudget = (ms) => {
-  if (ms === void 0 || !Number.isFinite(ms)) return void 0;
-  return Math.max(0, Math.floor(ms));
-};
-var resolveEffectivePolicy = (req, basePolicy) => {
-  const override = req.retry;
-  if (override === false) return null;
-  if (override === void 0) return basePolicy;
-  return {
-    ...basePolicy,
-    ...override.maxRetries !== void 0 && { maxRetries: override.maxRetries },
-    ...override.baseDelayMs !== void 0 && { baseDelayMs: override.baseDelayMs },
-    ...override.maxDelayMs !== void 0 && { maxDelayMs: override.maxDelayMs },
-    ...override.retryOnStatus !== void 0 && { retryOnStatus: override.retryOnStatus }
-  };
-};
-var resolveRetryEngine = (p) => {
-  if (p.engine !== void 0) {
-    if (p.engine === "ts" || p.engine === "wasm") return p.engine;
-    throw new Error(`brass-runtime retry engine must be 'ts' or 'wasm'; received '${String(p.engine)}'`);
-  }
-  if (p.wasm === true) return "wasm";
-  if (p.wasm === false) return "ts";
-  return "ts";
-};
-var withRetry = (p) => (next) => {
-  const retryOnMethods = p.retryOnMethods ?? defaultRetryableMethods;
-  const retryEngine = resolveRetryEngine(p);
-  const wasmPlanner = retryEngine === "wasm" ? makeWasmRetryPlanner() : void 0;
-  const isMethodRetryable = (req) => retryOnMethods.includes(req.method);
-  const nextDelay = (ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable, retryAfter) => {
-    if (!retryable) return void 0;
-    if (wasmPlanner && retryId !== void 0) {
-      return wasmPlanner.nextDelayMs(retryId, {
-        nowMs: performance.now(),
-        retryable,
-        retryAfterMs: retryAfter
-      });
-    }
-    const remainingBudget = epMaxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : epMaxElapsedMs - (performance.now() - startedAt);
-    if (remainingBudget <= 0) return void 0;
-    const rawDelay = retryAfter === void 0 ? backoffDelayMs(attempt, ep.baseDelayMs, ep.maxDelayMs) : Math.min(retryAfter, ep.maxDelayMs);
-    return Math.max(0, Math.min(rawDelay, remainingBudget));
-  };
-  const sleepWithCleanup = (ms, onCancel) => {
-    return asyncEffect((_env, cb) => {
-      const delay = Math.max(0, Math.floor(ms));
-      const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), delay);
-      return () => {
-        clearTimeout(id);
-        onCancel();
-      };
-    });
-  };
-  const loop = (req, attempt, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop) => {
-    if (!isMethodRetryable(req)) return next(req);
-    const effectiveReq = attempt > 0 ? (() => {
-      const boostedReq = { ...req };
-      boostedReq.priority = Math.max(0, originalPriority - 1);
-      return boostedReq;
-    })() : req;
-    const remainingBudget = () => epMaxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : epMaxElapsedMs - (performance.now() - startedAt);
-    return asyncFold(
-      next(effectiveReq),
-      (e) => {
-        if (e._tag === "Abort" || e._tag === "BadUrl" || e._tag === "PoolRejected" || e._tag === "CircuitBreakerOpen") {
-          safeDrop(retryId);
-          return asyncFail(e);
-        }
-        const retryable = attempt < ep.maxRetries && epRetryOnError(e) && remainingBudget() > 0;
-        const d = nextDelay(ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable);
-        if (d === void 0 || d <= 0 && epMaxElapsedMs !== void 0) {
-          safeDrop(retryId);
-          return asyncFail(e);
-        }
-        if (ep.onRetry) {
-          ep.onRetry({
-            attempt,
-            delayMs: d,
-            error: e,
-            status: void 0,
-            url: req.url,
-            method: req.method,
-            timestamp: Date.now()
-          });
-        }
-        return asyncFlatMap(sleepWithCleanup(d, () => safeDrop(retryId)), () => loop(req, attempt + 1, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop));
-      },
-      (w) => {
-        const retryable = attempt < ep.maxRetries && epRetryOnStatus(w.status) && remainingBudget() > 0;
-        const ra = ep.respectRetryAfter === false ? void 0 : retryAfterMs(w.headers);
-        const d = nextDelay(ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable, ra);
-        if (d === void 0 || d <= 0 && epMaxElapsedMs !== void 0) {
-          safeDrop(retryId);
-          return asyncSucceed(w);
-        }
-        if (ep.onRetry) {
-          ep.onRetry({
-            attempt,
-            delayMs: d,
-            error: void 0,
-            status: w.status,
-            url: req.url,
-            method: req.method,
-            timestamp: Date.now()
-          });
-        }
-        return asyncFlatMap(sleepWithCleanup(d, () => safeDrop(retryId)), () => loop(req, attempt + 1, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop));
-      }
-    );
-  };
-  return (req) => {
-    const effectivePolicy = resolveEffectivePolicy(req, p);
-    if (effectivePolicy === null) return next(req);
-    if (!isMethodRetryable(req)) return next(req);
-    const epRetryOnStatus = effectivePolicy.retryOnStatus ?? defaultRetryOnStatus;
-    const epRetryOnError = effectivePolicy.retryOnError ?? defaultRetryOnError;
-    const epMaxElapsedMs = normalizeRetryBudget(effectivePolicy.maxElapsedMs);
-    const originalPriority = req.priority ?? 5;
-    const startedAt = performance.now();
-    const retryId = wasmPlanner?.start({
-      nowMs: startedAt,
-      maxRetries: effectivePolicy.maxRetries,
-      baseDelayMs: effectivePolicy.baseDelayMs,
-      maxDelayMs: effectivePolicy.maxDelayMs,
-      maxElapsedMs: epMaxElapsedMs
-    });
-    let plannerDropped = false;
-    const safeDrop = (id) => {
-      if (id !== void 0 && !plannerDropped) {
-        plannerDropped = true;
-        wasmPlanner?.drop(id);
-      }
-    };
-    return loop(req, 0, startedAt, retryId, effectivePolicy, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop);
-  };
-};
-
-// src/http/wasmPermitPool.ts
-var DECISION_RUN_NOW = 0;
-var DECISION_QUEUED = 1;
-var WasmHttpPermitPoolBridge = class {
-  pool;
-  keyCache = /* @__PURE__ */ new Map();
-  constructor(Ctor, options) {
-    this.pool = new Ctor(options.concurrency, options.maxQueue, toU64(options.queueTimeoutMs));
-  }
-  acquire(key, subjectId, nowMs = Date.now()) {
-    const keyId = this.internKey(key);
-    const decision = this.pool.acquire(subjectId, keyId, toU64(nowMs));
-    const permitId = this.pool.last_permit_id();
-    if (decision === DECISION_RUN_NOW) return { kind: "run", keyId, permitId };
-    if (decision === DECISION_QUEUED) return { kind: "queued", keyId, permitId };
-    return { kind: "rejected", keyId, permitId };
-  }
-  release(keyId, nowMs = Date.now()) {
-    const ptr = this.pool.release(keyId, toU64(nowMs));
-    return this.readEvents(ptr, this.pool.permit_events_len());
-  }
-  cancel(permitId) {
-    this.pool.cancel(permitId);
-  }
-  advanceTime(nowMs = Date.now()) {
-    const ptr = this.pool.advance_time(toU64(nowMs));
-    return this.readEvents(ptr, this.pool.permit_events_len());
-  }
-  nextDeadlineMs() {
-    return this.pool.next_deadline_ms();
-  }
-  stats() {
-    return {
-      running: this.pool.metric_u64(0),
-      queued: this.pool.metric_u64(1),
-      acquired: this.pool.metric_u64(2),
-      released: this.pool.metric_u64(3),
-      rejected: this.pool.metric_u64(4),
-      queueTimeouts: this.pool.metric_u64(5),
-      keys: this.pool.metric_u64(6)
-    };
-  }
-  internKey(key) {
-    const normalized = key.trim().slice(0, 160) || "global";
-    let id = this.keyCache.get(normalized);
-    if (id === void 0) {
-      id = this.pool.intern_key(normalized);
-      this.keyCache.set(normalized, id);
-    }
-    return id;
-  }
-  readEvents(ptr, len) {
-    if (ptr === 0 || len <= 1) return [];
-    const words = new Uint32Array(this.pool.memory().buffer, ptr, len);
-    const count = words[0] >>> 0;
-    const out = [];
-    for (let i = 0; i < count; i++) {
-      const base = 1 + i * 3;
-      if (base + 2 >= words.length) break;
-      out.push({
-        subjectId: words[base] >>> 0,
-        permitId: words[base + 1] >>> 0,
-        keyId: words[base + 2] >>> 0
-      });
-    }
-    return out;
-  }
-};
-function makeWasmHttpPermitPool(options) {
-  const mod = resolveWasmModule();
-  const Ctor = mod?.BrassWasmHttpPermitPool;
-  if (!Ctor) throw new Error("brass-runtime wasm HTTP permit pool is not available. Run npm run build:wasm first.");
-  return new WasmHttpPermitPoolBridge(Ctor, options);
-}
-function toU64(value) {
-  return BigInt(Math.max(0, Math.floor(value)));
-}
-
-// src/http/pool.ts
-var DEFAULT_CONCURRENCY = 64;
-var DEFAULT_MAX_QUEUE = 256;
-var clampInt = (n, fallback, min) => {
-  if (n === void 0 || !Number.isFinite(n)) return fallback;
-  return Math.max(min, Math.floor(n));
-};
-var queueTimeoutError = (key, timeoutMs) => ({
-  _tag: "PoolTimeout",
-  key,
-  timeoutMs,
-  message: `HTTP pool '${key}' did not grant a slot within ${timeoutMs}ms`
-});
-var poolRejectedError = (key, maxQueue) => ({
-  _tag: "PoolRejected",
-  key,
-  limit: maxQueue,
-  message: `HTTP pool '${key}' queue is full`
-});
-var abortError = () => ({ _tag: "Abort" });
-function resolveHttpPoolEngine(config) {
-  if (config.engine !== void 0) {
-    if (config.engine === "ts" || config.engine === "wasm") return config.engine;
-    throw new Error(`brass-runtime HTTP pool engine must be 'ts' or 'wasm'; received '${String(config.engine)}'`);
-  }
-  if (config.wasm === true) return "wasm";
-  if (config.wasm === false) return "ts";
-  return "ts";
-}
-function resolveHttpPoolKey(resolver, req, url) {
-  const custom = req.poolKey?.trim();
-  if (custom) return custom.slice(0, 160);
-  const r = resolver ?? "origin";
-  if (typeof r === "function") return r(req, url).trim().slice(0, 160) || "global";
-  if (r === "global") return "global";
-  if (r === "host") return url.host;
-  return url.origin;
-}
-var HttpConcurrencyPool = class {
-  states = /* @__PURE__ */ new Map();
-  concurrency;
-  maxQueue;
-  queueTimeoutMs;
-  keyResolver;
-  wasm;
-  wasmWaiters = /* @__PURE__ */ new Map();
-  wasmTimer;
-  nextSubjectId = 1;
-  constructor(config = {}) {
-    this.concurrency = clampInt(config.concurrency, DEFAULT_CONCURRENCY, 1);
-    this.maxQueue = clampInt(config.maxQueue, DEFAULT_MAX_QUEUE, 0);
-    this.queueTimeoutMs = config.queueTimeoutMs !== void 0 && Number.isFinite(config.queueTimeoutMs) ? Math.max(0, Math.floor(config.queueTimeoutMs)) : void 0;
-    this.keyResolver = config.key;
-    const engine = resolveHttpPoolEngine(config);
-    this.wasm = engine === "wasm" ? makeWasmHttpPermitPool({
-      concurrency: this.concurrency,
-      maxQueue: this.maxQueue,
-      queueTimeoutMs: this.queueTimeoutMs ?? 0
-    }) : void 0;
-  }
-  acquire(key, signal) {
-    return this.wasm ? this.acquireWasm(key, signal) : this.acquireJs(key, signal);
-  }
-  stats() {
-    const keys = Array.from(this.states.values()).map((state) => ({
-      key: state.key,
-      running: state.running,
-      queued: state.queue.length,
-      concurrency: this.concurrency,
-      maxQueue: this.maxQueue,
-      acquired: state.acquired,
-      released: state.released,
-      rejected: state.rejected,
-      queueTimeouts: state.queueTimeouts,
-      abortedWhileQueued: state.abortedWhileQueued
-    })).sort((a, b) => b.running + b.queued - (a.running + a.queued) || a.key.localeCompare(b.key));
-    return keys.reduce((acc, key) => ({
-      running: acc.running + key.running,
-      queued: acc.queued + key.queued,
-      acquired: acc.acquired + key.acquired,
-      released: acc.released + key.released,
-      rejected: acc.rejected + key.rejected,
-      queueTimeouts: acc.queueTimeouts + key.queueTimeouts,
-      abortedWhileQueued: acc.abortedWhileQueued + key.abortedWhileQueued,
-      wasm: this.wasm?.stats(),
-      keys: acc.keys.concat(key)
-    }), {
-      running: 0,
-      queued: 0,
-      acquired: 0,
-      released: 0,
-      rejected: 0,
-      queueTimeouts: 0,
-      abortedWhileQueued: 0,
-      ...this.wasm ? { wasm: this.wasm.stats() } : {},
-      keys: []
-    });
-  }
-  acquireJs(key, signal) {
-    const state = this.getState(key);
-    if (signal.aborted) return Promise.reject(abortError());
-    if (state.running < this.concurrency) {
-      state.running++;
-      state.acquired++;
-      return Promise.resolve(this.makeLease(state));
-    }
-    if (state.queue.length >= this.maxQueue) {
-      state.rejected++;
-      return Promise.reject(poolRejectedError(key, this.maxQueue));
-    }
-    return new Promise((resolve, reject) => {
-      const waiter = { signal, resolve, reject };
-      const removeWaiter = () => this.removeWaiter(state, waiter);
-      const cleanup = () => this.cleanupWaiter(waiter);
-      waiter.abort = () => {
-        cleanup();
-        removeWaiter();
-        state.abortedWhileQueued++;
-        reject(abortError());
-      };
-      signal.addEventListener("abort", waiter.abort, { once: true });
-      if (this.queueTimeoutMs !== void 0 && this.queueTimeoutMs > 0) {
-        waiter.timer = setTimeout(() => {
-          cleanup();
-          removeWaiter();
-          state.queueTimeouts++;
-          reject(queueTimeoutError(key, this.queueTimeoutMs));
-        }, this.queueTimeoutMs);
-      }
-      state.queue.push(waiter);
-    });
-  }
-  acquireWasm(key, signal) {
-    const wasm = this.wasm;
-    const state = this.getState(key);
-    if (signal.aborted) return Promise.reject(abortError());
-    const subjectId = this.allocateSubjectId();
-    const decision = wasm.acquire(key, subjectId);
-    if (decision.kind === "run") {
-      state.running++;
-      state.acquired++;
-      return Promise.resolve(this.makeLease(state, decision.keyId));
-    }
-    if (decision.kind === "rejected") {
-      state.rejected++;
-      return Promise.reject(poolRejectedError(key, this.maxQueue));
-    }
-    return new Promise((resolve, reject) => {
-      const waiter = { signal, resolve, reject };
-      const removeWaiter = () => this.removeWaiter(state, waiter);
-      const cleanup = () => this.cleanupWaiter(waiter);
-      waiter.abort = () => {
-        cleanup();
-        removeWaiter();
-        wasm.cancel(decision.permitId);
-        this.wasmWaiters.delete(decision.permitId);
-        state.abortedWhileQueued++;
-        reject(abortError());
-      };
-      signal.addEventListener("abort", waiter.abort, { once: true });
-      state.queue.push(waiter);
-      this.wasmWaiters.set(decision.permitId, { waiter, state, keyId: decision.keyId });
-      this.scheduleWasmTimeoutPump();
-    });
-  }
-  getState(key) {
-    const k = key.trim().slice(0, 160) || "global";
-    const existing = this.states.get(k);
-    if (existing) return existing;
-    const created = {
-      key: k,
-      running: 0,
-      queue: [],
-      acquired: 0,
-      released: 0,
-      rejected: 0,
-      queueTimeouts: 0,
-      abortedWhileQueued: 0
-    };
-    this.states.set(k, created);
-    return created;
-  }
-  makeLease(state, wasmKeyId) {
-    let released = false;
-    return {
-      key: state.key,
-      release: () => {
-        if (released) return;
-        released = true;
-        if (state.running > 0) state.running--;
-        state.released++;
-        if (this.wasm && wasmKeyId !== void 0) {
-          this.handleWasmGrants(this.wasm.release(wasmKeyId));
-          this.scheduleWasmTimeoutPump();
-          return;
-        }
-        this.drain(state);
-      }
-    };
-  }
-  drain(state) {
-    while (state.running < this.concurrency && state.queue.length > 0) {
-      const waiter = state.queue.shift();
-      this.cleanupWaiter(waiter);
-      if (waiter.signal.aborted) {
-        state.abortedWhileQueued++;
-        waiter.reject(abortError());
-        continue;
-      }
-      state.running++;
-      state.acquired++;
-      waiter.resolve(this.makeLease(state));
-    }
-  }
-  handleWasmGrants(events) {
-    for (const event of events) {
-      const pending = this.wasmWaiters.get(event.permitId);
-      if (!pending) continue;
-      this.wasmWaiters.delete(event.permitId);
-      this.cleanupWaiter(pending.waiter);
-      this.removeWaiter(pending.state, pending.waiter);
-      if (pending.waiter.signal.aborted) {
-        pending.state.abortedWhileQueued++;
-        pending.waiter.reject(abortError());
-        continue;
-      }
-      pending.state.running++;
-      pending.state.acquired++;
-      pending.waiter.resolve(this.makeLease(pending.state, event.keyId));
-    }
-  }
-  handleWasmTimeouts(events) {
-    for (const event of events) {
-      const pending = this.wasmWaiters.get(event.permitId);
-      if (!pending) continue;
-      this.wasmWaiters.delete(event.permitId);
-      this.cleanupWaiter(pending.waiter);
-      this.removeWaiter(pending.state, pending.waiter);
-      pending.state.queueTimeouts++;
-      pending.waiter.reject(queueTimeoutError(pending.state.key, this.queueTimeoutMs ?? 0));
-    }
-  }
-  scheduleWasmTimeoutPump() {
-    if (!this.wasm) return;
-    if (this.wasmTimer !== void 0) clearTimeout(this.wasmTimer);
-    this.wasmTimer = void 0;
-    const next = this.wasm.nextDeadlineMs();
-    if (!Number.isFinite(next) || next < 0) return;
-    const delay = Math.max(0, Math.min(2 ** 31 - 1, Math.floor(next - Date.now())));
-    this.wasmTimer = setTimeout(() => {
-      this.wasmTimer = void 0;
-      if (!this.wasm) return;
-      this.handleWasmTimeouts(this.wasm.advanceTime());
-      this.scheduleWasmTimeoutPump();
-    }, delay);
-    if (typeof this.wasmTimer.unref === "function") this.wasmTimer.unref();
-  }
-  cleanupWaiter(waiter) {
-    if (waiter.timer !== void 0) {
-      clearTimeout(waiter.timer);
-      waiter.timer = void 0;
-    }
-    if (waiter.abort) {
-      waiter.signal.removeEventListener("abort", waiter.abort);
-      waiter.abort = void 0;
-    }
-  }
-  removeWaiter(state, waiter) {
-    const idx = state.queue.indexOf(waiter);
-    if (idx >= 0) state.queue.splice(idx, 1);
-  }
-  allocateSubjectId() {
-    const id = this.nextSubjectId >>> 0;
-    this.nextSubjectId = this.nextSubjectId + 1 >>> 0;
-    if (this.nextSubjectId === 0) this.nextSubjectId = 1;
-    return id === 0 ? this.allocateSubjectId() : id;
-  }
-};
-
-// src/http/client.ts
-var emptyStats = () => ({
-  inFlight: 0,
-  started: 0,
-  succeeded: 0,
-  failed: 0,
-  aborted: 0,
-  timedOut: 0,
-  poolRejected: 0,
-  poolTimeouts: 0
-});
-var decorate = (run, stats = emptyStats) => Object.assign(((req) => run(req)), {
-  with: (mw) => decorate(mw(run), stats),
-  stats
-});
-var withMiddleware = (mw) => (c) => decorate(mw(c), c.stats);
-var decorateStream = (run, stats = emptyStats) => Object.assign(((req) => run(req)), { stats });
-var isTaggedHttpError = (e) => {
-  if (typeof e !== "object" || e === null || !("_tag" in e)) return false;
-  const tag = e._tag;
-  return tag === "Abort" || tag === "BadUrl" || tag === "FetchError" || tag === "Timeout" || tag === "PoolRejected" || tag === "PoolTimeout";
-};
-var isAbortError = (e) => typeof e === "object" && e !== null && "name" in e && e.name === "AbortError";
-var normalizeHttpError = (e) => {
-  if (isTaggedHttpError(e)) return e;
-  if (isAbortError(e)) return { _tag: "Abort" };
-  return { _tag: "FetchError", message: String(e) };
-};
-var normalizeHeadersInit = (h) => {
-  if (!h) return void 0;
-  if (typeof Headers !== "undefined" && h instanceof Headers) {
-    const out = {};
-    h.forEach((v, k) => out[k] = v);
-    return out;
-  }
-  if (Array.isArray(h)) return Object.fromEntries(h);
-  if (typeof h === "object") return { ...h };
-  return void 0;
-};
-var normalizeRequest = (defaultHeaders) => (req0) => {
-  let req = Object.keys(defaultHeaders).length ? mergeHeadersUnder(defaultHeaders)(req0) : req0;
-  const initHeaders = normalizeHeadersInit(req0.init?.headers);
-  if (initHeaders && Object.keys(initHeaders).length) {
-    req = mergeHeadersUnder(initHeaders)(req);
-  }
-  return req;
-};
-var resolvePositiveTimeout = (value) => {
-  if (value === void 0 || !Number.isFinite(value)) return void 0;
-  const n = Math.floor(value);
-  return n > 0 ? n : void 0;
-};
-var makeHttpStats = (pool) => {
-  const stats = {
-    inFlight: 0,
-    started: 0,
-    succeeded: 0,
-    failed: 0,
-    aborted: 0,
-    timedOut: 0,
-    poolRejected: 0,
-    poolTimeouts: 0
-  };
-  const onStart = () => {
-    stats.inFlight++;
-    stats.started++;
-  };
-  const onFinish = (finish) => {
-    if (stats.inFlight > 0) stats.inFlight--;
-    stats.lastDurationMs = finish.durationMs;
-    if (finish.outcome === "success") {
-      stats.succeeded++;
-      return;
-    }
-    if (finish.outcome === "interrupt") {
-      stats.aborted++;
-      return;
-    }
-    if (finish.outcome === "timeout") {
-      stats.timedOut++;
-      return;
-    }
-    const err = normalizeHttpError(finish.error);
-    switch (err._tag) {
-      case "Abort":
-        stats.aborted++;
-        return;
-      case "Timeout":
-        stats.timedOut++;
-        return;
-      case "PoolRejected":
-        stats.poolRejected++;
-        stats.failed++;
-        return;
-      case "PoolTimeout":
-        stats.poolTimeouts++;
-        stats.failed++;
-        return;
-      default:
-        stats.failed++;
-        return;
-    }
-  };
-  const snapshot = () => ({
-    ...stats,
-    ...pool ? { pool: pool.stats() } : {}
-  });
-  return { onStart, onFinish, snapshot };
-};
-var makePool = (cfg) => cfg.pool === void 0 || cfg.pool === false ? void 0 : new HttpConcurrencyPool(cfg.pool);
-var resolveRequestUrl = (req, baseUrl) => {
-  try {
-    return new URL(req.url, baseUrl);
-  } catch {
-    return { _tag: "BadUrl", message: `URL inv\xE1lida: ${req.url}` };
-  }
-};
-var headersOf = (res) => {
-  const headers = {};
-  res.headers.forEach((v, k) => headers[k] = v);
-  return headers;
-};
-var fetchLabel = (req, url) => `http:${req.method}:${url.origin}`;
-var timeoutReason = (req, url, timeoutMs) => ({
-  _tag: "Timeout",
-  timeoutMs,
-  phase: "request",
-  message: `HTTP ${req.method} ${url.origin} timed out after ${timeoutMs}ms`
-});
-var linkAbortSignals = (runtimeSignal, requestSignal) => {
-  if (!requestSignal) return { signal: runtimeSignal, cleanup: () => void 0 };
-  const controller = new AbortController();
-  const abort = (source) => {
-    try {
-      controller.abort(source.reason);
-    } catch {
-      controller.abort();
-    }
-  };
-  const abortFromRuntime = () => abort(runtimeSignal);
-  const abortFromRequest = () => abort(requestSignal);
-  if (runtimeSignal.aborted) abortFromRuntime();
-  else runtimeSignal.addEventListener("abort", abortFromRuntime, { once: true });
-  if (requestSignal.aborted) abortFromRequest();
-  else requestSignal.addEventListener("abort", abortFromRequest, { once: true });
-  return {
-    signal: controller.signal,
-    cleanup: () => {
-      runtimeSignal.removeEventListener("abort", abortFromRuntime);
-      requestSignal.removeEventListener("abort", abortFromRequest);
-    }
-  };
-};
-function makeHttpStream(cfg = {}) {
-  const baseUrl = cfg.baseUrl ?? "";
-  const defaultHeaders = cfg.headers ?? {};
-  const normalize = normalizeRequest(defaultHeaders);
-  const pool = makePool(cfg);
-  const metrics = makeHttpStats(pool);
-  const run = (req0) => {
-    const req = normalize(req0);
-    const url = resolveRequestUrl(req, baseUrl);
-    if (!(url instanceof URL)) return asyncFail(url);
-    const timeoutMs = resolvePositiveTimeout(req.timeoutMs ?? cfg.timeoutMs);
-    return fromPromiseAbortable(
-      async (signal) => {
-        let lease;
-        const linkedSignal = linkAbortSignals(signal, req.init?.signal);
-        let cleanupTransferredToBody = false;
-        try {
-          if (pool) {
-            const key = resolveHttpPoolKey(pool.keyResolver, req, url);
-            lease = await pool.acquire(key, linkedSignal.signal);
-          }
-          const started = performance.now();
-          const res = await fetch(url, {
-            ...req.init ?? {},
-            method: req.method,
-            headers: Request.headers.get(req),
-            body: req.body,
-            signal: linkedSignal.signal
-          });
-          const headers = headersOf(res);
-          const body = streamFromReadableStream(res.body, normalizeHttpError, {
-            signal: linkedSignal.signal,
-            onRelease: linkedSignal.cleanup
-          });
-          cleanupTransferredToBody = res.body !== null;
-          lease?.release();
-          lease = void 0;
-          return {
-            status: res.status,
-            statusText: res.statusText,
-            headers,
-            body,
-            ms: Math.round(performance.now() - started)
-          };
-        } finally {
-          if (!cleanupTransferredToBody) {
-            linkedSignal.cleanup();
-          }
-          lease?.release();
-        }
-      },
-      normalizeHttpError,
-      {
-        label: fetchLabel(req, url),
-        timeoutMs,
-        timeoutReason: timeoutMs ? () => timeoutReason(req, url, timeoutMs) : void 0,
-        onStart: metrics.onStart,
-        onFinish: metrics.onFinish
-      }
-    );
-  };
-  return decorateStream(run, metrics.snapshot);
-}
-function makeHttp(cfg = {}) {
-  const baseUrl = cfg.baseUrl ?? "";
-  const defaultHeaders = cfg.headers ?? {};
-  const normalize = normalizeRequest(defaultHeaders);
-  const pool = makePool(cfg);
-  const metrics = makeHttpStats(pool);
-  const run = (req0) => {
-    const req = normalize(req0);
-    const url = resolveRequestUrl(req, baseUrl);
-    if (!(url instanceof URL)) return asyncFail(url);
-    const timeoutMs = resolvePositiveTimeout(req.timeoutMs ?? cfg.timeoutMs);
-    return fromPromiseAbortable(
-      async (signal) => {
-        let lease;
-        const linkedSignal = linkAbortSignals(signal, req.init?.signal);
-        try {
-          if (pool) {
-            const key = resolveHttpPoolKey(pool.keyResolver, req, url);
-            lease = await pool.acquire(key, linkedSignal.signal);
-          }
-          const started = performance.now();
-          const res = await fetch(url, {
-            ...req.init ?? {},
-            method: req.method,
-            headers: Request.headers.get(req),
-            body: req.body,
-            signal: linkedSignal.signal
-          });
-          const bodyText = await res.text();
-          const headers = headersOf(res);
-          return {
-            status: res.status,
-            statusText: res.statusText,
-            headers,
-            bodyText,
-            ms: Math.round(performance.now() - started)
-          };
-        } finally {
-          linkedSignal.cleanup();
-          lease?.release();
-        }
-      },
-      normalizeHttpError,
-      {
-        label: fetchLabel(req, url),
-        timeoutMs,
-        timeoutReason: timeoutMs ? () => timeoutReason(req, url, timeoutMs) : void 0,
-        onStart: metrics.onStart,
-        onFinish: metrics.onFinish
-      }
-    );
-  };
-  return decorate(run, metrics.snapshot);
-}
-var withRetryStream = (p) => (next) => {
-  const retryOnStatus = p.retryOnStatus ?? defaultRetryOnStatus;
-  const retryOnError = p.retryOnError ?? defaultRetryOnError;
-  const retryOnMethods = p.retryOnMethods ?? defaultRetryableMethods;
-  const maxElapsedMs = normalizeRetryBudget(p.maxElapsedMs);
-  const run = (req) => {
-    if (!retryOnMethods.includes(req.method)) return next(req);
-    const startedAt = performance.now();
-    const remainingBudget = () => maxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : maxElapsedMs - (performance.now() - startedAt);
-    const delayWithinBudget = (delayMs) => Math.max(0, Math.min(delayMs, remainingBudget()));
-    const loop = (attempt) => asyncFold(
-      next(req),
-      (e) => {
-        if (e._tag === "Abort" || e._tag === "BadUrl" || e._tag === "PoolRejected") return asyncFail(e);
-        const canRetry = attempt < p.maxRetries && retryOnError(e) && remainingBudget() > 0;
-        if (!canRetry) return asyncFail(e);
-        const d = delayWithinBudget(backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs));
-        if (d <= 0 && maxElapsedMs !== void 0) return asyncFail(e);
-        p.onRetry?.({
-          attempt,
-          delayMs: d,
-          error: e,
-          status: void 0,
-          url: req.url,
-          method: req.method,
-          timestamp: Date.now()
-        });
-        return asyncFlatMap(sleep(d), () => loop(attempt + 1));
-      },
-      (w) => {
-        const canRetry = attempt < p.maxRetries && retryOnStatus(w.status) && remainingBudget() > 0;
-        if (!canRetry) return asyncSucceed(w);
-        const ra = p.respectRetryAfter === false ? void 0 : retryAfterMs(w.headers);
-        const rawDelay = ra === void 0 ? backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs) : Math.min(ra, p.maxDelayMs);
-        const d = delayWithinBudget(rawDelay);
-        if (d <= 0 && maxElapsedMs !== void 0) return asyncSucceed(w);
-        p.onRetry?.({
-          attempt,
-          delayMs: d,
-          error: void 0,
-          status: w.status,
-          url: req.url,
-          method: req.method,
-          timestamp: Date.now()
-        });
-        return asyncFlatMap(sleep(d), () => loop(attempt + 1));
-      }
-    );
-    return loop(0);
-  };
-  return decorateStream(run, next.stats);
-};
+} from "../chunk-UB4B6OFY.js";
+import {
+  ConfigValidationError,
+  Schema,
+  SchemaValidationException,
+  formatConfigError,
+  formatIssues,
+  isConfigValidationError,
+  isSchema,
+  makeSchemaIssue,
+  parseConfig,
+  s,
+  schema,
+  validateValue
+} from "../chunk-C3MDXTRZ.js";
+import "../chunk-3RG5ZIWI.js";
 
 // src/http/httpClient.ts
 var resolveFinalUrl = (baseUrl, url) => {
@@ -945,43 +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, ...rest } = init ?? {};
-    return {
-      headers: normalizeHeadersInit(headers),
-      timeoutMs: typeof timeoutMs === "number" ? timeoutMs : void 0,
-      poolKey: typeof poolKey === "string" ? poolKey : void 0,
-      init: rest
-    };
-  };
-  const applyInitHeaders = (headers) => (req) => headers ? mergeHeaders(headers)(req) : req;
-  const buildReq = (method, url, init, body) => {
-    const s = splitInit(init);
-    const req = {
-      method,
-      url,
-      ...body && body.length > 0 ? { body } : {},
-      ...s.timeoutMs !== void 0 ? { timeoutMs: s.timeoutMs } : {},
-      ...s.poolKey !== void 0 ? { poolKey: s.poolKey } : {},
-      init: s.init
-    };
-    return applyInitHeaders(s.headers)(req);
-  };
   const toResponse = (w, body) => ({
     status: w.status,
     statusText: w.statusText,
     headers: w.headers,
     body
   });
+  const decodeResponse = (w, validator, schemaName) => asyncFlatMap(
+    decodeJsonBodyEffect(w.bodyText, validator, { schemaName }),
+    (body) => asyncSucceed(toResponse(w, body))
+  );
   return {
     cfg,
     wire,
     withPromise,
     requestRaw,
-    splitInit,
-    applyInitHeaders,
-    buildReq,
-    toResponse
+    buildReq: buildHttpRequest,
+    toResponse,
+    decodeResponse
   };
 };
 function httpClient(cfg = {}) {
@@ -995,20 +190,25 @@ function httpClient(cfg = {}) {
       const req = core.buildReq("GET", url, init);
       return core.withPromise(mapTryAsync(requestRaw(req), (w) => core.toResponse(w, w.bodyText)));
     };
-    const getJson = (url, init) => {
+    const getJson = ((url, init) => {
       const base = core.buildReq("GET", url, init);
       const req = setHeaderIfMissing("accept", "application/json")(base);
-      return core.withPromise(mapTryAsync(requestRaw(req), (w) => core.toResponse(w, JSON.parse(w.bodyText))));
-    };
-    const postJson = (url, bodyObj, init) => {
-      const base = core.buildReq("POST", url, init, JSON.stringify(bodyObj ?? {}));
-      const req = setHeaderIfMissing("content-type", "application/json")(
-        setHeaderIfMissing("accept", "application/json")(base)
-      );
+      return core.withPromise(asyncFlatMap(requestRaw(req), (w) => core.decodeResponse(w, init?.schema, init?.schemaName)));
+    });
+    const postJson = ((url, bodyObj, init) => {
       return core.withPromise(
-        mapTryAsync(requestRaw(req), (w) => core.toResponse(w, JSON.parse(w.bodyText)))
+        asyncFlatMap(
+          encodeJsonBodyEffect(bodyObj, init?.bodySchema, { schemaName: init?.bodySchemaName }),
+          (bodyText) => {
+            const base = core.buildReq("POST", url, init, bodyText);
+            const req = setHeaderIfMissing("content-type", "application/json")(
+              setHeaderIfMissing("accept", "application/json")(base)
+            );
+            return asyncFlatMap(requestRaw(req), (w) => core.decodeResponse(w, init?.schema, init?.schemaName));
+          }
+        )
       );
-    };
+    });
     return {
       request,
       get,
@@ -1050,17 +250,28 @@ function httpClientWithMeta(cfg = {}) {
     return request(req);
   };
   const postJson = (url, bodyObj, init) => {
-    const base = core.buildReq("POST", url, init, JSON.stringify(bodyObj ?? {}));
-    const req = setHeaderIfMissing("content-type", "application/json")(
-      setHeaderIfMissing("accept", "application/json")(base)
-    );
     const startedAt = Date.now();
     return core.withPromise(
-      mapTryAsync(core.requestRaw(req), (w) => ({
-        wire: w,
-        response: core.toResponse(w, JSON.parse(w.bodyText)),
-        meta: mkMeta(req, w, startedAt)
-      }))
+      asyncFlatMap(
+        encodeJsonBodyEffect(bodyObj, init?.bodySchema, { schemaName: init?.bodySchemaName }),
+        (bodyText) => {
+          const base = core.buildReq("POST", url, init, bodyText);
+          const req = setHeaderIfMissing("content-type", "application/json")(
+            setHeaderIfMissing("accept", "application/json")(base)
+          );
+          return asyncFlatMap(
+            core.requestRaw(req),
+            (w) => asyncFlatMap(
+              core.decodeResponse(w, init?.schema, init?.schemaName),
+              (response) => asyncSucceed({
+                wire: w,
+                response,
+                meta: mkMeta(req, w, startedAt)
+              })
+            )
+          );
+        }
+      )
     );
   };
   const getText = (url, init) => {
@@ -1079,11 +290,17 @@ function httpClientWithMeta(cfg = {}) {
     const req = setHeaderIfMissing("accept", "application/json")(base);
     const startedAt = Date.now();
     return core.withPromise(
-      mapTryAsync(core.requestRaw(req), (w) => ({
-        wire: w,
-        response: core.toResponse(w, JSON.parse(w.bodyText)),
-        meta: mkMeta(req, w, startedAt)
-      }))
+      asyncFlatMap(
+        core.requestRaw(req),
+        (w) => asyncFlatMap(
+          core.decodeResponse(w, init?.schema, init?.schemaName),
+          (response) => asyncSucceed({
+            wire: w,
+            response,
+            meta: mkMeta(req, w, startedAt)
+          })
+        )
+      )
     );
   };
   return {
@@ -1124,137 +341,77 @@ function httpClientStream(cfg = {}) {
   return make(wire);
 }
 
-// src/http/effectRunner.ts
-function registerHttpEffect(effect, env, cb) {
-  let done = false;
-  let currentCancel;
-  const finish = (exit) => {
-    if (done) return;
-    done = true;
-    currentCancel = void 0;
-    cb(exit);
-  };
-  const run = (current, cont) => {
-    if (done) return;
-    switch (current._tag) {
-      case "Succeed":
-        cont({ _tag: "Success", value: current.value });
-        return;
-      case "Fail":
-        cont({ _tag: "Failure", cause: Cause.fail(current.error) });
-        return;
-      case "Sync":
-        try {
-          cont({ _tag: "Success", value: current.thunk(env) });
-        } catch (e) {
-          cont({ _tag: "Failure", cause: Cause.die(e) });
-        }
-        return;
-      case "Async": {
-        const cancel = current.register(env, (exit) => {
-          currentCancel = void 0;
-          if (done) return;
-          cont(exit);
-        });
-        currentCancel = typeof cancel === "function" ? cancel : void 0;
-        return;
-      }
-      case "FlatMap":
-        run(current.first, (exit) => {
-          if (done) return;
-          if (exit._tag === "Failure") {
-            cont(exit);
-            return;
-          }
-          try {
-            run(current.andThen(exit.value), cont);
-          } catch (e) {
-            cont({ _tag: "Failure", cause: Cause.die(e) });
-          }
-        });
-        return;
-      case "Fold":
-        run(current.first, (exit) => {
-          if (done) return;
-          try {
-            if (exit._tag === "Success") {
-              run(current.onSuccess(exit.value), cont);
-              return;
-            }
-            if (exit.cause._tag === "Fail") {
-              run(current.onFailure(exit.cause.error), cont);
-              return;
-            }
-            cont(exit);
-          } catch (e) {
-            cont({ _tag: "Failure", cause: Cause.die(e) });
-          }
-        });
-        return;
-      case "Fork":
-        cont({ _tag: "Success", value: void 0 });
-        return;
-    }
-  };
-  run(effect, finish);
-  return () => {
-    if (done) return;
-    const cancel = currentCancel;
-    currentCancel = void 0;
-    done = true;
-    try {
-      cancel?.();
-    } finally {
-      cb({ _tag: "Failure", cause: Cause.interrupt() });
-    }
-  };
-}
-
 // src/http/circuitBreaker.ts
 function withCircuitBreaker(config = {}) {
   if (config.perOrigin) {
     const breakers = /* @__PURE__ */ new Map();
-    const getBreaker = (url) => {
+    const getBreaker = (url, onOpen) => {
       try {
         const origin = new URL(url).origin;
         if (!breakers.has(origin)) {
-          breakers.set(origin, makeCircuitBreaker(config));
+          breakers.set(origin, makeCircuitBreaker({
+            ...config,
+            onStateChange: (from, to) => {
+              config.onStateChange?.(from, to);
+              if (to === "open") onOpen();
+            }
+          }));
         }
         return breakers.get(origin);
       } catch {
         if (!breakers.has("__global__")) {
-          breakers.set("__global__", makeCircuitBreaker(config));
+          breakers.set("__global__", makeCircuitBreaker({
+            ...config,
+            onStateChange: (from, to) => {
+              config.onStateChange?.(from, to);
+              if (to === "open") onOpen();
+            }
+          }));
         }
         return breakers.get("__global__");
       }
     };
     return (next) => (req) => {
-      const breaker2 = getBreaker(req.url);
-      return protectLazy(breaker2, 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) => {
-    return protectLazy(breaker, 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) {
+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, cb);
+        cancel = registerHttpEffect(breaker.protect(deferred), env, finish);
       } catch (error) {
         cb({
           _tag: "Failure",
@@ -1268,6 +425,23 @@ function protectLazy(breaker, next, req) {
     }
   };
 }
+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) {
@@ -1284,1779 +458,72 @@ function withTracing(tracer) {
   };
 }
 
-// src/http/validation.ts
-function validatedJson(client, validator) {
-  return (req) => asyncFold(
-    client(req),
-    (error) => asyncFail(error),
-    (response) => {
-      try {
-        const parsed = JSON.parse(response.bodyText);
-        const result = validator(parsed);
-        if (result.success) {
-          return asyncSucceed(result.data);
-        }
-        return asyncFail({
-          _tag: "ValidationError",
-          message: result.error,
-          body: response.bodyText
-        });
-      } catch (e) {
-        return asyncFail({
-          _tag: "ValidationError",
-          message: `JSON parse error: ${String(e)}`,
-          body: response.bodyText
-        });
-      }
-    }
-  );
-}
-
-// src/http/body.ts
-function httpBodyByteLength(body) {
-  if (body === void 0) return 0;
-  if (typeof body === "string") return Buffer.byteLength(body, "utf8");
-  if (body instanceof ArrayBuffer) return body.byteLength;
-  return body.byteLength;
-}
-function httpBodyToBuffer(body) {
-  if (typeof body === "string") return Buffer.from(body, "utf8");
-  if (body instanceof ArrayBuffer) return Buffer.from(body);
-  return Buffer.from(body);
-}
-function httpBodyKeyPart(body) {
-  if (body === void 0) return "";
-  if (typeof body === "string") return body;
-  return `base64:${httpBodyToBuffer(body).toString("base64")}`;
-}
-
-// src/http/lifecycle/cacheKey.ts
-var SEPARATOR = "\0";
-var DEFAULT_CACHE_RELEVANT_HEADERS = ["accept", "authorization", "content-type"];
-function computeCacheKey(req, baseUrl, extraHeaders = []) {
-  const method = req.method.toUpperCase();
-  const resolvedUrl = new URL(req.url, baseUrl || void 0).toString();
-  const relevantSet = /* @__PURE__ */ new Set([
-    ...DEFAULT_CACHE_RELEVANT_HEADERS,
-    ...extraHeaders.map((h) => h.toLowerCase())
-  ]);
-  const headers = req.headers ?? {};
-  const sortedHeaders = Object.keys(headers).filter((k) => relevantSet.has(k.toLowerCase())).sort().map((k) => `${k.toLowerCase()}:${headers[k]}`).join(",");
-  const body = httpBodyKeyPart(req.body);
-  return `${method}${SEPARATOR}${resolvedUrl}${SEPARATOR}${sortedHeaders}${SEPARATOR}${body}`;
-}
-function parseCacheKey(key) {
-  const [method, resolvedUrl, headersStr, ...bodyParts] = key.split(SEPARATOR);
-  const body = bodyParts.join(SEPARATOR);
-  const headers = {};
-  if (headersStr) {
-    for (const entry of headersStr.split(",")) {
-      const colonIdx = entry.indexOf(":");
-      if (colonIdx > 0) {
-        headers[entry.slice(0, colonIdx)] = entry.slice(colonIdx + 1);
-      }
-    }
-  }
-  return { method, resolvedUrl, headers, body };
-}
-
-// src/http/lifecycle/dedupKey.ts
-var HOP_BY_HOP = /* @__PURE__ */ new Set([
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade"
-]);
-var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
-function computeDedupKey(req, baseUrl) {
-  const method = req.method.toUpperCase();
-  const resolvedUrl = new URL(req.url, baseUrl || void 0).toString();
-  const headers = req.headers ?? {};
-  const sortedHeaders = Object.keys(headers).filter((k) => {
-    const lower = k.toLowerCase();
-    return !HOP_BY_HOP.has(lower) && lower !== "authorization";
-  }).sort().map((k) => `${k.toLowerCase()}:${headers[k]}`).join(",");
-  const body = httpBodyKeyPart(req.body);
-  return `${method}${SEPARATOR}${resolvedUrl}${SEPARATOR}${sortedHeaders}${SEPARATOR}${body}`;
-}
-
-// src/http/lifecycle/dedup.ts
-function safeEmit(onEvent, event) {
-  if (!onEvent) return;
-  try {
-    onEvent(event);
-  } catch {
-  }
-}
-function withDedup(config) {
-  const inFlight = /* @__PURE__ */ new Map();
-  const customKeyFn = config?.dedupKey;
-  const onEvent = config?.onEvent;
-  return (next) => {
-    return (req) => {
-      if (!SAFE_METHODS.has(req.method.toUpperCase())) {
-        return next(req);
-      }
-      let key;
-      if (customKeyFn) {
-        try {
-          key = customKeyFn(req);
-        } catch {
-          return next(req);
-        }
-        if (!key) {
-          return next(req);
-        }
-      } else {
-        key = computeDedupKey(req, "");
-      }
-      return {
-        _tag: "Async",
-        register: (_env, cb) => {
-          const existing = inFlight.get(key);
-          let callerDone = false;
-          const finishCaller = (exit) => {
-            if (callerDone) return;
-            callerDone = true;
-            cb(exit);
-          };
-          if (existing) {
-            safeEmit(onEvent, { type: "dedup-hit", cacheKey: key });
-            existing.refCount++;
-            const waiter = {
-              resolve: (res) => {
-                finishCaller({ _tag: "Success", value: res });
-              },
-              reject: (err) => {
-                finishCaller({ _tag: "Failure", cause: Cause.fail(err) });
-              }
-            };
-            existing.waiters.push(waiter);
-            return () => {
-              if (callerDone) return;
-              existing.refCount--;
-              const idx = existing.waiters.indexOf(waiter);
-              if (idx >= 0) {
-                existing.waiters.splice(idx, 1);
-              }
-              if (existing.refCount <= 0) {
-                inFlight.delete(key);
-                safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
-                existing.controller.abort();
-              }
-              finishCaller({ _tag: "Failure", cause: Cause.interrupt() });
-            };
-          }
-          safeEmit(onEvent, { type: "dedup-miss", cacheKey: key });
-          const controller = new AbortController();
-          const entry = {
-            key,
-            controller,
-            refCount: 1,
-            waiters: []
-          };
-          inFlight.set(key, entry);
-          safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
-          const dedupReq = {
-            ...req,
-            init: {
-              ...req.init ?? {},
-              signal: controller.signal
-            }
-          };
-          const innerEffect = next(dedupReq);
-          const innerCancel = registerHttpEffect(innerEffect, _env, (exit) => {
-            inFlight.delete(key);
-            safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
-            if (exit._tag === "Success") {
-              resolveAll(entry, exit.value);
-              finishCaller(exit);
-              return;
-            }
-            if (exit.cause._tag === "Interrupt") {
-              rejectAll(entry, { _tag: "Abort" });
-              finishCaller({ _tag: "Failure", cause: Cause.interrupt() });
-              return;
-            }
-            if (exit.cause._tag === "Fail") {
-              rejectAll(entry, exit.cause.error);
-              finishCaller(exit);
-              return;
-            }
-            const err = { _tag: "FetchError", message: String(exit.cause.defect ?? "unknown") };
-            rejectAll(entry, err);
-            finishCaller({ _tag: "Failure", cause: Cause.fail(err) });
-          });
-          return () => {
-            if (callerDone) return;
-            entry.refCount--;
-            if (entry.refCount <= 0) {
-              inFlight.delete(key);
-              safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
-              controller.abort();
-              if (innerCancel) {
-                innerCancel();
-              }
-            }
-            finishCaller({ _tag: "Failure", cause: Cause.interrupt() });
-          };
-        }
-      };
-    };
-  };
-}
-function resolveAll(entry, res) {
-  const waiters = entry.waiters.slice();
-  for (const w of waiters) {
-    w.resolve(res);
-  }
-}
-function rejectAll(entry, err) {
-  const waiters = entry.waiters.slice();
-  for (const w of waiters) {
-    w.reject(err);
-  }
-}
-
-// src/http/lifecycle/timing.ts
-var now = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
-
-// src/http/lifecycle/lruCache.ts
-function isExpired(node) {
-  return now() - node.storedAt >= node.ttlMs;
-}
-var LRUCache = class {
-  map = /* @__PURE__ */ new Map();
-  head = null;
-  tail = null;
-  maxEntries;
-  onEvict;
-  /**
-   * Creates a new LRU cache instance.
-   *
-   * @param config - Cache configuration options.
-   * @param config.maxEntries - Maximum number of entries. Must be >= 1. Default: 1024.
-   * @param config.onEvict - Optional eviction callback.
-   *
-   * @example
-   * ```typescript
-   * import { LRUCache } from "./lruCache";
-   *
-   * const cache = new LRUCache<number>({ maxEntries: 50 });
-   * ```
-   */
-  constructor(config = {}) {
-    const max = config.maxEntries ?? 1024;
-    this.maxEntries = Math.max(1, Math.floor(max));
-    this.onEvict = config.onEvict;
-  }
-  /**
-   * Returns the number of entries currently in the cache.
-   *
-   * @returns The current entry count.
-   *
-   * @example
-   * ```typescript
-   * import { LRUCache } from "./lruCache";
-   *
-   * const cache = new LRUCache<string>();
-   * cache.set("a", "1", 10_000);
-   * console.log(cache.size); // 1
-   * ```
-   */
-  get size() {
-    return this.map.size;
-  }
-  /**
-   * Retrieves a value by key.
-   *
-   * Returns `undefined` if the key is not found or the entry has expired.
-   * On a hit (non-expired), the entry is moved to the head (most recently used).
-   * Expired entries are lazily removed on access.
-   *
-   * @param key - The cache key to look up.
-   * @returns The cached value, or `undefined` if not found or expired.
-   *
-   * @example
-   * ```typescript
-   * import { LRUCache } from "./lruCache";
-   *
-   * const cache = new LRUCache<string>();
-   * cache.set("greeting", "hello", 30_000);
-   * const val = cache.get("greeting"); // "hello"
-   * const miss = cache.get("unknown"); // undefined
-   * ```
-   */
-  get(key) {
-    const node = this.map.get(key);
-    if (!node) return void 0;
-    if (isExpired(node)) {
-      this.removeNode(node);
-      this.map.delete(key);
-      return void 0;
-    }
-    this.moveToHead(node);
-    return node.value;
-  }
-  /**
-   * Inserts or updates an entry in the cache.
-   *
-   * If the key already exists, the value and TTL are updated and the entry is
-   * moved to the head. If inserting a new entry causes the cache to exceed
-   * `maxEntries` (must be >= 1), the least recently used entry is evicted.
-   *
-   * @param key - The cache key.
-   * @param value - The value to store.
-   * @param ttlMs - Time-to-live in milliseconds. The entry expires after this duration.
-   *
-   * @example
-   * ```typescript
-   * import { LRUCache } from "./lruCache";
-   *
-   * const cache = new LRUCache<string>({ maxEntries: 2 });
-   * cache.set("a", "alpha", 60_000);
-   * cache.set("b", "beta", 60_000);
-   * cache.set("c", "gamma", 60_000); // evicts "a" (LRU)
-   * ```
-   */
-  set(key, value, ttlMs) {
-    const existing = this.map.get(key);
-    if (existing) {
-      existing.value = value;
-      existing.storedAt = now();
-      existing.ttlMs = ttlMs;
-      this.moveToHead(existing);
-      return;
-    }
-    const node = {
-      key,
-      value,
-      storedAt: now(),
-      ttlMs,
-      prev: null,
-      next: null
-    };
-    this.map.set(key, node);
-    this.addToHead(node);
-    if (this.map.size > this.maxEntries) {
-      this.evictTail();
-    }
-  }
-  /**
-   * Removes an entry by key.
-   *
-   * @param key - The cache key to remove.
-   * @returns `true` if the entry was found and removed, `false` otherwise.
-   *
-   * @example
-   * ```typescript
-   * import { LRUCache } from "./lruCache";
-   *
-   * const cache = new LRUCache<string>();
-   * cache.set("x", "value", 10_000);
-   * cache.delete("x"); // true
-   * cache.delete("x"); // false (already removed)
-   * ```
-   */
-  delete(key) {
-    const node = this.map.get(key);
-    if (!node) return false;
-    this.removeNode(node);
-    this.map.delete(key);
-    return true;
-  }
-  /**
-   * Removes all entries from the cache, resetting it to an empty state.
-   *
-   * @example
-   * ```typescript
-   * import { LRUCache } from "./lruCache";
-   *
-   * const cache = new LRUCache<string>();
-   * cache.set("a", "1", 10_000);
-   * cache.clear();
-   * console.log(cache.size); // 0
-   * ```
-   */
-  clear() {
-    this.map.clear();
-    this.head = null;
-    this.tail = null;
-  }
-  // --- Doubly-linked list operations ---
-  /** Adds a node to the head of the list (most recently used position). */
-  addToHead(node) {
-    node.prev = null;
-    node.next = this.head;
-    if (this.head) {
-      this.head.prev = node;
-    }
-    this.head = node;
-    if (!this.tail) {
-      this.tail = node;
-    }
-  }
-  /** Removes a node from its current position in the list. */
-  removeNode(node) {
-    if (node.prev) {
-      node.prev.next = node.next;
-    } else {
-      this.head = node.next;
-    }
-    if (node.next) {
-      node.next.prev = node.prev;
-    } else {
-      this.tail = node.prev;
-    }
-    node.prev = null;
-    node.next = null;
-  }
-  /** Moves an existing node to the head of the list. */
-  moveToHead(node) {
-    if (this.head === node) return;
-    this.removeNode(node);
-    this.addToHead(node);
-  }
-  /** Evicts the tail node (least recently used) and notifies via callback. */
-  evictTail() {
-    if (!this.tail) return;
-    const evicted = this.tail;
-    this.removeNode(evicted);
-    this.map.delete(evicted.key);
-    if (this.onEvict) {
-      this.onEvict(1);
-    }
-  }
-};
-
-// src/http/lifecycle/responseCache.ts
-function clamp2(n, min, max) {
-  return Math.max(min, Math.min(max, n));
-}
-function safeEmit2(onEvent, event) {
-  if (!onEvent) return;
-  try {
-    onEvent(event);
-  } catch {
-  }
-}
-function withCache(config) {
-  const ttlSeconds = clamp2(config?.ttlSeconds ?? 60, 1, 86400);
-  const ttlMs = ttlSeconds * 1e3;
-  const maxEntries = Math.max(1, Math.floor(config?.maxEntries ?? 1024));
-  const staleWhileRevalidate = config?.staleWhileRevalidate ?? false;
-  const cachePolicy = config?.cachePolicy;
-  const cacheRelevantHeaders = config?.cacheRelevantHeaders ?? [];
-  const baseUrl = config?.baseUrl ?? "";
-  const onEvent = config?.onEvent;
-  const onLifecycleEvent = config?.onLifecycleEvent;
-  const cache = new LRUCache({
-    maxEntries,
-    onEvict: (count) => onLifecycleEvent?.({ type: "cache-eviction", count })
-  });
-  const revalidating = /* @__PURE__ */ new Set();
-  const invalidate = (key) => {
-    cache.delete(key);
-  };
-  const clear = () => {
-    cache.clear();
-  };
-  const middleware = (next) => {
-    return (req) => {
-      const method = req.method.toUpperCase();
-      if (!SAFE_METHODS.has(method) && !cachePolicy) {
-        return next(req);
-      }
-      const key = computeCacheKey(req, baseUrl, cacheRelevantHeaders);
-      return {
-        _tag: "Async",
-        register: (env, cb) => {
-          const cached = cache.get(key);
-          if (cached !== void 0) {
-            onLifecycleEvent?.({ type: "cache-hit", cacheKey: key });
-            cb({ _tag: "Success", value: cached });
-            return;
-          }
-          onLifecycleEvent?.({ type: "cache-miss", cacheKey: key });
-          const innerEffect = next(req);
-          return registerHttpEffect(innerEffect, env, (exit) => {
-            if (exit._tag === "Success") {
-              storeIfCacheable(req, exit.value, key);
-            }
-            cb(exit);
-          });
-        }
-      };
-    };
-  };
-  function storeIfCacheable(req, res, key) {
-    const method = req.method.toUpperCase();
-    if (cachePolicy) {
-      const result = cachePolicy(req, res);
-      if (!result.cacheable) return;
-      const entryTtlMs = result.ttlSeconds !== void 0 ? clamp2(result.ttlSeconds, 1, 86400) * 1e3 : ttlMs;
-      cache.set(key, res, entryTtlMs);
-      return;
-    }
-    if (!SAFE_METHODS.has(method)) return;
-    cache.set(key, res, ttlMs);
-  }
-  function triggerRevalidation(next, req, key) {
-    if (revalidating.has(key)) return;
-    revalidating.add(key);
-    const innerEffect = next(req);
-    const handleExit = (exit) => {
-      revalidating.delete(key);
-      if (exit._tag === "Success") {
-        storeIfCacheable(req, exit.value, key);
-      } else {
-        safeEmit2(onEvent, {
-          type: "revalidation-failure",
-          cacheKey: key,
-          error: exit.cause._tag === "Fail" ? exit.cause.error : void 0
-        });
-      }
-    };
-    registerHttpEffect(innerEffect, void 0, handleExit);
-  }
-  const expirationMap = /* @__PURE__ */ new Map();
-  const swrMiddleware = (next) => {
-    return (req) => {
-      const method = req.method.toUpperCase();
-      if (!SAFE_METHODS.has(method) && !cachePolicy) {
-        return next(req);
-      }
-      const key = computeCacheKey(req, baseUrl, cacheRelevantHeaders);
-      return {
-        _tag: "Async",
-        register: (env, cb) => {
-          const cached = cache.get(key);
-          if (cached !== void 0) {
-            const expiresAt = expirationMap.get(key);
-            if (expiresAt !== void 0 && now() < expiresAt) {
-              onLifecycleEvent?.({ type: "cache-hit", cacheKey: key });
-              cb({ _tag: "Success", value: cached });
-              return;
-            }
-            onLifecycleEvent?.({ type: "cache-hit", cacheKey: key });
-            cb({ _tag: "Success", value: cached });
-            triggerRevalidation(next, req, key);
-            return;
-          }
-          onLifecycleEvent?.({ type: "cache-miss", cacheKey: key });
-          const innerEffect = next(req);
-          const handleSuccess = (res) => {
-            swrStoreIfCacheable(req, res, key);
-          };
-          return registerHttpEffect(innerEffect, env, (exit) => {
-            if (exit._tag === "Success") {
-              handleSuccess(exit.value);
-            }
-            cb(exit);
-          });
-        }
-      };
-    };
-  };
-  function swrStoreIfCacheable(req, res, key) {
-    const method = req.method.toUpperCase();
-    let entryTtlMs = ttlMs;
-    if (cachePolicy) {
-      const result = cachePolicy(req, res);
-      if (!result.cacheable) return;
-      entryTtlMs = result.ttlSeconds !== void 0 ? clamp2(result.ttlSeconds, 1, 86400) * 1e3 : ttlMs;
-    } else if (!SAFE_METHODS.has(method)) {
-      return;
-    }
-    const lruTtl = Number.MAX_SAFE_INTEGER;
-    cache.set(key, res, lruTtl);
-    expirationMap.set(key, now() + entryTtlMs);
-  }
-  const swrInvalidate = (key) => {
-    cache.delete(key);
-    expirationMap.delete(key);
-  };
-  const swrClear = () => {
-    cache.clear();
-    expirationMap.clear();
-  };
-  if (staleWhileRevalidate) {
-    return {
-      middleware: swrMiddleware,
-      invalidate: swrInvalidate,
-      clear: swrClear
-    };
-  }
-  return {
-    middleware,
-    invalidate,
-    clear
-  };
-}
-
-// src/http/lifecycle/priorityQueue.ts
-function clampPriority(value) {
-  if (value === void 0 || !Number.isFinite(value)) return 5;
-  return Math.max(0, Math.min(9, Math.trunc(value)));
-}
-function comparePriority(a, b) {
-  if (a.priority !== b.priority) return a.priority - b.priority;
-  return a.arrivalOrder - b.arrivalOrder;
-}
-var PriorityQueue = class {
-  heap = [];
-  counter = 0;
-  /**
-   * Returns the number of entries in the queue (including cancelled entries).
-   *
-   * @returns The total number of entries in the internal heap.
-   *
-   * @example
-   * ```typescript
-   * import { PriorityQueue } from "./priorityQueue";
-   *
-   * const queue = new PriorityQueue<string>();
-   * queue.enqueue("task", 5);
-   * console.log(queue.size); // 1
-   * ```
-   */
-  get size() {
-    return this.heap.length;
-  }
-  /** Returns the number of entries that have not been cancelled. */
-  get activeSize() {
-    return this.heap.reduce((n, entry) => n + (entry.cancelled ? 0 : 1), 0);
-  }
-  /**
-   * Adds a value to the queue with the given priority.
-   *
-   * Priority is clamped to the valid range [0, 9] via `clampPriority`.
-   * Returns the created entry, which can be used for later cancellation
-   * by setting `entry.cancelled = true`.
-   *
-   * @param value - The value to enqueue.
-   * @param priority - Priority level, integer from 0 (highest) to 9 (lowest).
-   *   Clamped to [0, 9]. Defaults to 5 if undefined.
-   * @returns The created queue entry.
-   *
-   * @example
-   * ```typescript
-   * import { PriorityQueue } from "./priorityQueue";
-   *
-   * const queue = new PriorityQueue<string>();
-   * const entry = queue.enqueue("urgent-task", 0);
-   * entry.cancelled = true; // cancel later if needed
-   * ```
-   */
-  enqueue(value, priority) {
-    const entry = {
-      priority: clampPriority(priority),
-      arrivalOrder: this.counter++,
-      value,
-      cancelled: false
-    };
-    this.heap.push(entry);
-    this.bubbleUp(this.heap.length - 1);
-    return entry;
-  }
-  /**
-   * Removes and returns the highest-priority non-cancelled entry.
-   *
-   * Skips (and discards) any cancelled entries at the top of the heap.
-   * Returns `undefined` if the queue is empty or all entries are cancelled.
-   *
-   * @returns The highest-priority non-cancelled entry, or `undefined` if none available.
-   *
-   * @example
-   * ```typescript
-   * import { PriorityQueue } from "./priorityQueue";
-   *
-   * const queue = new PriorityQueue<string>();
-   * queue.enqueue("first", 1);
-   * queue.enqueue("second", 2);
-   * const entry = queue.dequeue(); // { value: "first", priority: 1, ... }
-   * ```
-   */
-  dequeue() {
-    while (this.heap.length > 0) {
-      const top = this.heap[0];
-      if (top.cancelled) {
-        this.removeTop();
-        continue;
-      }
-      this.removeTop();
-      return top;
-    }
-    return void 0;
-  }
-  /**
-   * Returns the highest-priority non-cancelled entry without removing it.
-   *
-   * Discards cancelled entries at the top of the heap as a side effect.
-   * Returns `undefined` if the queue is empty or all entries are cancelled.
-   *
-   * @returns The highest-priority non-cancelled entry, or `undefined` if none available.
-   *
-   * @example
-   * ```typescript
-   * import { PriorityQueue } from "./priorityQueue";
-   *
-   * const queue = new PriorityQueue<string>();
-   * queue.enqueue("task", 3);
-   * const top = queue.peek(); // { value: "task", priority: 3, ... }
-   * console.log(queue.size);  // 1 (not removed)
-   * ```
-   */
-  peek() {
-    while (this.heap.length > 0) {
-      const top = this.heap[0];
-      if (top.cancelled) {
-        this.removeTop();
-        continue;
-      }
-      return top;
-    }
-    return void 0;
-  }
-  /**
-   * Marks all entries matching the predicate as cancelled (lazy removal).
-   *
-   * Cancelled entries are skipped on subsequent dequeue/peek calls.
-   * This does not immediately remove entries from the heap; they are
-   * discarded lazily when encountered at the top during dequeue or peek.
-   *
-   * @param predicate - A function that returns `true` for entries to cancel.
-   * @returns The number of entries marked as cancelled.
-   *
-   * @example
-   * ```typescript
-   * import { PriorityQueue } from "./priorityQueue";
-   *
-   * const queue = new PriorityQueue<string>();
-   * queue.enqueue("a", 1);
-   * queue.enqueue("b", 2);
-   * const removed = queue.remove((e) => e.value === "a"); // 1
-   * ```
-   */
-  remove(predicate) {
-    let count = 0;
-    for (const entry of this.heap) {
-      if (!entry.cancelled && predicate(entry)) {
-        entry.cancelled = true;
-        count++;
-      }
-    }
-    return count;
-  }
-  // --- Binary heap operations ---
-  /** Removes the top element from the heap and restores heap property. */
-  removeTop() {
-    const last = this.heap.pop();
-    if (this.heap.length > 0 && last !== void 0) {
-      this.heap[0] = last;
-      this.sinkDown(0);
-    }
-  }
-  /** Moves an element up the heap until the heap property is restored. */
-  bubbleUp(index) {
-    while (index > 0) {
-      const parentIndex = index - 1 >>> 1;
-      const current = this.heap[index];
-      const parent = this.heap[parentIndex];
-      if (comparePriority(current, parent) >= 0) break;
-      this.heap[index] = parent;
-      this.heap[parentIndex] = current;
-      index = parentIndex;
-    }
-  }
-  /** Moves an element down the heap until the heap property is restored. */
-  sinkDown(index) {
-    const length = this.heap.length;
-    while (true) {
-      const leftIndex = 2 * index + 1;
-      const rightIndex = 2 * index + 2;
-      let smallest = index;
-      if (leftIndex < length && comparePriority(this.heap[leftIndex], this.heap[smallest]) < 0) {
-        smallest = leftIndex;
-      }
-      if (rightIndex < length && comparePriority(this.heap[rightIndex], this.heap[smallest]) < 0) {
-        smallest = rightIndex;
-      }
-      if (smallest === index) break;
-      const temp = this.heap[index];
-      this.heap[index] = this.heap[smallest];
-      this.heap[smallest] = temp;
-      index = smallest;
-    }
-  }
-};
-
-// src/http/lifecycle/priorityScheduler.ts
-var DEFAULT_CONCURRENCY2 = 32;
-function extractPriority(req) {
-  const fromReq = req.priority;
-  if (fromReq !== void 0) return clampPriority(fromReq);
-  const fromInit = req.init?.priority;
-  if (fromInit !== void 0) return clampPriority(fromInit);
-  return 5;
-}
-function safeEmit3(onEvent, event) {
-  if (!onEvent) return;
-  try {
-    onEvent(event);
-  } catch {
-  }
-}
-function withPriority(config) {
-  const concurrency = resolveConcurrency(config?.concurrency);
-  const queueTimeoutMs = resolveQueueTimeout(config?.queueTimeoutMs);
-  const onEvent = config?.onEvent;
-  const queue = new PriorityQueue();
-  let inFlight = 0;
-  const queueDepth = () => {
-    return queue.activeSize;
-  };
-  const middleware = (next) => {
-    return (req) => {
-      const priority = extractPriority(req);
-      return {
-        _tag: "Async",
-        register: (env, cb) => {
-          if (inFlight < concurrency) {
-            return dispatchRequest(next, req, env, cb);
-          }
-          const queued = { req, env, cb, signal: getSignal(req) };
-          const entry = queue.enqueue(queued, priority);
-          safeEmit3(onEvent, { type: "queue-enqueue", priority });
-          if (queueTimeoutMs !== void 0) {
-            queued.timer = setTimeout(() => {
-              entry.cancelled = true;
-              queued.timer = void 0;
-              cb({
-                _tag: "Failure",
-                cause: Cause.fail({
-                  _tag: "PoolTimeout",
-                  key: "priority",
-                  timeoutMs: queueTimeoutMs,
-                  message: `Priority queue did not dispatch within ${queueTimeoutMs}ms`
-                })
-              });
-            }, queueTimeoutMs);
-          }
-          const signal = queued.signal;
-          let abortHandler;
-          if (signal && !signal.aborted) {
-            abortHandler = () => {
-              entry.cancelled = true;
-              if (queued.timer !== void 0) {
-                clearTimeout(queued.timer);
-                queued.timer = void 0;
-              }
-              cb({ _tag: "Failure", cause: Cause.fail({ _tag: "Abort" }) });
-            };
-            signal.addEventListener("abort", abortHandler, { once: true });
-          } else if (signal?.aborted) {
-            entry.cancelled = true;
-            cb({ _tag: "Failure", cause: Cause.fail({ _tag: "Abort" }) });
-            return;
-          }
-          return () => {
-            entry.cancelled = true;
-            if (queued.timer !== void 0) {
-              clearTimeout(queued.timer);
-              queued.timer = void 0;
-            }
-            if (abortHandler && signal) {
-              signal.removeEventListener("abort", abortHandler);
-            }
-            cb({ _tag: "Failure", cause: Cause.interrupt() });
-          };
-        }
-      };
-    };
-    function dispatchRequest(downstream, req, env, cb) {
-      inFlight++;
-      safeEmit3(onEvent, { type: "queue-dispatch", priority: extractPriority(req) });
-      const innerEffect = downstream(req);
-      let completed = false;
-      const onComplete = (exit) => {
-        if (completed) return;
-        completed = true;
-        inFlight--;
-        cb(exit);
-        drainNext(downstream);
-      };
-      const innerCancel = registerHttpEffect(innerEffect, env, onComplete);
-      return () => {
-        innerCancel();
-      };
-    }
-    function drainNext(downstream) {
-      while (inFlight < concurrency) {
-        const entry = queue.dequeue();
-        if (!entry) break;
-        if (entry.cancelled) continue;
-        const queued = entry.value;
-        if (queued.timer !== void 0) {
-          clearTimeout(queued.timer);
-          queued.timer = void 0;
-        }
-        if (queued.signal?.aborted) {
-          queued.cb({ _tag: "Failure", cause: Cause.fail({ _tag: "Abort" }) });
-          continue;
-        }
-        dispatchRequest(downstream, queued.req, queued.env, queued.cb);
-      }
-    }
-  };
-  return Object.assign(middleware, { queueDepth });
-}
-function resolveConcurrency(value) {
-  if (value === void 0 || !Number.isFinite(value)) return DEFAULT_CONCURRENCY2;
-  return Math.max(1, Math.floor(value));
-}
-function resolveQueueTimeout(value) {
-  if (value === void 0 || !Number.isFinite(value)) return void 0;
-  const n = Math.floor(value);
-  return n > 0 ? n : void 0;
-}
-function getSignal(req) {
-  return req.init?.signal;
-}
-
-// src/http/lifecycle/stats.ts
-var LifecycleStatsTracker = class {
-  _cacheHits = 0;
-  _cacheMisses = 0;
-  _cacheEvictions = 0;
-  _dedupHits = 0;
-  _dedupActive = 0;
-  _queueDepth = 0;
-  _requestsStarted = 0;
-  _requestsCompleted = 0;
-  _requestsFailed = 0;
-  _retries = 0;
-  _onEvent;
-  _wireStats;
-  /**
-   * Creates a new lifecycle stats tracker.
-   *
-   * @param opts - Configuration options for the tracker.
-   * @param opts.onEvent - Optional callback invoked on each lifecycle event.
-   *   Errors thrown by this callback are silently discarded.
-   * @param opts.wireStats - A function returning the current wire-level HTTP client stats.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({
-   *   wireStats: () => ({ requestCount: 0, errorCount: 0 }),
-   * });
-   * ```
-   */
-  constructor(opts) {
-    this._onEvent = opts.onEvent;
-    this._wireStats = opts.wireStats;
-  }
-  // --- Increment methods ---
-  /**
-   * Records a cache hit. Increments the cache hit counter by 1.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
-   * tracker.cacheHit();
-   * ```
-   */
-  cacheHit() {
-    this._cacheHits++;
-  }
-  /**
-   * Records a cache miss. Increments the cache miss counter by 1.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
-   * tracker.cacheMiss();
-   * ```
-   */
-  cacheMiss() {
-    this._cacheMisses++;
-  }
-  /**
-   * Records a cache eviction. Increments the cache eviction counter by 1.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
-   * tracker.cacheEviction();
-   * ```
-   */
-  cacheEviction() {
-    this._cacheEvictions++;
-  }
-  /**
-   * Records a dedup hit (a request that joined an in-flight duplicate).
-   * Increments the dedup hit counter by 1.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
-   * tracker.dedupHit();
-   * ```
-   */
-  dedupHit() {
-    this._dedupHits++;
-  }
-  /**
-   * Sets the current number of active dedup groups.
-   *
-   * @param n - The current count of active dedup groups. Must be >= 0.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
-   * tracker.setDedupActive(3);
-   * ```
-   */
-  setDedupActive(n) {
-    this._dedupActive = n;
-  }
-  /**
-   * Sets the current priority queue depth.
-   *
-   * @param n - The current number of entries in the priority queue. Must be >= 0.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
-   * tracker.setQueueDepth(5);
-   * ```
-   */
-  setQueueDepth(n) {
-    this._queueDepth = n;
-  }
-  /**
-   * Records that a request has started. Increments the requests started counter by 1.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
-   * tracker.requestStarted();
-   * ```
-   */
-  requestStarted() {
-    this._requestsStarted++;
-  }
-  /**
-   * Records that a request has completed successfully.
-   * Increments the requests completed counter by 1.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
-   * tracker.requestCompleted();
-   * ```
-   */
-  requestCompleted() {
-    this._requestsCompleted++;
-  }
-  /**
-   * Records that a request has failed.
-   * Increments the requests failed counter by 1.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
-   * tracker.requestFailed();
-   * ```
-   */
-  requestFailed() {
-    this._requestsFailed++;
-  }
-  retry() {
-    this._retries++;
-  }
-  // --- Event emission ---
-  /**
-   * Emits a lifecycle event to the registered `onEvent` callback.
-   *
-   * The callback is wrapped in a try-catch so that any exception thrown by
-   * the callback is silently discarded and request processing continues
-   * unaffected. If no `onEvent` callback was provided, this is a no-op.
-   *
-   * @param type - The lifecycle event type to emit (e.g., `"cache-hit"`, `"request-start"`).
-   * @param extra - Optional additional event data.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({
-   *   onEvent: (event) => console.log(event.type, event.timestamp),
-   *   wireStats: () => ({ requestCount: 0, errorCount: 0 }),
-   * });
-   * tracker.emit("cache-hit", { cacheKey: "GET|/api/users" });
-   * ```
-   */
-  emit(type, extra) {
-    if (!this._onEvent) return;
-    try {
-      const event = {
-        type,
-        timestamp: now(),
-        ...extra
-      };
-      this._onEvent(event);
-    } catch {
-    }
-  }
-  // --- Snapshot ---
-  /**
-   * Returns a frozen snapshot of all lifecycle statistics including wire stats.
-   *
-   * The returned object is frozen (immutable) and represents a point-in-time
-   * view of all counters and gauges.
-   *
-   * @returns A frozen `LifecycleStats` object containing all current statistics.
-   *
-   * @example
-   * ```typescript
-   * import { LifecycleStatsTracker } from "./stats";
-   *
-   * const tracker = new LifecycleStatsTracker({
-   *   wireStats: () => ({ requestCount: 10, errorCount: 1 }),
-   * });
-   * tracker.cacheHit();
-   * tracker.cacheHit();
-   * const stats = tracker.snapshot();
-   * console.log(stats.cacheHits); // 2
-   * ```
-   */
-  snapshot() {
-    return Object.freeze({
-      cacheHits: this._cacheHits,
-      cacheMisses: this._cacheMisses,
-      cacheEvictions: this._cacheEvictions,
-      dedupHits: this._dedupHits,
-      dedupActive: this._dedupActive,
-      queueDepth: this._queueDepth,
-      requestsStarted: this._requestsStarted,
-      requestsCompleted: this._requestsCompleted,
-      requestsFailed: this._requestsFailed,
-      retries: this._retries,
-      wire: this._wireStats()
-    });
-  }
-};
-
-// src/http/lifecycle/lifecycleClient.ts
-function validateGlobals() {
-  if (typeof fetch === "undefined") {
-    throw new Error(
-      "makeLifecycleClient: global `fetch` is not available. Ensure you are running in an environment with fetch support (Node.js 18+ or modern browser)."
-    );
-  }
-  if (typeof AbortController === "undefined") {
-    throw new Error(
-      "makeLifecycleClient: global `AbortController` is not available. Ensure you are running in an environment with AbortController support (Node.js 15+ or modern browser)."
-    );
-  }
-}
-function extractWireConfig(config) {
-  const { dedup, cache, priority, retry, onEvent, ...wireConfig } = config;
-  return wireConfig;
-}
-function makeLifecycleClient(config = {}) {
-  validateGlobals();
-  const wireConfig = extractWireConfig(config);
-  const wireClient = makeHttp(wireConfig);
-  const activeControllers = /* @__PURE__ */ new Set();
-  const tracker = new LifecycleStatsTracker({
-    onEvent: config.onEvent,
-    wireStats: wireClient.stats
-  });
-  const hasDedup = config.dedup !== void 0 && config.dedup !== false;
-  const hasCache = config.cache !== void 0 && config.cache !== false;
-  const hasPriority = config.priority !== void 0 && config.priority !== false;
-  const hasRetry = config.retry !== void 0 && config.retry !== false;
-  if (!hasDedup && !hasCache && !hasPriority && !hasRetry) {
-    return buildLifecycleClient(wireClient, tracker, {
-      cacheInvalidate: noopInvalidate,
-      cacheClear: noopClear,
-      cancelAll: () => cancelControllers(activeControllers),
-      activeControllers
-    });
-  }
-  let priorityMiddleware;
-  if (hasPriority) {
-    const priorityConfig = config.priority;
-    priorityMiddleware = withPriority({
-      ...priorityConfig,
-      onEvent: (event) => {
-        tracker.setQueueDepth(priorityMiddleware?.queueDepth() ?? 0);
-        tracker.emit(event.type, { priority: event.priority });
-      }
-    });
-  }
-  let cacheLayer;
-  if (hasCache) {
-    const cacheConfig = config.cache;
-    cacheLayer = withCache({
-      ...cacheConfig,
-      baseUrl: wireConfig.baseUrl,
-      onLifecycleEvent: (event) => {
-        if (event.type === "cache-hit") tracker.cacheHit();
-        if (event.type === "cache-miss") tracker.cacheMiss();
-        if (event.type === "cache-eviction") tracker.cacheEviction();
-        if (event.type === "cache-hit" || event.type === "cache-miss") {
-          tracker.emit(event.type, { cacheKey: event.cacheKey });
-        }
-      }
-    });
-  }
-  let dedupMiddleware;
-  if (hasDedup) {
-    const dedupConfig = config.dedup;
-    const baseUrl = wireConfig.baseUrl ?? "";
-    const effectiveDedupConfig = dedupConfig.dedupKey || !baseUrl ? dedupConfig : { ...dedupConfig, dedupKey: (req) => computeDedupKey(req, baseUrl) };
-    dedupMiddleware = withDedup({
-      ...effectiveDedupConfig,
-      onEvent: (event) => {
-        if (event.type === "dedup-hit") tracker.dedupHit();
-        if (event.type === "dedup-active") {
-          tracker.setDedupActive(event.active ?? 0);
-          return;
-        }
-        tracker.emit(event.type, { cacheKey: event.cacheKey });
-      }
-    });
-  }
-  let composedFn = wireClient;
-  if (priorityMiddleware) {
-    composedFn = priorityMiddleware(composedFn);
-  }
-  if (hasRetry) {
-    const retryConfig = config.retry;
-    composedFn = withRetry({
-      ...retryConfig,
-      onRetry: (event) => {
-        tracker.retry();
-        tracker.emit("retry", {
-          attempt: event.attempt,
-          delayMs: event.delayMs,
-          status: event.status,
-          errorTag: event.error?._tag
-        });
-        retryConfig.onRetry?.(event);
-      }
-    })(composedFn);
-  }
-  if (cacheLayer) {
-    composedFn = cacheLayer.middleware(composedFn);
-  }
-  if (dedupMiddleware) {
-    composedFn = dedupMiddleware(composedFn);
-  }
-  return buildLifecycleClient(composedFn, tracker, {
-    cacheInvalidate: cacheLayer?.invalidate ?? noopInvalidate,
-    cacheClear: cacheLayer?.clear ?? noopClear,
-    cancelAll: () => cancelControllers(activeControllers),
-    activeControllers,
-    queueDepth: priorityMiddleware?.queueDepth
-  });
-}
-function makeHttpClient(config = {}) {
-  return makeLifecycleClient(config);
-}
-function noopInvalidate(_key) {
-}
-function noopClear() {
-}
-function buildLifecycleClient(fn, tracker, internals) {
-  const client = (req) => trackRequest(fn, req, tracker, internals);
-  const stats = () => {
-    tracker.setQueueDepth(internals.queueDepth?.() ?? 0);
-    return tracker.snapshot();
-  };
-  const withMw = (mw) => {
-    const wrappedFn = mw(fn);
-    return buildLifecycleClient(wrappedFn, tracker, internals);
-  };
-  const lifecycleClient = Object.assign(client, {
-    with: withMw,
-    stats,
-    cancelAll: internals.cancelAll,
-    cache: {
-      invalidate: internals.cacheInvalidate,
-      clear: internals.cacheClear
-    }
-  });
-  return lifecycleClient;
-}
-function cancelControllers(activeControllers) {
-  for (const controller of Array.from(activeControllers)) {
-    try {
-      controller.abort();
-    } catch {
-    }
-  }
-  return asyncSucceed(void 0);
-}
-function trackRequest(fn, req, tracker, internals) {
-  return {
-    _tag: "Async",
-    register: (env, cb) => {
-      const controller = new AbortController();
-      const previousSignal = req.init?.signal;
-      let done = false;
-      let abortedByPreviousSignal = false;
-      let cancelInner;
-      const abortFromPrevious = () => {
-        abortedByPreviousSignal = true;
-        try {
-          controller.abort(previousSignal?.reason);
-        } catch {
-          controller.abort();
-        }
-        cancelInner?.();
-      };
-      if (previousSignal?.aborted) {
-        abortFromPrevious();
-      } else {
-        previousSignal?.addEventListener("abort", abortFromPrevious, { once: true });
-      }
-      internals.activeControllers.add(controller);
-      tracker.requestStarted();
-      tracker.emit("request-start");
-      const finish = (exit0) => {
-        if (done) return;
-        done = true;
-        const exit = abortedByPreviousSignal && exit0._tag === "Failure" && exit0.cause._tag === "Interrupt" ? { _tag: "Failure", cause: Cause.fail({ _tag: "Abort" }) } : exit0;
-        previousSignal?.removeEventListener("abort", abortFromPrevious);
-        internals.activeControllers.delete(controller);
-        if (exit._tag === "Success") {
-          tracker.requestCompleted();
-        } else {
-          tracker.requestFailed();
-        }
-        tracker.emit("request-end");
-        cb(exit);
-      };
-      const trackedReq = {
-        ...req,
-        init: {
-          ...req.init ?? {},
-          signal: controller.signal
-        }
-      };
-      try {
-        cancelInner = registerHttpEffect(fn(trackedReq), env, finish);
-      } catch (error) {
-        finish({
-          _tag: "Failure",
-          cause: Cause.fail({ _tag: "FetchError", message: String(error) })
-        });
-      }
-      return () => {
-        if (done) return;
-        try {
-          controller.abort();
-        } catch {
-        }
-        if (cancelInner) {
-          cancelInner();
-        } else {
-          finish({ _tag: "Failure", cause: Cause.interrupt() });
-        }
-      };
-    }
-  };
-}
-
 // src/http/lifecycle/middleware.ts
 function withAuth(tokenProvider) {
   return (next) => {
-    return (req) => {
-      return asyncFlatMap(tokenProvider(), (token) => {
-        const modifiedReq = {
-          ...req,
-          headers: {
-            ...req.headers ?? {},
-            Authorization: `Bearer ${token}`
-          }
-        };
-        return next(modifiedReq);
-      });
-    };
-  };
-}
-function withLogging(logger) {
-  return (next) => {
-    return (req) => {
-      try {
-        logger({ phase: "request", req });
-      } catch {
-      }
-      const startedAt = now();
-      return asyncFold(
-        next(req),
-        (error) => {
-          const durationMs = Math.round(now() - startedAt);
-          try {
-            logger({ phase: "error", req, error, durationMs });
-          } catch {
-          }
-          return asyncFail(error);
-        },
-        (res) => {
-          const durationMs = Math.round(now() - startedAt);
-          try {
-            logger({ phase: "response", req, res, durationMs });
-          } catch {
-          }
-          return asyncSucceed(res);
-        }
-      );
-    };
-  };
-}
-function withResponseTransform(fn) {
-  return (next) => {
-    return (req) => {
-      return asyncFold(
-        next(req),
-        (error) => {
-          return asyncFail(error);
-        },
-        (res) => {
-          try {
-            const transformed = fn(res, req);
-            return asyncSucceed(transformed);
-          } catch (e) {
-            return asyncFail({ _tag: "FetchError", message: String(e) });
-          }
-        }
-      );
-    };
-  };
-}
-
-// src/http/compression/decompressor.ts
-import zlib from "zlib";
-
-// src/http/compression/environment.ts
-function isNodeEnvironment() {
-  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-}
-
-// src/http/compression/decompressorNode.ts
-function createNodeDecompressor(zlib2) {
-  return {
-    isPassthrough: false,
-    decompress(data, encoding) {
-      try {
-        const input = Buffer.isBuffer(data) ? data : Buffer.from(data);
-        let result;
-        switch (encoding) {
-          case "gzip":
-            result = zlib2.gunzipSync(input);
-            break;
-          case "br":
-            result = zlib2.brotliDecompressSync(input);
-            break;
-          case "deflate":
-            result = zlib2.inflateSync(input);
-            break;
-          default:
-            return { ok: false, error: `Unsupported encoding: ${encoding}` };
-        }
-        return { ok: true, data: result };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { ok: false, error: message };
-      }
-    }
-  };
-}
-
-// src/http/compression/decompressor.noop.ts
-function createNoopDecompressor() {
-  return {
-    isPassthrough: true,
-    decompress(data, _encoding) {
-      const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
-      return { ok: true, data: buf };
-    }
-  };
-}
-
-// src/http/compression/decompressor.ts
-function createDecompressor() {
-  if (isNodeEnvironment()) {
-    return createNodeDecompressor(zlib);
-  }
-  return createNoopDecompressor();
-}
-
-// src/http/compression/types.ts
-var SUPPORTED_ENCODINGS = ["br", "gzip", "deflate"];
-function emptyStats2() {
-  return {
-    decompressed: { gzip: 0, br: 0, deflate: 0 },
-    compressedBytes: 0,
-    decompressedBytes: 0,
-    passthroughCount: 0,
-    errorCount: 0,
-    unsupportedEncodingCount: 0
-  };
-}
-function emptyRequestCompressionStats() {
-  return {
-    compressedCount: 0,
-    skippedCount: 0,
-    errorCount: 0,
-    originalBytes: 0,
-    compressedBytes: 0
-  };
-}
-
-// src/http/compression/middleware.ts
-function injectAcceptEncoding(req, encodings) {
-  const headers = req.headers ?? {};
-  const hasAcceptEncoding = Object.keys(headers).some(
-    (k) => k.toLowerCase() === "accept-encoding"
-  );
-  if (hasAcceptEncoding) return req;
-  return {
-    ...req,
-    headers: {
-      ...headers,
-      "Accept-Encoding": encodings.join(", ")
-    }
-  };
-}
-function isSupportedEncoding(enc) {
-  return SUPPORTED_ENCODINGS.includes(enc);
-}
-function processResponse(res, decompressor, enabledEncodings, stats) {
-  const contentEncodingKey = Object.keys(res.headers).find(
-    (k) => k.toLowerCase() === "content-encoding"
-  );
-  const contentEncodingValue = contentEncodingKey ? res.headers[contentEncodingKey]?.trim() : void 0;
-  if (!contentEncodingValue || contentEncodingValue.toLowerCase() === "identity") {
-    stats.passthroughCount++;
-    return res;
-  }
-  const encodings = contentEncodingValue.split(",").map((e) => e.trim().toLowerCase());
-  const reversedEncodings = [...encodings].reverse();
-  let currentData = Buffer.from(res.bodyText, "latin1");
-  const originalData = currentData;
-  let decompressedCount = 0;
-  for (let i = 0; i < reversedEncodings.length; i++) {
-    const enc = reversedEncodings[i];
-    if (!isSupportedEncoding(enc)) {
-      stats.unsupportedEncodingCount++;
-      if (decompressedCount === 0) {
-        stats.passthroughCount++;
-        return res;
-      }
-      const remainingEncodings = reversedEncodings.slice(i).reverse();
-      const newHeaders2 = { ...res.headers };
-      if (contentEncodingKey) {
-        newHeaders2[contentEncodingKey] = remainingEncodings.join(", ");
-      }
-      newHeaders2["Content-Length"] = String(currentData.byteLength);
-      return {
-        ...res,
-        headers: newHeaders2,
-        bodyText: currentData.toString("latin1")
-      };
-    }
-    if (!enabledEncodings.includes(enc)) {
-      stats.passthroughCount++;
-      if (decompressedCount === 0) {
-        return res;
-      }
-      const remainingEncodings = reversedEncodings.slice(i).reverse();
-      const newHeaders2 = { ...res.headers };
-      if (contentEncodingKey) {
-        newHeaders2[contentEncodingKey] = remainingEncodings.join(", ");
-      }
-      newHeaders2["Content-Length"] = String(currentData.byteLength);
-      return {
-        ...res,
-        headers: newHeaders2,
-        bodyText: currentData.toString("latin1")
-      };
-    }
-    const result = decompressor.decompress(currentData, enc);
-    if (!result.ok) {
-      stats.errorCount++;
-      return res;
-    }
-    stats.compressedBytes += currentData.byteLength;
-    stats.decompressedBytes += result.data.byteLength;
-    stats.decompressed[enc]++;
-    decompressedCount++;
-    currentData = result.data;
-  }
-  const newHeaders = { ...res.headers };
-  if (contentEncodingKey) {
-    delete newHeaders[contentEncodingKey];
-  }
-  const lowerKey = Object.keys(newHeaders).find(
-    (k) => k.toLowerCase() === "content-encoding"
-  );
-  if (lowerKey) {
-    delete newHeaders[lowerKey];
-  }
-  newHeaders["Content-Length"] = String(currentData.byteLength);
-  return {
-    ...res,
-    headers: newHeaders,
-    bodyText: currentData.toString("utf-8")
+    return (req) => {
+      return asyncFlatMap(tokenProvider(), (token) => {
+        const modifiedReq = {
+          ...req,
+          headers: {
+            ...req.headers ?? {},
+            Authorization: `Bearer ${token}`
+          }
+        };
+        return next(modifiedReq);
+      });
+    };
   };
 }
-function makeCompressionMiddleware(config) {
-  const enabledEncodings = config?.encodings ?? [...SUPPORTED_ENCODINGS];
-  const decompressor = createDecompressor();
-  const mutableStats = emptyStats2();
-  const middleware = (next) => {
+function withLogging(logger) {
+  return (next) => {
     return (req) => {
-      const modifiedReq = injectAcceptEncoding(req, enabledEncodings);
+      try {
+        logger({ phase: "request", req });
+      } catch {
+      }
+      const startedAt = now();
       return asyncFold(
-        next(modifiedReq),
-        // Pass HttpErrors through unchanged
-        (error) => asyncFail(error),
-        // Process successful responses
+        next(req),
+        (error) => {
+          const durationMs = Math.round(now() - startedAt);
+          try {
+            logger({ phase: "error", req, error, durationMs });
+          } catch {
+          }
+          return asyncFail(error);
+        },
         (res) => {
-          if (decompressor.isPassthrough) {
-            mutableStats.passthroughCount++;
-            return asyncSucceed(res);
+          const durationMs = Math.round(now() - startedAt);
+          try {
+            logger({ phase: "response", req, res, durationMs });
+          } catch {
           }
-          const processed = processResponse(
-            res,
-            decompressor,
-            enabledEncodings,
-            mutableStats
-          );
-          return asyncSucceed(processed);
+          return asyncSucceed(res);
         }
       );
     };
   };
-  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) => {
+}
+function withResponseTransform(fn) {
+  return (next) => {
     return (req) => {
-      const compressed = compressRequest(req, encoding, minBytes, methods, mutableStats);
-      return next(compressed);
+      return asyncFold(
+        next(req),
+        (error) => {
+          return asyncFail(error);
+        },
+        (res) => {
+          try {
+            const transformed = fn(res, req);
+            return asyncSucceed(transformed);
+          } catch (e) {
+            return asyncFail({ _tag: "FetchError", message: String(e) });
+          }
+        }
+      );
     };
   };
-  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
@@ -3141,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;
         }
@@ -3174,10 +641,16 @@ function failEntries(config, key, entries, error) {
   }
 }
 function toFetchError(error) {
-  if (isHttpError(error)) return error;
+  if (isHttpError2(error)) return error;
   return { _tag: "FetchError", message: error instanceof Error ? error.message : String(error) };
 }
-function isHttpError(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;
   return tag === "Abort" || tag === "BadUrl" || tag === "FetchError" || tag === "Timeout" || tag === "PoolRejected" || tag === "PoolTimeout";
@@ -3238,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) });
@@ -3251,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);
@@ -3261,7 +745,7 @@ function runEffect(effect, env, cb) {
   };
 }
 
-// src/http/prewarm.ts
+// src/http/prewarm/legacy.ts
 function prewarmConnections(config = {}) {
   const fetchImpl = config.fetchImpl ?? globalThis.fetch;
   const method = config.method ?? "HEAD";
@@ -3376,13 +860,13 @@ function resolveUrl(value, baseUrl) {
   }
 }
 function normalizePrewarmError(error) {
-  if (isHttpError2(error)) return error;
+  if (isHttpError3(error)) return error;
   if (typeof error === "object" && error !== null && error.name === "AbortError") {
     return { _tag: "Abort" };
   }
   return { _tag: "FetchError", message: error instanceof Error ? error.message : String(error) };
 }
-function isHttpError2(error) {
+function isHttpError3(error) {
   if (typeof error !== "object" || error === null || !("_tag" in error)) return false;
   const tag = error._tag;
   return tag === "Abort" || tag === "BadUrl" || tag === "FetchError" || tag === "Timeout" || tag === "PoolRejected" || tag === "PoolTimeout";
@@ -3394,48 +878,820 @@ function emit2(config, event) {
   } catch {
   }
 }
+
+// src/http/builder.ts
+var DEFAULT_BUILDER_RETRY = {
+  maxRetries: 2,
+  baseDelayMs: 100,
+  maxDelayMs: 1e3
+};
+var cloneConfig = (config) => ({
+  ...config,
+  headers: config.headers ? { ...config.headers } : void 0,
+  middleware: config.middleware ? [...config.middleware] : void 0
+});
+var freezeConfig = (config) => ({
+  ...config,
+  headers: config.headers ? { ...config.headers } : void 0,
+  middleware: config.middleware ? [...config.middleware] : void 0
+});
+var mergeConfig = (current, next) => ({
+  ...current,
+  ...next,
+  headers: {
+    ...current.headers ?? {},
+    ...next.headers ?? {}
+  },
+  middleware: [
+    ...current.middleware ?? [],
+    ...next.middleware ?? []
+  ]
+});
+function makeBuilder(config) {
+  const replace = (patch) => makeBuilder({
+    ...config,
+    ...patch,
+    headers: patch.headers ? { ...patch.headers } : config.headers,
+    middleware: patch.middleware ? [...patch.middleware] : config.middleware
+  });
+  const setLayer = (key, value) => replace({ [key]: value });
+  const middleware = (mw) => makeBuilder({
+    ...config,
+    middleware: [...config.middleware ?? [], mw]
+  });
+  return Object.freeze({
+    config: () => freezeConfig(config),
+    baseUrl: (baseUrl) => replace({ baseUrl }),
+    header: (name, value) => makeBuilder({
+      ...config,
+      headers: {
+        ...config.headers ?? {},
+        [name]: value
+      }
+    }),
+    headers: (headers) => makeBuilder({
+      ...config,
+      headers: {
+        ...config.headers ?? {},
+        ...headers
+      }
+    }),
+    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),
+    noBatch: () => setLayer("batch", false),
+    cache: (layer = {}) => setLayer("cache", layer),
+    noCache: () => setLayer("cache", false),
+    priority: (layer = {}) => setLayer("priority", layer),
+    noPriority: () => setLayer("priority", false),
+    retry: (layer = DEFAULT_BUILDER_RETRY) => setLayer("retry", layer),
+    noRetry: () => setLayer("retry", false),
+    prewarm: (layer = {}) => setLayer("prewarm", layer),
+    noPrewarm: () => setLayer("prewarm", false),
+    adaptiveLimiter: (layer = {}) => setLayer("adaptiveLimiter", layer),
+    adaptiveLimiterPreset: (preset, overrides = {}) => setLayer("adaptiveLimiter", makeAdaptiveLimiterConfig(preset, overrides)),
+    conservativeLimiter: (overrides = {}) => setLayer("adaptiveLimiter", makeAdaptiveLimiterConfig("conservative", overrides)),
+    balancedLimiter: (overrides = {}) => setLayer("adaptiveLimiter", makeAdaptiveLimiterConfig("balanced", overrides)),
+    aggressiveLimiter: (overrides = {}) => setLayer("adaptiveLimiter", makeAdaptiveLimiterConfig("aggressive", overrides)),
+    noAdaptiveLimiter: () => setLayer("adaptiveLimiter", false),
+    pool: (layer = {}) => setLayer("pool", layer),
+    noPool: () => setLayer("pool", false),
+    compression: (layer = {}) => setLayer("compression", layer),
+    noCompression: () => setLayer("compression", false),
+    middleware,
+    use: middleware,
+    configure: (next) => makeBuilder(mergeConfig(config, next)),
+    build: () => makeDefaultHttpClient(freezeConfig(config)),
+    buildWire: () => makeDefaultHttpClient(freezeConfig(config)).wire
+  });
+}
+function httpClientBuilder(config = {}) {
+  return makeBuilder(cloneConfig(config));
+}
+var makeHttpClientBuilder = httpClientBuilder;
+var httpBuilder = httpClientBuilder;
+
+// src/http/server.ts
+import { createServer } from "http";
+var DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+function route(method, path, optionsOrHandler, maybeHandler) {
+  const options = typeof optionsOrHandler === "function" ? {} : optionsOrHandler;
+  const handler = typeof optionsOrHandler === "function" ? optionsOrHandler : maybeHandler;
+  if (!handler) throw new Error(`Missing handler for HTTP route ${method} ${path}`);
+  return {
+    method: normalizeRouteMethod(method),
+    path: normalizeRoutePath(path),
+    options,
+    handler,
+    match: compileRoutePath(path)
+  };
+}
+var httpRoute = route;
+function makeHttpRouter(routes, options = {}) {
+  const normalizedRoutes = routes.map((item) => ({
+    ...item,
+    method: normalizeRouteMethod(item.method),
+    path: normalizeRoutePath(item.path)
+  }));
+  const router = {
+    routes: normalizedRoutes,
+    match: (method, path) => matchRoute(normalizedRoutes, method, path),
+    handle: (request, existingMatch) => {
+      const matched = existingMatch ?? router.match(request.method, request.path);
+      return handleRouteMatch(request, matched, options);
+    },
+    listen: (serverOptions = {}) => nodeHttpServerResource({
+      ...serverOptions,
+      router
+    })
+  };
+  return router;
+}
+function json(body, init = {}) {
+  return {
+    ...init,
+    headers: setHeaderIfMissing2(init.headers, "content-type", "application/json"),
+    body
+  };
+}
+function text(body, init = {}) {
+  return {
+    ...init,
+    headers: setHeaderIfMissing2(init.headers, "content-type", "text/plain; charset=utf-8"),
+    body
+  };
+}
+function empty(status = 204, headers) {
+  return { status, headers };
+}
+function makeRuntimeHealthRoute(options = {}) {
+  const { path = "/health", ...healthOptions } = options;
+  return route(
+    "GET",
+    path,
+    () => asyncFlatMap(
+      makeRuntimeHealth(healthOptions),
+      (report) => asyncSucceed(healthReportToServerResponse(report))
+    )
+  );
+}
+function makeRuntimeReadinessRoute(options = {}) {
+  return makeRuntimeHealthRoute({
+    ...options,
+    path: options.path ?? "/ready"
+  });
+}
+var runtimeHealthRoute = makeRuntimeHealthRoute;
+var runtimeReadinessRoute = makeRuntimeReadinessRoute;
+function withResponseHeader(name, value) {
+  return (next) => (ctx) => asyncFlatMap(
+    next(ctx),
+    (response) => asyncSucceed({
+      ...response,
+      headers: setHeaderIfMissing2(response.headers, name, value)
+    })
+  );
+}
+function healthReportToServerResponse(report) {
+  return healthHttpResponseToServerResponse(healthToHttpResponse(report));
+}
+function healthHttpResponseToServerResponse(response) {
+  return {
+    status: response.status,
+    headers: response.headers,
+    body: response.body
+  };
+}
+function makeNodeHttpServer(options) {
+  return asyncEffect((_env, cb) => {
+    const router = resolveRouter(options.router);
+    const server = createServer((req, res) => {
+      void handleNodeRequest(req, res, router, options);
+    });
+    let settled = false;
+    let closed = false;
+    const close = () => closeNodeServer(server, options);
+    const fail = (error) => {
+      if (settled) {
+        options.onError?.(error);
+        return;
+      }
+      settled = true;
+      cb({
+        _tag: "Failure",
+        cause: {
+          _tag: "Fail",
+          error: {
+            _tag: "ListenError",
+            error,
+            message: error instanceof Error ? error.message : String(error)
+          }
+        }
+      });
+    };
+    server.once("error", fail);
+    server.once("close", () => {
+      closed = true;
+    });
+    server.listen(options.port ?? 0, options.host, () => {
+      if (settled) return;
+      settled = true;
+      server.off("error", fail);
+      server.on("error", (error) => options.onError?.(error));
+      cb({
+        _tag: "Success",
+        value: {
+          server,
+          router,
+          address: () => server.address(),
+          url: () => serverUrl(server),
+          close
+        }
+      });
+    });
+    return () => {
+      if (closed) return;
+      void close().catch((error) => options.onError?.(error));
+    };
+  });
+}
+function nodeHttpServerResource(options) {
+  return resource(
+    makeNodeHttpServer(options),
+    (handle) => asyncEffect((_env, cb) => {
+      handle.close().then(() => cb({ _tag: "Success", value: void 0 })).catch(() => cb({ _tag: "Success", value: void 0 }));
+    })
+  );
+}
+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 }));
+  }
+  if (match._tag === "MethodNotAllowed") {
+    return asyncSucceed(json(
+      { error: "Method Not Allowed", allowed: match.allowed.filter((method) => method !== "ALL") },
+      { status: 405, headers: { allow: match.allowed.filter((method) => method !== "ALL").join(", ") } }
+    ));
+  }
+  const routeWithParams = match.route;
+  const prepared = prepareRouteContext(request, match.params, routeWithParams);
+  if (!prepared.success) return asyncSucceed(validationErrorResponse(prepared.error));
+  const handler = composeMiddleware(
+    [...options.middleware ?? [], ...routeWithParams.options.middleware ?? []],
+    routeWithParams.handler
+  );
+  let handled;
+  try {
+    handled = handler(prepared.ctx);
+  } catch (error) {
+    return asyncSucceed(handlerErrorResponse(error, options));
+  }
+  return asyncFold(
+    handled,
+    (error) => asyncSucceed(handlerErrorResponse(error, options)),
+    (response) => {
+      const normalized = normalizeServerResponse(response);
+      const validation = validateResponseBody(normalized, routeWithParams);
+      return asyncSucceed(validation.success ? normalized : validationErrorResponse(validation.error));
+    }
+  );
+}
+function prepareRouteContext(request, params, routeWithSchemas) {
+  const paramsResult = validatePart(params, routeWithSchemas.options.params, {
+    phase: "request",
+    schemaName: routeWithSchemas.options.paramsSchemaName ?? "params",
+    body: JSON.stringify(params)
+  });
+  if (!paramsResult.success) return paramsResult;
+  const queryResult = validatePart(request.query, routeWithSchemas.options.query, {
+    phase: "request",
+    schemaName: routeWithSchemas.options.querySchemaName ?? "query",
+    body: JSON.stringify(request.query)
+  });
+  if (!queryResult.success) return queryResult;
+  const bodyInput = routeWithSchemas.options.body ? parseJsonRequestBody(request.bodyText) : { success: true, data: request.bodyText.length > 0 ? request.bodyText : void 0 };
+  if (!bodyInput.success) {
+    return {
+      success: false,
+      error: makeValidationError({
+        message: bodyInput.message,
+        body: request.bodyText,
+        phase: "request",
+        schema: routeWithSchemas.options.bodySchemaName ?? "body",
+        issues: [makeSchemaIssue([], "valid JSON", request.bodyText, bodyInput.message)]
+      })
+    };
+  }
+  const bodyResult = validatePart(bodyInput.data, routeWithSchemas.options.body, {
+    phase: "request",
+    schemaName: routeWithSchemas.options.bodySchemaName ?? "body",
+    body: request.bodyText
+  });
+  if (!bodyResult.success) return bodyResult;
+  return {
+    success: true,
+    ctx: {
+      ...request,
+      route: routeWithSchemas.path,
+      params: paramsResult.data,
+      query: queryResult.data,
+      body: bodyResult.data
+    }
+  };
+}
+function validateResponseBody(response, routeWithSchemas) {
+  const schema2 = routeWithSchemas.options.response;
+  if (!schema2) return { success: true };
+  const result = validateValue(response.body, schema2);
+  if (result.success) return { success: true };
+  return {
+    success: false,
+    error: makeValidationError({
+      message: `HTTP response failed validation: ${formatIssues(result.issues)}`,
+      body: previewJson(response.body),
+      phase: "response",
+      schema: routeWithSchemas.options.responseSchemaName ?? "response",
+      issues: result.issues
+    })
+  };
+}
+function validatePart(input, schema2, options) {
+  if (!schema2) return { success: true, data: input };
+  const result = validateValue(input, schema2);
+  if (result.success) return { success: true, data: result.data };
+  return {
+    success: false,
+    error: makeValidationError({
+      message: `HTTP ${options.schemaName} failed validation: ${formatIssues(result.issues)}`,
+      body: options.body,
+      phase: options.phase,
+      schema: options.schemaName,
+      issues: result.issues
+    })
+  };
+}
+function resolveRouter(input) {
+  return isHttpRouter(input) ? input : makeHttpRouter(input);
+}
+function isHttpRouter(value) {
+  return !Array.isArray(value) && typeof value === "object" && value !== null && typeof value.match === "function" && typeof value.handle === "function";
+}
+function makeValidationError(input) {
+  return {
+    _tag: "ValidationError",
+    message: input.message,
+    body: input.body,
+    phase: input.phase,
+    schema: input.schema,
+    issues: input.issues
+  };
+}
+function validationErrorResponse(error) {
+  return json(
+    {
+      error: error.phase === "response" ? "Response validation failed" : "Request validation failed",
+      message: error.message,
+      phase: error.phase,
+      schema: error.schema,
+      issues: error.issues
+    },
+    { status: error.phase === "response" ? 500 : 400 }
+  );
+}
+function handlerErrorResponse(error, options) {
+  return json(
+    {
+      error: "Internal Server Error",
+      ...options.includeErrorDetails ? { message: error instanceof Error ? error.message : String(error) } : {}
+    },
+    { status: 500 }
+  );
+}
+async function handleNodeRequest(req, res, router, options) {
+  try {
+    const bodyText = await readNodeRequestBody(req, options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES);
+    const serverRequest = nodeRequestToServerRequest(req, bodyText);
+    const match = router.match(serverRequest.method, serverRequest.path);
+    const effect = router.handle(serverRequest, match);
+    const routeLabel = match._tag === "Match" || match._tag === "MethodNotAllowed" ? match.route.path : void 0;
+    const observedInput = {
+      method: serverRequest.method,
+      route: routeLabel,
+      target: serverRequest.target,
+      headers: serverRequest.headers
+    };
+    const response = options.observability ? (await runObservedHttpServerEffect(
+      options.observability,
+      observedInput,
+      effect,
+      {
+        statusCode: (value) => value.status ?? 200,
+        ...options.observabilityOptions ?? {}
+      },
+      options.env,
+      options.runtimeOptions
+    )).value : await (options.runtime ?? new Runtime({
+      env: options.env ?? {},
+      ...options.runtimeOptions ?? {}
+    })).toPromise(effect);
+    writeNodeResponse(res, response);
+  } catch (error) {
+    options.onError?.(error);
+    writeNodeResponse(res, json({ error: "Internal Server Error" }, { status: 500 }));
+  }
+}
+function nodeRequestToServerRequest(req, bodyText) {
+  const headers = normalizeNodeHeaders(req.headers);
+  const target = req.url ?? "/";
+  const parsed = parseRequestUrl(target, headers.host);
+  return {
+    method: (req.method ?? "GET").toUpperCase(),
+    url: parsed.toString(),
+    path: parsed.pathname,
+    target,
+    headers,
+    query: queryToObject(parsed.searchParams),
+    params: {},
+    bodyText,
+    raw: req
+  };
+}
+function writeNodeResponse(res, response) {
+  const normalized = normalizeServerResponse(response);
+  const encoded = encodeResponseBody(normalized);
+  res.statusCode = normalized.status ?? 200;
+  for (const [name, value] of Object.entries(encoded.headers)) {
+    res.setHeader(name, value);
+  }
+  if (encoded.body === void 0) {
+    res.end();
+    return;
+  }
+  res.end(encoded.body);
+}
+function normalizeServerResponse(response) {
+  if (isServerResponse(response)) {
+    return { status: 200, ...response };
+  }
+  return { status: 200, body: response };
+}
+function isServerResponse(value) {
+  return typeof value === "object" && value !== null && ("status" in value || "headers" in value || "body" in value);
+}
+function encodeResponseBody(response) {
+  const headers = { ...response.headers ?? {} };
+  const body = response.body;
+  if (body === void 0 || response.status === 204 || response.status === 304) return { headers };
+  if (typeof body === "string") {
+    return {
+      headers: setHeaderIfMissing2(headers, "content-type", "text/plain; charset=utf-8"),
+      body
+    };
+  }
+  if (body instanceof Uint8Array) return { headers, body };
+  if (body instanceof ArrayBuffer) return { headers, body: new Uint8Array(body) };
+  return {
+    headers: setHeaderIfMissing2(headers, "content-type", "application/json"),
+    body: JSON.stringify(body)
+  };
+}
+function readNodeRequestBody(req, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    req.on("data", (chunk) => {
+      total += chunk.byteLength;
+      if (total > maxBytes) {
+        reject(new Error(`HTTP request body exceeded ${maxBytes} bytes`));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("error", reject);
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  });
+}
+function closeNodeServer(server, options) {
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const schedule = options.shutdownPollSchedule ?? defaultShutdownPollSchedule(options.gracefulShutdownMs ?? 5e3);
+    const driver = makeScheduleDriver(schedule, { name: schedule.name ?? "http.server.shutdown", startedAtMs: startedAt });
+    let finished = false;
+    const done = (error) => {
+      if (finished) return;
+      finished = true;
+      if (timer) clearTimeout(timer);
+      if (error && error.message !== "Server is not running.") reject(error);
+      else resolve();
+    };
+    let timer;
+    const poll = () => {
+      if (finished) return;
+      if (!server.listening) {
+        done();
+        return;
+      }
+      const decision = driver.next({
+        listening: server.listening,
+        elapsedMs: Date.now() - startedAt
+      });
+      if (!decision.continue) {
+        server.closeAllConnections?.();
+        done();
+        return;
+      }
+      timer = setTimeout(poll, decision.delayMs);
+      timer.unref?.();
+    };
+    server.close(done);
+    poll();
+  });
+}
+function defaultShutdownPollSchedule(maxMs) {
+  const intervalMs = 25;
+  return take(fixed(intervalMs), Math.max(1, Math.ceil(Math.max(0, maxMs) / intervalMs)));
+}
+function matchRoute(routes, method, path) {
+  const requestedMethod = method.toUpperCase();
+  const allowed = [];
+  let methodMismatch;
+  for (const candidate of routes) {
+    const params = candidate.match(path);
+    if (!params) continue;
+    if (candidate.method === "ALL" || candidate.method === requestedMethod) {
+      return { _tag: "Match", route: candidate, params };
+    }
+    methodMismatch ??= candidate;
+    allowed.push(candidate.method);
+  }
+  if (methodMismatch) {
+    return { _tag: "MethodNotAllowed", route: methodMismatch, allowed };
+  }
+  return { _tag: "NotFound" };
+}
+function composeMiddleware(middleware, handler) {
+  return middleware.reduceRight((next, current) => current(next), handler);
+}
+function parseJsonRequestBody(bodyText) {
+  if (bodyText.length === 0) return { success: true, data: void 0 };
+  try {
+    return { success: true, data: JSON.parse(bodyText) };
+  } catch (error) {
+    return {
+      success: false,
+      message: `JSON parse error: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function compileRoutePath(path) {
+  const keys = [];
+  const normalized = normalizeRoutePath(path);
+  if (normalized === "/") {
+    return (input) => input === "/" ? {} : void 0;
+  }
+  const source = normalized.split("/").filter(Boolean).map((segment) => {
+    if (segment === "*") {
+      keys.push("*");
+      return "(.*)";
+    }
+    if (segment.startsWith(":")) {
+      keys.push(segment.slice(1));
+      return "([^/]+)";
+    }
+    return escapeRegExp(segment);
+  }).join("/");
+  const regex = new RegExp(`^/${source}/?$`);
+  return (input) => {
+    const match = regex.exec(input);
+    if (!match) return void 0;
+    const params = {};
+    keys.forEach((key, index) => {
+      params[key] = decodePathPart(match[index + 1] ?? "");
+    });
+    return params;
+  };
+}
+function normalizeRouteMethod(method) {
+  const upper = method.toUpperCase();
+  return upper === "ALL" ? "ALL" : upper;
+}
+function normalizeRoutePath(path) {
+  if (!path || path === "*") return "/";
+  const withSlash = path.startsWith("/") ? path : `/${path}`;
+  return withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+}
+function parseRequestUrl(target, host) {
+  try {
+    return new URL(target, `http://${host ?? "localhost"}`);
+  } catch {
+    return new URL("/", `http://${host ?? "localhost"}`);
+  }
+}
+function queryToObject(searchParams) {
+  const out = {};
+  for (const [key, value] of searchParams.entries()) {
+    const current = out[key];
+    if (current === void 0) {
+      out[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      out[key] = [current, value];
+    }
+  }
+  return out;
+}
+function normalizeNodeHeaders(headers) {
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === void 0) continue;
+    out[key.toLowerCase()] = Array.isArray(value) ? value.join(",") : value;
+  }
+  return out;
+}
+function setHeaderIfMissing2(headers, name, value) {
+  const out = { ...headers ?? {} };
+  const existing = Object.keys(out).find((key) => key.toLowerCase() === name.toLowerCase());
+  if (!existing) out[name] = value;
+  return out;
+}
+function serverUrl(server) {
+  const address = server.address();
+  if (!address || typeof address === "string") return void 0;
+  const host = address.address === "::" || address.address === "0.0.0.0" ? "127.0.0.1" : address.address;
+  return `http://${host}:${address.port}`;
+}
+function previewJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[unserializable]";
+  }
+}
+function decodePathPart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 export {
+  AdaptiveLimiter,
+  ConfigValidationError,
   DEFAULT_CACHE_RELEVANT_HEADERS,
+  EmaComputer,
   HttpConcurrencyPool,
+  HttpServer,
   LRUCache,
+  LatencyWindow,
   LifecycleStatsTracker,
   PriorityQueue,
   SEPARATOR,
   SUPPORTED_ENCODINGS,
+  Schema,
+  SchemaValidationException,
+  abortErrorForSignal,
+  adaptiveLimiterPresets,
   backoffDelayMs,
   clampPriority,
   computeCacheKey,
+  computeGradient,
+  computeNewLimit,
+  decodeJsonBody,
+  decodeJsonBodyEffect,
   decorate,
+  defaultHttpClientPreset,
   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,
+  makeHttpRouter,
+  makeHttpServerResource,
   makeHttpStream,
   makeLifecycleClient,
+  makeNodeHttpServer,
+  makeNodeHttpServerResource,
+  makePrewarmManager,
+  makePromiseHttpTransport,
   makeRequestCompressionMiddleware,
   makeResponseCompressionMiddleware,
+  makeRuntimeHealthRoute,
+  makeRuntimeReadinessRoute,
+  makeSchemaIssue,
+  matchHttpError,
+  nodeHttpServerResource,
   normalizeHeadersInit,
+  normalizeHttpError,
+  normalizeHttpHeaders,
   normalizeRetryBudget,
   parseCacheKey,
+  parseConfig,
   prewarmConnections,
   prewarmHttpConnections,
+  promiseHttpTransport,
+  resolveConfig,
   resolveHttpPoolKey,
+  resolveHttpRequestPolicyPresets,
   retryAfterMs,
+  route,
+  runtimeHealthRoute,
+  runtimeReadinessRoute,
+  s,
+  schema,
+  text,
+  toHttpError,
+  validateConfig,
+  validateFetchAvailable,
+  validateOrigin,
+  validateValue,
   validatedJson,
+  validatedJsonResponse,
   withAuth,
+  withBatch,
   withCache,
   withCircuitBreaker,
   withConnectionPrewarming,
   withDedup,
+  withHttpPolicyPresets,
+  withHttpRequestPolicy,
   withLogging,
   withMiddleware,
   withPriority,
   withRequestBatching,
+  withResponseHeader,
   withResponseTransform,
   withRetry,
   withRetryStream,