brass-runtime 1.15.0 → 1.16.0

package/dist/http/index.js

@@ -1,937 +1,182 @@
 import {
-  streamFromReadableStream
-} from "../chunk-PPUXIH5R.js";
+  registerHttpEffect
+} from "../chunk-H55LI6WY.js";
 import {
+  fixed,
   makeCircuitBreaker,
-  sleep
-} from "../chunk-BDYEENHT.js";
-import "../chunk-TO7IKXYT.js";
+  resource,
+  take
+} from "../chunk-KCPT2D6G.js";
+import {
+  AdaptiveLimiter,
+  EmaComputer,
+  HttpConcurrencyPool,
+  LatencyWindow,
+  adaptiveLimiterPresets,
+  backoffDelayMs,
+  computeGradient,
+  computeNewLimit,
+  decorate,
+  defaultRetryOnError,
+  defaultRetryOnStatus,
+  defaultRetryableMethods,
+  makeAdaptiveLimiterConfig,
+  makeHttp,
+  makeHttpStream,
+  mergeHeaders,
+  normalizeHeadersInit,
+  normalizeRetryBudget,
+  resolveConfig,
+  resolveHttpPoolKey,
+  retryAfterMs,
+  setHeaderIfMissing,
+  validateConfig,
+  validateDefaultHttpClientConfig,
+  validateLifecycleClientConfig,
+  withMiddleware,
+  withRetry,
+  withRetryStream
+} from "../chunk-7TL2LHQJ.js";
+import "../chunk-OOGJ73B6.js";
+import "../chunk-ROJC3NBJ.js";
+import {
+  healthToHttpResponse,
+  makeRuntimeHealth,
+  runObservedHttpServerEffect
+} from "../chunk-7XOPAB5Q.js";
+import "../chunk-XDZOO4L5.js";
+import "../chunk-G3XGCZDQ.js";
+import "../chunk-FM4W4QPL.js";
+import {
+  Runtime,
+  fromPromiseAbortable,
+  toPromise
+} from "../chunk-7LVI2GIN.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);
+} from "../chunk-PNVFW245.js";
+import {
+  ConfigValidationError,
+  Schema,
+  SchemaValidationException,
+  formatIssues,
+  isSchema,
+  makeSchemaIssue,
+  parseConfig,
+  s,
+  schema,
+  validateValue
+} from "../chunk-TDVMADDN.js";
+import {
+  __require
+} from "../chunk-3RG5ZIWI.js";
 
-// 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() {
+// src/http/validation.ts
+function decodeJsonBody(bodyText, validator, options = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(bodyText);
+  } catch (error) {
     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)
+      success: false,
+      error: {
+        _tag: "ValidationError",
+        message: `JSON parse error: ${error instanceof Error ? error.message : String(error)}`,
+        body: bodyText,
+        phase: "response",
+        schema: options.schemaName,
+        issues: [makeSchemaIssue([], "valid JSON", bodyText, "Response body is not valid JSON")]
+      }
     };
   }
-  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;
+  if (!validator) return { success: true, data: parsed };
+  let legacyMessage;
+  const validation = isSchema(validator) ? validator.safeParse(parsed) : (() => {
+    const result = validator(parsed);
+    if (result.success) return { success: true, data: result.data };
+    legacyMessage = result.error;
+    return {
+      success: false,
+      issues: result.issues ?? [makeSchemaIssue([], "valid JSON shape", parsed, result.error)]
+    };
+  })();
+  if (validation.success) return { success: true, data: validation.data };
   return {
-    ...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
-      });
+    success: false,
+    error: {
+      _tag: "ValidationError",
+      message: legacyMessage ?? `JSON response failed validation: ${formatIssues(validation.issues)}`,
+      body: bodyText,
+      phase: "response",
+      schema: options.schemaName,
+      issues: validation.issues
     }
-    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
+}
+function encodeJsonBodyEffect(bodyObj, validator, options = {}) {
+  if (validator) {
+    const validation = validateValue(bodyObj, validator);
+    if (!validation.success) {
+      return asyncFail({
+        _tag: "ValidationError",
+        message: `JSON request body failed validation: ${formatIssues(validation.issues)}`,
+        body: previewJson(bodyObj),
+        phase: "request",
+        schema: options.schemaName,
+        issues: validation.issues
       });
     }
-    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();
+  try {
+    return asyncSucceed(JSON.stringify(bodyObj ?? {}));
+  } catch (error) {
+    return asyncFail({
+      _tag: "ValidationError",
+      message: `JSON request body could not be serialized: ${error instanceof Error ? error.message : String(error)}`,
+      body: "",
+      phase: "request",
+      schema: options.schemaName,
+      issues: [
+        makeSchemaIssue([], "JSON-serializable value", bodyObj, "Request body could not be serialized to JSON")
+      ]
     });
   }
-  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) => {
+}
+function decodeJsonBodyEffect(bodyText, validator, options) {
+  const result = decodeJsonBody(bodyText, validator, options);
+  return result.success ? asyncSucceed(result.data) : asyncFail(result.error);
+}
+function validatedJson(client, validator) {
+  return (req) => asyncFold(
+    client(req),
+    (error) => asyncFail(error),
+    (response) => decodeJsonBodyEffect(response.bodyText, validator)
+  );
+}
+function validatedJsonResponse(client, validator) {
+  return (req) => asyncFold(
+    client(req),
+    (error) => asyncFail(error),
+    (response) => asyncFlatMap(
+      decodeJsonBodyEffect(response.bodyText, validator),
+      (body) => asyncSucceed({ ...response, body })
+    )
+  );
+}
+function previewJson(value) {
   try {
-    return new URL(req.url, baseUrl);
+    return JSON.stringify(value);
   } catch {
-    return { _tag: "BadUrl", message: `URL inv\xE1lida: ${req.url}` };
+    return "[unserializable]";
   }
-};
-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);
-};
+}
 
 // src/http/httpClient.ts
 var resolveFinalUrl = (baseUrl, url) => {
@@ -946,7 +191,7 @@ var createHttpCore = (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 ?? {};
+    const { headers, timeoutMs, poolKey, schema: schema2, schemaName, bodySchema, bodySchemaName, ...rest } = init ?? {};
     return {
       headers: normalizeHeadersInit(headers),
       timeoutMs: typeof timeoutMs === "number" ? timeoutMs : void 0,
@@ -955,24 +200,28 @@ var createHttpCore = (cfg = {}) => {
     };
   };
   const applyInitHeaders = (headers) => (req) => headers ? mergeHeaders(headers)(req) : req;
-  const buildReq = (method, url, init, body) => {
-    const s = splitInit(init);
+  const buildReq2 = (method, url, init, body) => {
+    const s2 = 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
+      ...s2.timeoutMs !== void 0 ? { timeoutMs: s2.timeoutMs } : {},
+      ...s2.poolKey !== void 0 ? { poolKey: s2.poolKey } : {},
+      init: s2.init
     };
-    return applyInitHeaders(s.headers)(req);
+    return applyInitHeaders(s2.headers)(req);
   };
-  const toResponse = (w, body) => ({
+  const toResponse2 = (w, body) => ({
     status: w.status,
     statusText: w.statusText,
     headers: w.headers,
     body
   });
+  const decodeResponse2 = (w, validator, schemaName) => asyncFlatMap(
+    decodeJsonBodyEffect(w.bodyText, validator, { schemaName }),
+    (body) => asyncSucceed(toResponse2(w, body))
+  );
   return {
     cfg,
     wire,
@@ -980,8 +229,9 @@ var createHttpCore = (cfg = {}) => {
     requestRaw,
     splitInit,
     applyInitHeaders,
-    buildReq,
-    toResponse
+    buildReq: buildReq2,
+    toResponse: toResponse2,
+    decodeResponse: decodeResponse2
   };
 };
 function httpClient(cfg = {}) {
@@ -995,20 +245,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 +305,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 +345,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 +396,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,48 +480,95 @@ 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);
+  if (req.poolKey) return req.poolKey;
+  if (limiter.keyResolver === "global") return "global";
+  try {
+    const url = new URL(req.url);
+    if (limiter.keyResolver === "host") return url.host;
+    return url.origin;
+  } catch {
+    return "global";
+  }
+}
 
 // src/http/tracing.ts
 function withTracing(tracer) {
   return (next) => (req) => {
     return tracer.span(
-      `HTTP ${req.method} ${req.url}`,
-      next(req),
-      {
-        "http.method": req.method,
-        "http.url": req.url,
-        ...req.headers?.["content-type"] ? { "http.content_type": req.headers["content-type"] } : {}
-      }
-    );
-  };
-}
-
-// src/http/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
-        });
+      `HTTP ${req.method} ${req.url}`,
+      next(req),
+      {
+        "http.method": req.method,
+        "http.url": req.url,
+        ...req.headers?.["content-type"] ? { "http.content_type": req.headers["content-type"] } : {}
       }
-    }
-  );
+    );
+  };
+}
+
+// src/http/errors.ts
+var HTTP_ERROR_TAGS = /* @__PURE__ */ new Set([
+  "Abort",
+  "BadUrl",
+  "FetchError",
+  "Timeout",
+  "PoolRejected",
+  "PoolTimeout",
+  "PoolClosed",
+  "BatchSplitError"
+]);
+function isHttpError(error) {
+  return hasTag(error) && HTTP_ERROR_TAGS.has(error._tag);
+}
+function isValidationError(error) {
+  return hasTag(error) && error._tag === "ValidationError";
+}
+function isCircuitBreakerOpen(error) {
+  return hasTag(error) && error._tag === "CircuitBreakerOpen";
+}
+function isKnownHttpError(error) {
+  return isHttpError(error) || isValidationError(error) || isCircuitBreakerOpen(error);
+}
+function matchHttpError(error, handlers) {
+  if (isKnownHttpError(error)) {
+    const handler = handlers[error._tag];
+    if (handler) return handler(error);
+  }
+  return handlers.default?.(error);
+}
+function formatHttpError(error) {
+  if (isValidationError(error)) {
+    const phase = error.phase ? `${error.phase} ` : "";
+    return `${phase}validation failed: ${error.message}`;
+  }
+  if (isCircuitBreakerOpen(error)) {
+    return `Circuit breaker is open after ${error.failures} failure(s)`;
+  }
+  if (!isHttpError(error)) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  switch (error._tag) {
+    case "Abort":
+      return "HTTP request aborted";
+    case "BadUrl":
+    case "FetchError":
+    case "PoolRejected":
+    case "PoolTimeout":
+    case "PoolClosed":
+    case "BatchSplitError":
+      return error.message;
+    case "Timeout":
+      return error.message;
+  }
+}
+function hasTag(error) {
+  return typeof error === "object" && error !== null && typeof error._tag === "string";
 }
 
 // src/http/body.ts
@@ -1522,6 +781,186 @@ function rejectAll(entry, err) {
   }
 }
 
+// src/http/lifecycle/batch.ts
+function clamp(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return Math.max(min, Math.min(max, Math.floor(value)));
+}
+function safeEmitBatch(onEvent, event) {
+  if (!onEvent) return;
+  try {
+    onEvent(event);
+  } catch {
+  }
+}
+function withBatch(config, onEvent) {
+  const windowMs = clamp(config.windowMs, 1, 5e3);
+  const maxBatchSize = clamp(config.maxBatchSize, 2, 1e4);
+  const { batch, batchKey } = config;
+  const groups = /* @__PURE__ */ new Map();
+  return (next) => {
+    function dispatch(group) {
+      group.dispatched = true;
+      if (group.timer !== null) {
+        clearTimeout(group.timer);
+        group.timer = null;
+      }
+      groups.delete(group.key);
+      const requests = group.waiters.map((w) => w.request);
+      const waiterCount = group.waiters.length;
+      let coalescedReq;
+      try {
+        coalescedReq = batch.coalesce(requests);
+      } catch (err) {
+        const error = { _tag: "FetchError", message: String(err) };
+        rejectAllWaiters(group, error);
+        return;
+      }
+      coalescedReq = {
+        ...coalescedReq,
+        init: {
+          ...coalescedReq.init ?? {},
+          signal: group.controller.signal
+        }
+      };
+      safeEmitBatch(onEvent, { type: "batch-dispatch", batchKey: group.key, batchSize: waiterCount });
+      const innerEffect = next(coalescedReq);
+      registerHttpEffect(innerEffect, void 0, (exit) => {
+        if (exit._tag === "Success") {
+          let responses;
+          try {
+            responses = batch.split(exit.value, requests);
+          } catch (err2) {
+            const error = { _tag: "FetchError", message: String(err2) };
+            rejectAllWaiters(group, error);
+            return;
+          }
+          if (responses.length !== waiterCount) {
+            const error = {
+              _tag: "BatchSplitError",
+              expected: waiterCount,
+              actual: responses.length,
+              message: `split returned ${responses.length} responses but expected ${waiterCount}`
+            };
+            rejectAllWaiters(group, error);
+            return;
+          }
+          const waiters = group.waiters.slice();
+          for (let i = 0; i < waiters.length; i++) {
+            waiters[i].resolve(responses[i]);
+          }
+          return;
+        }
+        if (exit.cause._tag === "Fail") {
+          rejectAllWaiters(group, exit.cause.error);
+          return;
+        }
+        if (exit.cause._tag === "Interrupt") {
+          rejectAllWaiters(group, { _tag: "Abort" });
+          return;
+        }
+        const err = { _tag: "FetchError", message: String(exit.cause.defect ?? "unknown") };
+        rejectAllWaiters(group, err);
+      });
+    }
+    return (req) => {
+      let key;
+      try {
+        key = batchKey(req);
+      } catch {
+        return next(req);
+      }
+      if (!key) {
+        return next(req);
+      }
+      return {
+        _tag: "Async",
+        register: (_env, cb) => {
+          let callerDone = false;
+          const finishCaller = (exit) => {
+            if (callerDone) return;
+            callerDone = true;
+            cb(exit);
+          };
+          const waiter = {
+            request: req,
+            resolve: (res) => {
+              finishCaller({ _tag: "Success", value: res });
+            },
+            reject: (err) => {
+              finishCaller({ _tag: "Failure", cause: Cause.fail(err) });
+            }
+          };
+          const existing = groups.get(key);
+          if (existing && !existing.dispatched) {
+            existing.waiters.push(waiter);
+            safeEmitBatch(onEvent, { type: "batch-hit", batchKey: key });
+            if (existing.waiters.length >= maxBatchSize) {
+              dispatch(existing);
+            }
+            return () => {
+              if (callerDone) return;
+              const idx = existing.waiters.indexOf(waiter);
+              if (idx >= 0) {
+                existing.waiters.splice(idx, 1);
+              }
+              if (existing.waiters.length === 0 && !existing.dispatched) {
+                if (existing.timer !== null) {
+                  clearTimeout(existing.timer);
+                  existing.timer = null;
+                }
+                groups.delete(key);
+              }
+              if (existing.waiters.length === 0 && existing.dispatched) {
+                existing.controller.abort();
+              }
+              finishCaller({ _tag: "Failure", cause: Cause.interrupt() });
+            };
+          }
+          const controller = new AbortController();
+          const group = {
+            key,
+            controller,
+            waiters: [waiter],
+            timer: null,
+            dispatched: false
+          };
+          group.timer = setTimeout(() => {
+            if (!group.dispatched && group.waiters.length > 0) {
+              dispatch(group);
+            }
+          }, windowMs);
+          groups.set(key, group);
+          return () => {
+            if (callerDone) return;
+            const idx = group.waiters.indexOf(waiter);
+            if (idx >= 0) {
+              group.waiters.splice(idx, 1);
+            }
+            if (group.waiters.length === 0 && !group.dispatched) {
+              if (group.timer !== null) {
+                clearTimeout(group.timer);
+                group.timer = null;
+              }
+              groups.delete(key);
+            }
+            if (group.waiters.length === 0 && group.dispatched) {
+              group.controller.abort();
+            }
+            finishCaller({ _tag: "Failure", cause: Cause.interrupt() });
+          };
+        }
+      };
+    };
+  };
+}
+function rejectAllWaiters(group, err) {
+  const waiters = group.waiters.slice();
+  for (const w of waiters) {
+    w.reject(err);
+  }
+}
+
 // src/http/lifecycle/timing.ts
 var now = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
 
@@ -2096,7 +1535,7 @@ var PriorityQueue = class {
 };
 
 // src/http/lifecycle/priorityScheduler.ts
-var DEFAULT_CONCURRENCY2 = 32;
+var DEFAULT_CONCURRENCY = 32;
 function extractPriority(req) {
   const fromReq = req.priority;
   if (fromReq !== void 0) return clampPriority(fromReq);
@@ -2216,7 +1655,7 @@ function withPriority(config) {
   return Object.assign(middleware, { queueDepth });
 }
 function resolveConcurrency(value) {
-  if (value === void 0 || !Number.isFinite(value)) return DEFAULT_CONCURRENCY2;
+  if (value === void 0 || !Number.isFinite(value)) return DEFAULT_CONCURRENCY;
   return Math.max(1, Math.floor(value));
 }
 function resolveQueueTimeout(value) {
@@ -2240,6 +1679,8 @@ var LifecycleStatsTracker = class {
   _requestsCompleted = 0;
   _requestsFailed = 0;
   _retries = 0;
+  _batchDispatches = 0;
+  _batchedRequests = 0;
   _onEvent;
   _wireStats;
   /**
@@ -2400,6 +1841,19 @@ var LifecycleStatsTracker = class {
   retry() {
     this._retries++;
   }
+  /**
+   * Records a batch dispatch. Increments the batch dispatches counter by 1.
+   */
+  batchDispatch() {
+    this._batchDispatches++;
+  }
+  /**
+   * Records requests that were coalesced into a batch.
+   * @param count - The number of individual requests in the batch.
+   */
+  batchedRequests(count) {
+    this._batchedRequests += count;
+  }
   // --- Event emission ---
   /**
    * Emits a lifecycle event to the registered `onEvent` callback.
@@ -2468,11 +1922,447 @@ var LifecycleStatsTracker = class {
       requestsCompleted: this._requestsCompleted,
       requestsFailed: this._requestsFailed,
       retries: this._retries,
+      batchDispatches: this._batchDispatches,
+      batchedRequests: this._batchedRequests,
       wire: this._wireStats()
     });
   }
 };
 
+// src/http/prewarm/validation.ts
+function validateOrigin(origin) {
+  if (!origin || typeof origin !== "string") {
+    throw new Error(`validateOrigin: origin must be a non-empty string, got "${origin}"`);
+  }
+  const trimmed = origin.trim();
+  if (!trimmed) {
+    throw new Error(`validateOrigin: origin must be a non-empty string, got "${origin}"`);
+  }
+  const stripped = stripTrailingSlashes(trimmed);
+  const lower = stripped.toLowerCase();
+  if (!lower.startsWith("http://") && !lower.startsWith("https://")) {
+    throw new Error(
+      `validateOrigin: invalid origin "${origin}" \u2014 must start with http:// or https://`
+    );
+  }
+  let parsed;
+  try {
+    parsed = new URL(stripped);
+  } catch {
+    throw new Error(
+      `validateOrigin: invalid origin "${origin}" \u2014 must be a valid URL origin (scheme + host + optional port)`
+    );
+  }
+  if (parsed.pathname !== "/" && parsed.pathname !== "") {
+    throw new Error(
+      `validateOrigin: invalid origin "${origin}" \u2014 must not contain a path`
+    );
+  }
+  if (parsed.search) {
+    throw new Error(
+      `validateOrigin: invalid origin "${origin}" \u2014 must not contain query parameters`
+    );
+  }
+  if (parsed.hash) {
+    throw new Error(
+      `validateOrigin: invalid origin "${origin}" \u2014 must not contain a fragment`
+    );
+  }
+  return parsed.origin;
+}
+function stripTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
+
+// src/http/prewarm/platform.ts
+function detectPlatform() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined" ? "browser" : "node";
+}
+function validateFetchAvailable() {
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error(
+      "makePrewarmManager: global fetch is not available. Requires Node.js 18+ or modern browser."
+    );
+  }
+  if (typeof globalThis.AbortController !== "function") {
+    throw new Error(
+      "makePrewarmManager: global AbortController is not available."
+    );
+  }
+}
+
+// src/http/prewarm/probe.ts
+async function executeProbe(origin, options) {
+  const { timeoutMs, signal, platform } = options;
+  const url = `${origin}/`;
+  const start = Date.now();
+  const timeoutController = new AbortController();
+  const timeoutId = setTimeout(() => timeoutController.abort(), timeoutMs);
+  const onExternalAbort = () => timeoutController.abort();
+  signal.addEventListener("abort", onExternalAbort);
+  try {
+    if (options.client) {
+      const result = await executeProbeViaClient(options.client, url, timeoutController.signal);
+      const durationMs2 = Date.now() - start;
+      if (result.ok) {
+        return { ok: true, durationMs: durationMs2 };
+      }
+      return { ok: false, durationMs: durationMs2, error: result.error };
+    }
+    const fetchOptions = {
+      method: "HEAD",
+      signal: timeoutController.signal,
+      // Prevent caching of probe requests
+      cache: "no-store"
+    };
+    if (platform === "browser") {
+      fetchOptions.mode = "no-cors";
+    }
+    await globalThis.fetch(url, fetchOptions);
+    const durationMs = Date.now() - start;
+    return { ok: true, durationMs };
+  } catch (err) {
+    const durationMs = Date.now() - start;
+    if (signal.aborted) {
+      return { ok: false, durationMs, error: "cancelled" };
+    }
+    if (timeoutController.signal.aborted && !signal.aborted) {
+      return { ok: false, durationMs, error: `Probe timed out after ${timeoutMs}ms` };
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, durationMs, error: message };
+  } finally {
+    clearTimeout(timeoutId);
+    signal.removeEventListener("abort", onExternalAbort);
+  }
+}
+async function executeProbeViaClient(client, url, signal) {
+  const { registerHttpEffect: registerHttpEffect2 } = await import("../effectRunner-A4CHJXJI.js");
+  return new Promise((resolve) => {
+    const effect = client({
+      method: "HEAD",
+      url,
+      init: { signal }
+    });
+    const cancel = registerHttpEffect2(effect, {}, (exit) => {
+      if (exit._tag === "Success") {
+        resolve({ ok: true });
+      } else {
+        const cause = exit.cause;
+        if (cause?._tag === "Fail") {
+          const err = cause.error;
+          resolve({ ok: false, error: err?.message ?? err?._tag ?? "Unknown error" });
+        } else {
+          resolve({ ok: false, error: "cancelled" });
+        }
+      }
+    });
+    if (signal.aborted) {
+      cancel();
+    } else {
+      signal.addEventListener("abort", () => {
+        cancel();
+      }, { once: true });
+    }
+  });
+}
+
+// src/http/prewarm/connectionState.ts
+function makeConnectionStateMap(origins, keepAliveDurationMs) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const origin of origins) {
+    entries.set(origin, {
+      origin,
+      status: "idle",
+      lastProbeAt: void 0,
+      warmUntil: void 0
+    });
+  }
+  function markWarm(origin, now2) {
+    const entry = entries.get(origin);
+    if (!entry) return;
+    const timestamp = now2 ?? Date.now();
+    entry.status = "warm";
+    entry.lastProbeAt = timestamp;
+    entry.warmUntil = timestamp + keepAliveDurationMs;
+  }
+  function markExpired(origin) {
+    const entry = entries.get(origin);
+    if (!entry) return;
+    entry.status = "expired";
+  }
+  function markIdle(origin) {
+    const entry = entries.get(origin);
+    if (!entry) return;
+    entry.status = "idle";
+    entry.lastProbeAt = void 0;
+    entry.warmUntil = void 0;
+  }
+  function markProbing(origin) {
+    const entry = entries.get(origin);
+    if (!entry) return;
+    entry.status = "probing";
+  }
+  function isWarm(origin, now2) {
+    const entry = entries.get(origin);
+    if (!entry) return false;
+    if (entry.status !== "warm") return false;
+    if (entry.lastProbeAt === void 0 || entry.warmUntil === void 0) return false;
+    const currentTime = now2 ?? Date.now();
+    if (currentTime >= entry.warmUntil) {
+      entry.status = "expired";
+      return false;
+    }
+    return true;
+  }
+  function getState(origin) {
+    const entry = entries.get(origin);
+    if (!entry) return void 0;
+    return {
+      origin: entry.origin,
+      status: entry.status,
+      lastProbeAt: entry.lastProbeAt,
+      warmUntil: entry.warmUntil
+    };
+  }
+  function snapshot() {
+    const result = [];
+    for (const entry of entries.values()) {
+      result.push({
+        origin: entry.origin,
+        status: entry.status,
+        lastProbeAt: entry.lastProbeAt,
+        warmUntil: entry.warmUntil
+      });
+    }
+    return { origins: result };
+  }
+  return { markWarm, markExpired, markIdle, markProbing, isWarm, getState, snapshot };
+}
+
+// src/http/prewarm/budgetSemaphore.ts
+function makeBudgetSemaphore(capacity) {
+  if (capacity < 1 || !Number.isFinite(capacity)) {
+    throw new Error(`makeBudgetSemaphore: capacity must be >= 1, got ${capacity}`);
+  }
+  capacity = Math.floor(capacity);
+  let active = 0;
+  const waiters = [];
+  function release() {
+    active--;
+    if (waiters.length > 0) {
+      const next = waiters.shift();
+      active++;
+      next({ release });
+    }
+  }
+  function acquire() {
+    if (active < capacity) {
+      active++;
+      return Promise.resolve({ release });
+    }
+    return new Promise((resolve) => {
+      waiters.push(resolve);
+    });
+  }
+  function tryAcquire() {
+    if (active < capacity) {
+      active++;
+      return { release };
+    }
+    return void 0;
+  }
+  function available() {
+    return capacity - active;
+  }
+  function queued() {
+    return waiters.length;
+  }
+  return { acquire, tryAcquire, available, queued };
+}
+
+// src/http/prewarm/prewarmManager.ts
+var DEFAULTS = {
+  keepAliveDurationMs: 55e3,
+  budget: 4,
+  probeTimeoutMs: 5e3,
+  autoRefresh: false,
+  useClientPool: false
+};
+function makePrewarmManager(config) {
+  validateFetchAvailable();
+  const keepAliveDurationMs = config.keepAliveDurationMs ?? DEFAULTS.keepAliveDurationMs;
+  const budget = config.budget ?? DEFAULTS.budget;
+  const probeTimeoutMs = config.probeTimeoutMs ?? DEFAULTS.probeTimeoutMs;
+  const autoRefresh = config.autoRefresh ?? DEFAULTS.autoRefresh;
+  const useClientPool = config.useClientPool ?? DEFAULTS.useClientPool;
+  const onEvent = config.onEvent;
+  const client = config.client;
+  const origins = config.origins.map((o) => validateOrigin(o));
+  const platform = detectPlatform();
+  const stateMap = makeConnectionStateMap(origins, keepAliveDurationMs);
+  const semaphore = makeBudgetSemaphore(budget);
+  const abortControllers = /* @__PURE__ */ new Map();
+  const refreshTimers = /* @__PURE__ */ new Map();
+  let disposed = false;
+  function emit3(event) {
+    if (onEvent) {
+      try {
+        onEvent(event);
+      } catch {
+      }
+    }
+  }
+  function scheduleAutoRefresh(origin) {
+    if (!autoRefresh || disposed) return;
+    clearRefreshTimer(origin);
+    const delay = Math.floor(0.8 * keepAliveDurationMs);
+    const timer = setTimeout(() => {
+      refreshTimers.delete(origin);
+      if (disposed) return;
+      if (stateMap.isWarm(origin)) {
+        stateMap.markExpired(origin);
+        emit3({
+          type: "connection-expired",
+          origin,
+          timestamp: Date.now()
+        });
+      }
+      warm(origin).catch(() => {
+      });
+    }, delay);
+    if (typeof timer === "object" && "unref" in timer) {
+      timer.unref();
+    }
+    refreshTimers.set(origin, timer);
+  }
+  function clearRefreshTimer(origin) {
+    const timer = refreshTimers.get(origin);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      refreshTimers.delete(origin);
+    }
+  }
+  function clearAllRefreshTimers() {
+    for (const [, timer] of refreshTimers) {
+      clearTimeout(timer);
+    }
+    refreshTimers.clear();
+  }
+  async function warm(origin) {
+    if (disposed) {
+      return { origin, status: "cancelled", durationMs: 0 };
+    }
+    if (stateMap.isWarm(origin)) {
+      return { origin, status: "already-warm", durationMs: 0 };
+    }
+    const { release } = await semaphore.acquire();
+    if (disposed) {
+      release();
+      return { origin, status: "cancelled", durationMs: 0 };
+    }
+    const controller = new AbortController();
+    abortControllers.set(origin, controller);
+    stateMap.markProbing(origin);
+    try {
+      const probeOptions = {
+        timeoutMs: probeTimeoutMs,
+        signal: controller.signal,
+        platform,
+        client: useClientPool ? client : void 0
+      };
+      const outcome = await executeProbe(origin, probeOptions);
+      if (controller.signal.aborted) {
+        stateMap.markIdle(origin);
+        emit3({
+          type: "connection-cancelled",
+          origin,
+          timestamp: Date.now()
+        });
+        return { origin, status: "cancelled", durationMs: outcome.durationMs };
+      }
+      if (outcome.ok) {
+        stateMap.markWarm(origin);
+        emit3({
+          type: "connection-warmed",
+          origin,
+          timestamp: Date.now(),
+          durationMs: outcome.durationMs
+        });
+        scheduleAutoRefresh(origin);
+        return { origin, status: "warmed", durationMs: outcome.durationMs };
+      } else {
+        stateMap.markIdle(origin);
+        emit3({
+          type: "connection-failed",
+          origin,
+          timestamp: Date.now(),
+          error: outcome.error
+        });
+        return { origin, status: "failed", durationMs: outcome.durationMs, error: outcome.error };
+      }
+    } catch (err) {
+      stateMap.markIdle(origin);
+      const error = err instanceof Error ? err.message : String(err);
+      emit3({
+        type: "connection-failed",
+        origin,
+        timestamp: Date.now(),
+        error
+      });
+      return { origin, status: "failed", durationMs: 0, error };
+    } finally {
+      abortControllers.delete(origin);
+      release();
+    }
+  }
+  async function warmAll() {
+    const results = await Promise.all(origins.map((o) => warm(o)));
+    return results;
+  }
+  function cancel(origin) {
+    const controller = abortControllers.get(origin);
+    if (controller) {
+      controller.abort();
+    }
+    clearRefreshTimer(origin);
+  }
+  function cancelAll() {
+    for (const [, controller] of abortControllers) {
+      controller.abort();
+    }
+    clearAllRefreshTimers();
+  }
+  function isWarm(origin) {
+    if (disposed) return false;
+    return stateMap.isWarm(origin);
+  }
+  function status() {
+    return stateMap.snapshot();
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    cancelAll();
+    for (const origin of origins) {
+      stateMap.markIdle(origin);
+    }
+  }
+  return {
+    warm,
+    warmAll,
+    isWarm,
+    cancel,
+    cancelAll,
+    status,
+    dispose
+  };
+}
+
 // src/http/lifecycle/lifecycleClient.ts
 function validateGlobals() {
   if (typeof fetch === "undefined") {
@@ -2487,10 +2377,11 @@ function validateGlobals() {
   }
 }
 function extractWireConfig(config) {
-  const { dedup, cache, priority, retry, onEvent, ...wireConfig } = config;
+  const { dedup, batch, cache, priority, retry, prewarm, onEvent, ...wireConfig } = config;
   return wireConfig;
 }
 function makeLifecycleClient(config = {}) {
+  validateLifecycleClientConfig(config);
   validateGlobals();
   const wireConfig = extractWireConfig(config);
   const wireClient = makeHttp(wireConfig);
@@ -2500,15 +2391,38 @@ function makeLifecycleClient(config = {}) {
     wireStats: wireClient.stats
   });
   const hasDedup = config.dedup !== void 0 && config.dedup !== false;
+  const hasBatch = config.batch !== void 0 && config.batch !== false;
   const hasCache = config.cache !== void 0 && config.cache !== false;
   const hasPriority = config.priority !== void 0 && config.priority !== false;
   const hasRetry = config.retry !== void 0 && config.retry !== false;
-  if (!hasDedup && !hasCache && !hasPriority && !hasRetry) {
+  if (!hasDedup && !hasBatch && !hasCache && !hasPriority && !hasRetry) {
+    let prewarmMgr2;
+    const hasPrewarm2 = config.prewarm !== void 0 && config.prewarm !== false;
+    if (hasPrewarm2) {
+      const prewarmConfig = config.prewarm;
+      const prewarmOrigins = prewarmConfig.origins ?? [];
+      if (prewarmOrigins.length > 0) {
+        prewarmMgr2 = makePrewarmManager({
+          origins: prewarmOrigins,
+          keepAliveDurationMs: prewarmConfig.keepAliveDurationMs,
+          budget: prewarmConfig.budget,
+          probeTimeoutMs: prewarmConfig.probeTimeoutMs,
+          autoRefresh: prewarmConfig.autoRefresh,
+          useClientPool: prewarmConfig.useClientPool,
+          client: prewarmConfig.useClientPool ? wireClient : void 0,
+          onEvent: prewarmConfig.onEvent
+        });
+      }
+    }
     return buildLifecycleClient(wireClient, tracker, {
       cacheInvalidate: noopInvalidate,
       cacheClear: noopClear,
-      cancelAll: () => cancelControllers(activeControllers),
-      activeControllers
+      cancelAll: () => cancelControllers(activeControllers, prewarmMgr2),
+      shutdown: () => shutdownClient(activeControllers, prewarmMgr2, wireClient.shutdown),
+      activeControllers,
+      adaptiveLimiter: wireClient.adaptiveLimiter,
+      prewarmManager: prewarmMgr2,
+      afterResponse: hasPrewarm2 ? config.prewarm.afterResponse : void 0
     });
   }
   let priorityMiddleware;
@@ -2555,6 +2469,17 @@ function makeLifecycleClient(config = {}) {
       }
     });
   }
+  let batchMiddleware;
+  if (hasBatch) {
+    const batchConfig = config.batch;
+    batchMiddleware = withBatch(batchConfig, (event) => {
+      if (event.type === "batch-dispatch") {
+        tracker.batchDispatch();
+        tracker.batchedRequests(event.batchSize ?? 0);
+      }
+      tracker.emit(event.type, { batchKey: event.batchKey, batchSize: event.batchSize });
+    });
+  }
   let composedFn = wireClient;
   if (priorityMiddleware) {
     composedFn = priorityMiddleware(composedFn);
@@ -2578,15 +2503,40 @@ function makeLifecycleClient(config = {}) {
   if (cacheLayer) {
     composedFn = cacheLayer.middleware(composedFn);
   }
+  if (batchMiddleware) {
+    composedFn = batchMiddleware(composedFn);
+  }
   if (dedupMiddleware) {
     composedFn = dedupMiddleware(composedFn);
   }
+  let prewarmMgr;
+  const hasPrewarm = config.prewarm !== void 0 && config.prewarm !== false;
+  if (hasPrewarm) {
+    const prewarmConfig = config.prewarm;
+    const prewarmOrigins = prewarmConfig.origins ?? [];
+    if (prewarmOrigins.length > 0) {
+      prewarmMgr = makePrewarmManager({
+        origins: prewarmOrigins,
+        keepAliveDurationMs: prewarmConfig.keepAliveDurationMs,
+        budget: prewarmConfig.budget,
+        probeTimeoutMs: prewarmConfig.probeTimeoutMs,
+        autoRefresh: prewarmConfig.autoRefresh,
+        useClientPool: prewarmConfig.useClientPool,
+        client: prewarmConfig.useClientPool ? wireClient : void 0,
+        onEvent: prewarmConfig.onEvent
+      });
+    }
+  }
   return buildLifecycleClient(composedFn, tracker, {
     cacheInvalidate: cacheLayer?.invalidate ?? noopInvalidate,
     cacheClear: cacheLayer?.clear ?? noopClear,
-    cancelAll: () => cancelControllers(activeControllers),
+    cancelAll: () => cancelControllers(activeControllers, prewarmMgr),
+    shutdown: () => shutdownClient(activeControllers, prewarmMgr, wireClient.shutdown),
     activeControllers,
-    queueDepth: priorityMiddleware?.queueDepth
+    adaptiveLimiter: wireClient.adaptiveLimiter,
+    queueDepth: priorityMiddleware?.queueDepth,
+    prewarmManager: prewarmMgr,
+    afterResponse: hasPrewarm ? config.prewarm.afterResponse : void 0
   });
 }
 function makeHttpClient(config = {}) {
@@ -2603,13 +2553,15 @@ function buildLifecycleClient(fn, tracker, internals) {
     return tracker.snapshot();
   };
   const withMw = (mw) => {
-    const wrappedFn = mw(fn);
+    const wrappedFn = mw(withLifecycleMetadata(fn, internals));
     return buildLifecycleClient(wrappedFn, tracker, internals);
   };
   const lifecycleClient = Object.assign(client, {
     with: withMw,
     stats,
     cancelAll: internals.cancelAll,
+    shutdown: internals.shutdown,
+    adaptiveLimiter: internals.adaptiveLimiter,
     cache: {
       invalidate: internals.cacheInvalidate,
       clear: internals.cacheClear
@@ -2617,13 +2569,27 @@ function buildLifecycleClient(fn, tracker, internals) {
   });
   return lifecycleClient;
 }
-function cancelControllers(activeControllers) {
+function withLifecycleMetadata(fn, internals) {
+  if (!internals.adaptiveLimiter) return fn;
+  return Object.assign(((req) => fn(req)), {
+    adaptiveLimiter: internals.adaptiveLimiter
+  });
+}
+function cancelControllers(activeControllers, prewarmMgr) {
   for (const controller of Array.from(activeControllers)) {
     try {
       controller.abort();
     } catch {
     }
   }
+  if (prewarmMgr) {
+    prewarmMgr.cancelAll();
+  }
+  return asyncSucceed(void 0);
+}
+function shutdownClient(activeControllers, prewarmMgr, wireShutdown) {
+  cancelControllers(activeControllers, prewarmMgr);
+  wireShutdown?.();
   return asyncSucceed(void 0);
 }
 function trackRequest(fn, req, tracker, internals) {
@@ -2660,6 +2626,18 @@ function trackRequest(fn, req, tracker, internals) {
         internals.activeControllers.delete(controller);
         if (exit._tag === "Success") {
           tracker.requestCompleted();
+          if (internals.afterResponse && internals.prewarmManager) {
+            try {
+              const originsToWarm = internals.afterResponse(exit.value, req);
+              if (originsToWarm && originsToWarm.length > 0) {
+                for (const origin of originsToWarm) {
+                  internals.prewarmManager.warm(origin).catch(() => {
+                  });
+                }
+              }
+            } catch {
+            }
+          }
         } else {
           tracker.requestFailed();
         }
@@ -2773,7 +2751,7 @@ function isNodeEnvironment() {
   return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 }
 
-// src/http/compression/decompressorNode.ts
+// src/http/compression/decompressor.node.ts
 function createNodeDecompressor(zlib2) {
   return {
     isPassthrough: false,
@@ -2824,7 +2802,7 @@ function createDecompressor() {
 
 // src/http/compression/types.ts
 var SUPPORTED_ENCODINGS = ["br", "gzip", "deflate"];
-function emptyStats2() {
+function emptyStats() {
   return {
     decompressed: { gzip: 0, br: 0, deflate: 0 },
     compressedBytes: 0,
@@ -2874,7 +2852,6 @@ function processResponse(res, decompressor, enabledEncodings, stats) {
   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];
@@ -2944,7 +2921,7 @@ function processResponse(res, decompressor, enabledEncodings, stats) {
 function makeCompressionMiddleware(config) {
   const enabledEncodings = config?.encodings ?? [...SUPPORTED_ENCODINGS];
   const decompressor = createDecompressor();
-  const mutableStats = emptyStats2();
+  const mutableStats = emptyStats();
   const middleware = (next) => {
     return (req) => {
       const modifiedReq = injectAcceptEncoding(req, enabledEncodings);
@@ -3174,10 +3151,10 @@ 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 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";
@@ -3261,7 +3238,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 +3353,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,40 +3371,980 @@ function emit2(config, event) {
   } catch {
   }
 }
+
+// src/http/defaultClient.ts
+var MINIMAL_PRESET_CONFIG = {
+  timeoutMs: 3e4
+};
+var BALANCED_PRESET_CONFIG = {
+  ...MINIMAL_PRESET_CONFIG,
+  dedup: {},
+  priority: {
+    concurrency: 32,
+    queueTimeoutMs: 3e4
+  },
+  retry: {
+    maxRetries: 2,
+    baseDelayMs: 100,
+    maxDelayMs: 1e3,
+    maxElapsedMs: 5e3,
+    respectRetryAfter: true
+  },
+  adaptiveLimiter: makeAdaptiveLimiterConfig("balanced")
+};
+var DEFAULT_CACHEABLE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+var DEFAULT_PRESET_CONFIG = {
+  ...BALANCED_PRESET_CONFIG,
+  cache: {
+    ttlSeconds: 60,
+    maxEntries: 1024,
+    staleWhileRevalidate: true,
+    cachePolicy: (req, res) => ({
+      cacheable: DEFAULT_CACHEABLE_METHODS.has(req.method) && res.status >= 200 && res.status < 400
+    })
+  },
+  priority: {
+    concurrency: 64,
+    queueTimeoutMs: 3e4
+  },
+  retry: {
+    maxRetries: 3,
+    baseDelayMs: 100,
+    maxDelayMs: 2e3,
+    maxElapsedMs: 1e4,
+    respectRetryAfter: true
+  },
+  adaptiveLimiter: makeAdaptiveLimiterConfig("aggressive")
+};
+var PRESET_CONFIGS = {
+  minimal: MINIMAL_PRESET_CONFIG,
+  balanced: BALANCED_PRESET_CONFIG,
+  default: DEFAULT_PRESET_CONFIG
+};
+var defaultHttpClientPreset = "default";
+function makeDefaultHttpClient(config = {}) {
+  validateDefaultHttpClientConfig(config);
+  const {
+    preset = defaultHttpClientPreset,
+    compression,
+    middleware = [],
+    ...lifecycleOverrides
+  } = config;
+  const lifecycleConfig = mergeLifecycleConfig(PRESET_CONFIGS[preset], lifecycleOverrides);
+  let wire = makeLifecycleClient(lifecycleConfig);
+  const compressionResult = compression === false || compression === void 0 && preset === "minimal" ? void 0 : makeCompressionMiddleware(compression === void 0 ? void 0 : compression);
+  if (compressionResult) {
+    wire = wire.with(compressionResult.middleware);
+  }
+  for (const mw of middleware) {
+    wire = wire.with(mw);
+  }
+  const features = featureSnapshot(lifecycleConfig, compressionResult !== void 0, middleware.length);
+  return buildDefaultClient(wire, {
+    preset,
+    features,
+    compressionStats: compressionResult?.stats
+  });
+}
+function buildDefaultClient(wire, meta) {
+  const withPromise = (eff) => withAsyncPromise((e, env) => toPromise(e, env))(eff);
+  const requestRaw = (req) => wire(req);
+  const request = (req) => withPromise(requestRaw(req));
+  const get = (url, init) => request(buildReq("GET", url, init));
+  const post = (url, body, init) => request(buildReq("POST", url, init, body));
+  const getText = (url, init) => {
+    const req = buildReq("GET", url, init);
+    return withPromise(
+      mapTryAsync(requestRaw(req), (w) => toResponse(w, w.bodyText))
+    );
+  };
+  const getJson = ((url, init) => {
+    const req = setHeaderIfMissing("accept", "application/json")(
+      buildReq("GET", url, init)
+    );
+    return withPromise(
+      asyncFlatMap(requestRaw(req), (w) => decodeResponse(w, init?.schema, init?.schemaName))
+    );
+  });
+  const postJson = ((url, bodyObj, init) => {
+    return withPromise(
+      asyncFlatMap(
+        encodeJsonBodyEffect(bodyObj, init?.bodySchema, { schemaName: init?.bodySchemaName }),
+        (bodyText) => {
+          const req = setHeaderIfMissing("content-type", "application/json")(
+            setHeaderIfMissing("accept", "application/json")(
+              buildReq("POST", url, init, bodyText)
+            )
+          );
+          return asyncFlatMap(requestRaw(req), (w) => decodeResponse(w, init?.schema, init?.schemaName));
+        }
+      )
+    );
+  });
+  return {
+    request,
+    get,
+    post,
+    getText,
+    getJson,
+    postJson,
+    with: (mw) => buildDefaultClient(wire.with(mw), {
+      ...meta,
+      features: {
+        ...meta.features,
+        middleware: meta.features.middleware + 1
+      }
+    }),
+    wire,
+    stats: () => wire.stats(),
+    cache: wire.cache,
+    cancelAll: wire.cancelAll,
+    shutdown: wire.shutdown,
+    preset: meta.preset,
+    features: meta.features,
+    ...meta.compressionStats ? {
+      compression: {
+        stats: meta.compressionStats
+      }
+    } : {}
+  };
+}
+function buildReq(method, url, init, body) {
+  const { headers, timeoutMs, poolKey, schema: schema2, schemaName, bodySchema, bodySchemaName, ...rest } = init ?? {};
+  const normalizedHeaders = normalizeHeadersInit(headers);
+  const req = {
+    method,
+    url,
+    ...body && body.length > 0 ? { body } : {},
+    ...typeof timeoutMs === "number" ? { timeoutMs } : {},
+    ...typeof poolKey === "string" ? { poolKey } : {},
+    init: rest
+  };
+  return normalizedHeaders ? mergeHeaders(normalizedHeaders)(req) : req;
+}
+function toResponse(wire, body) {
+  return {
+    status: wire.status,
+    statusText: wire.statusText,
+    headers: wire.headers,
+    body
+  };
+}
+function decodeResponse(wire, schema2, schemaName) {
+  return asyncFlatMap(
+    decodeJsonBodyEffect(wire.bodyText, schema2, { schemaName }),
+    (body) => asyncSucceed(toResponse(wire, body))
+  );
+}
+function mergeLifecycleConfig(defaults, overrides) {
+  return {
+    ...defaults,
+    ...overrides,
+    headers: mergeRecord(defaults.headers, overrides.headers),
+    dedup: mergeLayer(defaults.dedup, overrides.dedup),
+    batch: mergeLayer(defaults.batch, overrides.batch),
+    cache: mergeLayer(defaults.cache, overrides.cache),
+    priority: mergeLayer(defaults.priority, overrides.priority),
+    retry: mergeLayer(defaults.retry, overrides.retry),
+    prewarm: mergeLayer(defaults.prewarm, overrides.prewarm),
+    adaptiveLimiter: mergeAdaptiveLimiterLayer(defaults.adaptiveLimiter, overrides.adaptiveLimiter),
+    pool: mergeLayer(defaults.pool, overrides.pool)
+  };
+}
+function mergeRecord(defaults, overrides) {
+  if (!defaults) return overrides;
+  if (!overrides) return defaults;
+  return { ...defaults, ...overrides };
+}
+function mergeLayer(defaults, overrides) {
+  if (overrides === void 0) return defaults;
+  if (overrides === false) return false;
+  if (defaults === void 0 || defaults === false) return overrides;
+  return { ...defaults, ...overrides };
+}
+function mergeAdaptiveLimiterLayer(defaults, overrides) {
+  if (overrides === void 0) return defaults;
+  if (overrides === false) return false;
+  if (defaults === void 0 || defaults === false) return overrides;
+  if (overrides.preset !== void 0) return overrides;
+  return { ...defaults, ...overrides };
+}
+function featureSnapshot(config, compression, middleware) {
+  return Object.freeze({
+    dedup: isEnabled(config.dedup),
+    batch: isEnabled(config.batch),
+    cache: isEnabled(config.cache),
+    priority: isEnabled(config.priority),
+    retry: isEnabled(config.retry),
+    prewarm: isEnabled(config.prewarm),
+    adaptiveLimiter: isEnabled(config.adaptiveLimiter),
+    compression,
+    middleware
+  });
+}
+function isEnabled(value) {
+  return value !== void 0 && value !== false;
+}
+
+// src/http/builder.ts
+var DEFAULT_BUILDER_RETRY = {
+  maxRetries: 2,
+  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 }),
+    preset: (preset) => replace({ preset }),
+    minimal: () => replace({ preset: "minimal" }),
+    balanced: () => replace({ preset: "balanced" }),
+    defaultPreset: () => replace({ preset: "default" }),
+    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;
+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: previewJson2(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);
+    let state = schedule.initial();
+    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, nextState] = schedule.step(state, {
+        listening: server.listening,
+        elapsedMs: Date.now() - startedAt
+      });
+      state = nextState;
+      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 previewJson2(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,
   LRUCache,
+  LatencyWindow,
   LifecycleStatsTracker,
   PriorityQueue,
   SEPARATOR,
   SUPPORTED_ENCODINGS,
+  Schema,
+  SchemaValidationException,
+  adaptiveLimiterPresets,
   backoffDelayMs,
   clampPriority,
   computeCacheKey,
+  computeGradient,
+  computeNewLimit,
+  decodeJsonBody,
+  decodeJsonBodyEffect,
   decorate,
+  defaultHttpClientPreset,
   defaultRetryOnError,
   defaultRetryOnStatus,
   defaultRetryableMethods,
+  detectPlatform,
+  empty,
+  encodeJsonBodyEffect,
+  executeProbe,
+  formatHttpError,
+  formatIssues,
+  httpBuilder,
   httpClient,
+  httpClientBuilder,
   httpClientStream,
   httpClientWithMeta,
+  httpRoute,
+  isCircuitBreakerOpen,
+  isHttpError,
+  isKnownHttpError,
+  isSchema,
+  isValidationError,
+  json,
+  makeAdaptiveLimiterConfig,
+  makeBudgetSemaphore,
   makeCompressionMiddleware,
+  makeConnectionStateMap,
+  makeDefaultHttpClient,
   makeHttp,
   makeHttpClient,
+  makeHttpClientBuilder,
+  makeHttpRouter,
+  makeHttpServerResource,
   makeHttpStream,
   makeLifecycleClient,
+  makeNodeHttpServer,
+  makeNodeHttpServerResource,
+  makePrewarmManager,
   makeRequestCompressionMiddleware,
   makeResponseCompressionMiddleware,
+  makeRuntimeHealthRoute,
+  makeRuntimeReadinessRoute,
+  makeSchemaIssue,
+  matchHttpError,
+  nodeHttpServerResource,
   normalizeHeadersInit,
   normalizeRetryBudget,
   parseCacheKey,
+  parseConfig,
   prewarmConnections,
   prewarmHttpConnections,
+  resolveConfig,
   resolveHttpPoolKey,
   retryAfterMs,
+  route,
+  runtimeHealthRoute,
+  runtimeReadinessRoute,
+  s,
+  schema,
+  text,
+  validateConfig,
+  validateFetchAvailable,
+  validateOrigin,
+  validateValue,
   validatedJson,
+  validatedJsonResponse,
   withAuth,
+  withBatch,
   withCache,
   withCircuitBreaker,
   withConnectionPrewarming,
@@ -3436,6 +4353,7 @@ export {
   withMiddleware,
   withPriority,
   withRequestBatching,
+  withResponseHeader,
   withResponseTransform,
   withRetry,
   withRetryStream,