brass-runtime 1.19.1 → 1.20.0

package/dist/{chunk-LXNU3MRV.cjs → chunk-LA2PAO7J.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9;
 
 var _chunkL6VB5N7Qcjs = require('./chunk-L6VB5N7Q.cjs');
 
@@ -14,6 +14,8 @@ var _chunkZZ2CMYJLcjs = require('./chunk-ZZ2CMYJL.cjs');
 
 
 
+
+
 var _chunkJKHBEWQAcjs = require('./chunk-JKHBEWQA.cjs');
 
 
@@ -3182,6 +3184,275 @@ var noopSignal = (() => {
   globalThis.__brassNoopSignal = s;
   return s;
 })();
+var PoolRequestState = (_class6 = class {
+  constructor(req, url, transport, metrics, pool, adaptiveLimiter, timerWheel, timeoutMs, env, cb, previousSignal, controller, signal, label, startedAt) {;_class6.prototype.__init11.call(this);_class6.prototype.__init12.call(this);_class6.prototype.__init13.call(this);_class6.prototype.__init14.call(this);_class6.prototype.__init15.call(this);_class6.prototype.__init16.call(this);
+    this.req = req;
+    this.url = url;
+    this.transport = transport;
+    this.metrics = metrics;
+    this.pool = pool;
+    this.adaptiveLimiter = adaptiveLimiter;
+    this.timerWheel = timerWheel;
+    this.timeoutMs = timeoutMs;
+    this.env = env;
+    this.cb = cb;
+    this.previousSignal = previousSignal;
+    this.controller = controller;
+    this.signal = signal;
+    this.label = label;
+    this.startedAt = startedAt;
+  }
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  __init11() {this.done = false}
+  __init12() {this.cancelInner = void 0}
+  __init13() {this.timerHandle = void 0}
+  __init14() {this.timeoutHandle = void 0}
+  __init15() {this.lease = void 0}
+  finish(outcome, exit, error) {
+    if (this.done) return;
+    this.done = true;
+    if (this.timerHandle) {
+      this.timerHandle.cancel();
+      this.timerHandle = void 0;
+    }
+    if (this.timeoutHandle !== void 0) {
+      clearTimeout(this.timeoutHandle);
+      this.timeoutHandle = void 0;
+    }
+    if (this.previousSignal) this.previousSignal.removeEventListener("abort", this.boundAbortFromPrevious);
+    this.cancelInner = void 0;
+    _chunkJKHBEWQAcjs.recordAbortablePromiseFinish.call(void 0, this.label, outcome);
+    this.metrics.onFinish({
+      label: this.label,
+      outcome,
+      durationMs: Math.round(performance.now() - this.startedAt),
+      error
+    });
+    this.cb(exit);
+  }
+  finishFailure(error, outcome = "failure") {
+    this.finish(outcome, { _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail(error) }, error);
+  }
+  abortCurrent(reason) {
+    if (!this.controller) return;
+    try {
+      this.controller.abort(reason);
+    } catch (e7) {
+      this.controller.abort();
+    }
+  }
+  /**
+   * Bound reference for addEventListener/removeEventListener.
+   * Only allocated when previousSignal is present (not on the hot path).
+   */
+  __init16() {this.boundAbortFromPrevious = void 0}
+  abortFromPrevious() {
+    const error = this.previousSignal ? abortErrorForSignal(this.previousSignal) : { _tag: "Abort" };
+    this.abortCurrent(_optionalChain([this, 'access', _78 => _78.previousSignal, 'optionalAccess', _79 => _79.reason]));
+    const cancel = this.cancelInner;
+    this.cancelInner = void 0;
+    if (this.lease) {
+      releaseFailure(this.lease, this.adaptiveLimiter);
+      this.lease = void 0;
+    }
+    queueMicrotask(() => {
+      this.finishFailure(error);
+      _optionalChain([cancel, 'optionalCall', _80 => _80()]);
+    });
+  }
+  runTransportInner() {
+    const { transport, req, url, signal, env } = this;
+    try {
+      const effect = transport({ request: req, url, signal });
+      if (effect._tag === "Succeed") {
+        if (this.lease) releaseSuccess(this.lease, this.adaptiveLimiter, effect.value);
+        this.finish("success", { _tag: "Success", value: effect.value });
+      } else if (effect._tag === "Fail") {
+        if (this.lease) releaseFailure(this.lease, this.adaptiveLimiter);
+        this.finishFailure(effect.error);
+      } else if (effect._tag === "Async") {
+        try {
+          const cancel = effect.register(env, (exit) => {
+            if (this.done) return;
+            this.cancelInner = void 0;
+            if (exit._tag === "Success") {
+              if (this.lease) releaseSuccess(this.lease, this.adaptiveLimiter, exit.value);
+              this.finish("success", exit);
+            } else {
+              if (this.lease) releaseFailure(this.lease, this.adaptiveLimiter);
+              this.finish("failure", exit, exitError(exit));
+            }
+          });
+          if (!this.done) this.cancelInner = typeof cancel === "function" ? cancel : void 0;
+        } catch (error) {
+          if (this.lease) releaseFailure(this.lease, this.adaptiveLimiter);
+          this.finishFailure(normalizeHttpError(error));
+        }
+      } else {
+        const innerCancel = _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, 
+          effect,
+          env,
+          (exit) => {
+            if (this.done) return;
+            this.cancelInner = void 0;
+            if (exit._tag === "Success") {
+              if (this.lease) releaseSuccess(this.lease, this.adaptiveLimiter, exit.value);
+              this.finish("success", exit);
+            } else {
+              if (this.lease) releaseFailure(this.lease, this.adaptiveLimiter);
+              this.finish("failure", exit, exitError(exit));
+            }
+          }
+        );
+        if (!this.done) this.cancelInner = innerCancel;
+      }
+    } catch (error) {
+      if (this.lease) releaseFailure(this.lease, this.adaptiveLimiter);
+      this.finishFailure(normalizeHttpError(error));
+    }
+  }
+}, _class6);
+var runPoolTransport = (req, url, transport, metrics, pool, adaptiveLimiter, timerWheel, timeoutMs) => ({
+  _tag: "Async",
+  register: (env, cb) => {
+    const previousSignal = _optionalChain([req, 'access', _81 => _81.init, 'optionalAccess', _82 => _82.signal]);
+    const controller = new AbortController();
+    const signal = controller.signal;
+    const label = fetchLabel(req, url);
+    const startedAt = performance.now();
+    const state = new PoolRequestState(
+      req,
+      url,
+      transport,
+      metrics,
+      pool,
+      adaptiveLimiter,
+      timerWheel,
+      timeoutMs,
+      env,
+      cb,
+      previousSignal,
+      controller,
+      signal,
+      label,
+      startedAt
+    );
+    _chunkJKHBEWQAcjs.recordAbortablePromiseStart.call(void 0, label);
+    metrics.onStart();
+    if (previousSignal) {
+      state.boundAbortFromPrevious = () => state.abortFromPrevious();
+      if (previousSignal.aborted) {
+        state.abortFromPrevious();
+        return () => void 0;
+      }
+      previousSignal.addEventListener("abort", state.boundAbortFromPrevious, ONCE_OPTIONS);
+    }
+    if (timeoutMs !== void 0 && timeoutMs > 0) {
+      const onTimeout = () => {
+        const reason = timeoutReason(req, url, timeoutMs);
+        if (state.lease) {
+          releaseFailure(state.lease, adaptiveLimiter);
+          state.lease = void 0;
+        }
+        const cancel = state.cancelInner;
+        state.cancelInner = void 0;
+        state.finishFailure(reason, "timeout");
+        state.abortCurrent(reason);
+        _optionalChain([cancel, 'optionalCall', _83 => _83()]);
+      };
+      if (timerWheel) {
+        state.timerHandle = timerWheel.schedule(timeoutMs, onTimeout, startedAt);
+      } else {
+        state.timeoutHandle = setTimeout(onTimeout, timeoutMs);
+      }
+    }
+    if (adaptiveLimiter) {
+      const key = resolveHttpPoolKey(adaptiveLimiter.keyResolver, req, url);
+      const syncLease = adaptiveLimiter.tryAcquireSync(key, signal);
+      if (syncLease) {
+        state.lease = syncLease;
+      } else {
+        adaptiveLimiter.acquire(key, signal, { priority: requestPriority(req) }).then(
+          (asyncLease) => {
+            if (state.done) {
+              asyncLease.release(0);
+              return;
+            }
+            state.lease = asyncLease;
+            state.runTransportInner();
+          },
+          (err) => {
+            if (state.done) return;
+            state.finishFailure(normalizeHttpError(err));
+          }
+        );
+        return () => {
+          if (state.done) return;
+          const cancel = state.cancelInner;
+          state.cancelInner = void 0;
+          state.abortCurrent();
+          if (state.lease) releaseFailure(state.lease, adaptiveLimiter);
+          state.finish("interrupt", { _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.interrupt() });
+          _optionalChain([cancel, 'optionalCall', _84 => _84()]);
+        };
+      }
+    } else if (pool) {
+      const key = resolveHttpPoolKey(pool.keyResolver, req, url);
+      const syncLease = pool.tryAcquireSync(key, signal);
+      if (syncLease) {
+        state.lease = syncLease;
+      } else {
+        pool.acquire(key, signal).then(
+          (asyncLease) => {
+            if (state.done) {
+              asyncLease.release();
+              return;
+            }
+            state.lease = asyncLease;
+            state.runTransportInner();
+          },
+          (err) => {
+            if (state.done) return;
+            state.finishFailure(normalizeHttpError(err));
+          }
+        );
+        return () => {
+          if (state.done) return;
+          const cancel = state.cancelInner;
+          state.cancelInner = void 0;
+          state.abortCurrent();
+          if (state.lease) releaseFailure(state.lease, void 0);
+          state.finish("interrupt", { _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.interrupt() });
+          _optionalChain([cancel, 'optionalCall', _85 => _85()]);
+        };
+      }
+    }
+    state.runTransportInner();
+    return () => {
+      if (state.done) return;
+      const cancel = state.cancelInner;
+      state.cancelInner = void 0;
+      state.abortCurrent();
+      if (state.lease) releaseFailure(state.lease, adaptiveLimiter);
+      state.finish("interrupt", { _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.interrupt() });
+      _optionalChain([cancel, 'optionalCall', _86 => _86()]);
+    };
+  }
+});
 function makeHttp(cfg = {}) {
   validateMakeHttpConfig(cfg);
   const baseUrl = _nullishCoalesce(cfg.baseUrl, () => ( ""));
@@ -3200,53 +3471,18 @@ function makeHttp(cfg = {}) {
     if (!adaptiveLimiter && !pool && timeoutMs === void 0) {
       return runDirectTransport(req, url, transport, metrics);
     }
-    return _chunkJKHBEWQAcjs.fromPromiseAbortable.call(void 0, 
-      async (signal, env) => {
-        let lease;
-        const linkedSignal = linkAbortSignals(signal, _optionalChain([req, 'access', _78 => _78.init, 'optionalAccess', _79 => _79.signal]));
-        try {
-          if (linkedSignal.signal.aborted) throw abortErrorForSignal(linkedSignal.signal);
-          if (adaptiveLimiter) {
-            const key = resolveHttpPoolKey(adaptiveLimiter.keyResolver, req, url);
-            lease = await adaptiveLimiter.acquire(key, linkedSignal.signal, { priority: requestPriority(req) });
-          } else if (pool) {
-            const key = resolveHttpPoolKey(pool.keyResolver, req, url);
-            lease = await pool.acquire(key, linkedSignal.signal);
-          }
-          const response = await runTransportEffect(
-            transport({ request: req, url, signal: linkedSignal.signal }),
-            env,
-            linkedSignal.signal
-          );
-          lease = releaseSuccess(lease, adaptiveLimiter, response);
-          return response;
-        } finally {
-          linkedSignal.cleanup();
-          if (lease) {
-            releaseFailure(lease, adaptiveLimiter);
-          }
-        }
-      },
-      normalizeHttpError,
-      {
-        label: fetchLabel(req, url),
-        timeoutMs,
-        timeoutReason: timeoutMs ? () => timeoutReason(req, url, timeoutMs) : void 0,
-        onStart: metrics.onStart,
-        onFinish: metrics.onFinish
-      }
-    );
+    return runPoolTransport(req, url, transport, metrics, pool, adaptiveLimiter, void 0, timeoutMs);
   };
   const metadata = {};
   if (adaptiveLimiter) metadata.adaptiveLimiter = adaptiveLimiter;
   if (adaptiveLimiter || destroyTransport) {
     metadata.destroy = () => {
-      _optionalChain([adaptiveLimiter, 'optionalAccess', _80 => _80.destroy, 'call', _81 => _81()]);
-      _optionalChain([destroyTransport, 'optionalCall', _82 => _82()]);
+      _optionalChain([adaptiveLimiter, 'optionalAccess', _87 => _87.destroy, 'call', _88 => _88()]);
+      _optionalChain([destroyTransport, 'optionalCall', _89 => _89()]);
     };
     metadata.shutdown = () => {
-      _optionalChain([adaptiveLimiter, 'optionalAccess', _83 => _83.shutdown, 'call', _84 => _84()]);
-      _optionalChain([destroyTransport, 'optionalCall', _85 => _85()]);
+      _optionalChain([adaptiveLimiter, 'optionalAccess', _90 => _90.shutdown, 'call', _91 => _91()]);
+      _optionalChain([destroyTransport, 'optionalCall', _92 => _92()]);
     };
   }
   return decorate(run, metrics.snapshot, metadata);
@@ -3269,7 +3505,7 @@ var withRetryStream = (p) => (next) => {
         if (!canRetry) return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, e);
         const d = delayWithinBudget(backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs));
         if (d <= 0 && maxElapsedMs !== void 0) return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, e);
-        _optionalChain([p, 'access', _86 => _86.onRetry, 'optionalCall', _87 => _87({
+        _optionalChain([p, 'access', _93 => _93.onRetry, 'optionalCall', _94 => _94({
           attempt,
           delayMs: d,
           error: e,
@@ -3287,7 +3523,7 @@ var withRetryStream = (p) => (next) => {
         const rawDelay = ra === void 0 ? backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs) : Math.min(ra, p.maxDelayMs);
         const d = delayWithinBudget(rawDelay);
         if (d <= 0 && maxElapsedMs !== void 0) return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, w);
-        _optionalChain([p, 'access', _88 => _88.onRetry, 'optionalCall', _89 => _89({
+        _optionalChain([p, 'access', _95 => _95.onRetry, 'optionalCall', _96 => _96({
           attempt,
           delayMs: d,
           error: void 0,
@@ -3484,7 +3720,7 @@ function safeEmit(onEvent, event) {
   if (!onEvent) return;
   try {
     onEvent(event);
-  } catch (e7) {
+  } catch (e8) {
   }
 }
 function causeDefectMessage(cause) {
@@ -3494,8 +3730,8 @@ function causeDefectMessage(cause) {
 }
 function withDedup(config) {
   const inFlight = /* @__PURE__ */ new Map();
-  const customKeyFn = _optionalChain([config, 'optionalAccess', _90 => _90.dedupKey]);
-  const onEvent = _optionalChain([config, 'optionalAccess', _91 => _91.onEvent]);
+  const customKeyFn = _optionalChain([config, 'optionalAccess', _97 => _97.dedupKey]);
+  const onEvent = _optionalChain([config, 'optionalAccess', _98 => _98.onEvent]);
   const dedupKeyCtx = makeDedupKeyContext("");
   return (next) => {
     return (req) => {
@@ -3512,7 +3748,7 @@ function withDedup(config) {
       } else if (customKeyFn) {
         try {
           key = customKeyFn(req);
-        } catch (e8) {
+        } catch (e9) {
           return next(req);
         }
         if (!key) {
@@ -3639,7 +3875,7 @@ function safeEmitBatch(onEvent, event) {
   if (!onEvent) return;
   try {
     onEvent(event);
-  } catch (e9) {
+  } catch (e10) {
   }
 }
 function causeDefectMessage2(cause) {
@@ -3722,7 +3958,7 @@ function withBatch(config, onEvent) {
       let key;
       try {
         key = batchKey(req);
-      } catch (e10) {
+      } catch (e11) {
         return next(req);
       }
       if (!key) {
@@ -3823,10 +4059,10 @@ var now = typeof performance !== "undefined" && typeof performance.now === "func
 function isExpired(node) {
   return now() - node.storedAt >= node.ttlMs;
 }
-var LRUCache = (_class6 = class {
-  __init11() {this.map = /* @__PURE__ */ new Map()}
-  __init12() {this.head = null}
-  __init13() {this.tail = null}
+var LRUCache = (_class7 = class {
+  __init17() {this.map = /* @__PURE__ */ new Map()}
+  __init18() {this.head = null}
+  __init19() {this.tail = null}
   
   
   /**
@@ -3843,7 +4079,7 @@ var LRUCache = (_class6 = class {
    * const cache = new LRUCache<number>({ maxEntries: 50 });
    * ```
    */
-  constructor(config = {}) {;_class6.prototype.__init11.call(this);_class6.prototype.__init12.call(this);_class6.prototype.__init13.call(this);
+  constructor(config = {}) {;_class7.prototype.__init17.call(this);_class7.prototype.__init18.call(this);_class7.prototype.__init19.call(this);
     const max = _nullishCoalesce(config.maxEntries, () => ( 1024));
     this.maxEntries = Math.max(1, Math.floor(max));
     this.onEvict = config.onEvict;
@@ -4025,7 +4261,7 @@ var LRUCache = (_class6 = class {
       this.onEvict(1);
     }
   }
-}, _class6);
+}, _class7);
 
 // src/http/lifecycle/responseCache.ts
 function clamp3(n, min, max) {
@@ -4035,23 +4271,23 @@ function safeEmit2(onEvent, event) {
   if (!onEvent) return;
   try {
     onEvent(event);
-  } catch (e11) {
+  } catch (e12) {
   }
 }
 function withCache(config) {
-  const ttlSeconds = clamp3(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _92 => _92.ttlSeconds]), () => ( 60)), 1, 86400);
+  const ttlSeconds = clamp3(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _99 => _99.ttlSeconds]), () => ( 60)), 1, 86400);
   const ttlMs = ttlSeconds * 1e3;
-  const maxEntries = Math.max(1, Math.floor(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _93 => _93.maxEntries]), () => ( 1024))));
-  const staleWhileRevalidate = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _94 => _94.staleWhileRevalidate]), () => ( false));
-  const cachePolicy = _optionalChain([config, 'optionalAccess', _95 => _95.cachePolicy]);
-  const cacheRelevantHeaders = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _96 => _96.cacheRelevantHeaders]), () => ( []));
-  const baseUrl = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _97 => _97.baseUrl]), () => ( ""));
-  const onEvent = _optionalChain([config, 'optionalAccess', _98 => _98.onEvent]);
-  const onLifecycleEvent = _optionalChain([config, 'optionalAccess', _99 => _99.onLifecycleEvent]);
+  const maxEntries = Math.max(1, Math.floor(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _100 => _100.maxEntries]), () => ( 1024))));
+  const staleWhileRevalidate = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _101 => _101.staleWhileRevalidate]), () => ( false));
+  const cachePolicy = _optionalChain([config, 'optionalAccess', _102 => _102.cachePolicy]);
+  const cacheRelevantHeaders = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _103 => _103.cacheRelevantHeaders]), () => ( []));
+  const baseUrl = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _104 => _104.baseUrl]), () => ( ""));
+  const onEvent = _optionalChain([config, 'optionalAccess', _105 => _105.onEvent]);
+  const onLifecycleEvent = _optionalChain([config, 'optionalAccess', _106 => _106.onLifecycleEvent]);
   const cacheKeyCtx = makeCacheKeyContext(baseUrl, cacheRelevantHeaders);
   const cache = new LRUCache({
     maxEntries,
-    onEvict: (count) => _optionalChain([onLifecycleEvent, 'optionalCall', _100 => _100({ type: "cache-eviction", count })])
+    onEvict: (count) => _optionalChain([onLifecycleEvent, 'optionalCall', _107 => _107({ type: "cache-eviction", count })])
   });
   const revalidating = /* @__PURE__ */ new Set();
   const invalidate = (key) => {
@@ -4072,11 +4308,11 @@ function withCache(config) {
         register: (env, cb) => {
           const cached = cache.get(key);
           if (cached !== void 0) {
-            _optionalChain([onLifecycleEvent, 'optionalCall', _101 => _101({ type: "cache-hit", cacheKey: key })]);
+            _optionalChain([onLifecycleEvent, 'optionalCall', _108 => _108({ type: "cache-hit", cacheKey: key })]);
             cb({ _tag: "Success", value: cached });
             return;
           }
-          _optionalChain([onLifecycleEvent, 'optionalCall', _102 => _102({ type: "cache-miss", cacheKey: key })]);
+          _optionalChain([onLifecycleEvent, 'optionalCall', _109 => _109({ type: "cache-miss", cacheKey: key })]);
           const innerEffect = next(req);
           return _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, innerEffect, env, (exit) => {
             if (exit._tag === "Success") {
@@ -4133,16 +4369,16 @@ function withCache(config) {
           if (cached !== void 0) {
             const expiresAt = expirationMap.get(key);
             if (expiresAt !== void 0 && now() < expiresAt) {
-              _optionalChain([onLifecycleEvent, 'optionalCall', _103 => _103({ type: "cache-hit", cacheKey: key })]);
+              _optionalChain([onLifecycleEvent, 'optionalCall', _110 => _110({ type: "cache-hit", cacheKey: key })]);
               cb({ _tag: "Success", value: cached });
               return;
             }
-            _optionalChain([onLifecycleEvent, 'optionalCall', _104 => _104({ type: "cache-hit", cacheKey: key })]);
+            _optionalChain([onLifecycleEvent, 'optionalCall', _111 => _111({ type: "cache-hit", cacheKey: key })]);
             cb({ _tag: "Success", value: cached });
             triggerRevalidation(next, req, key);
             return;
           }
-          _optionalChain([onLifecycleEvent, 'optionalCall', _105 => _105({ type: "cache-miss", cacheKey: key })]);
+          _optionalChain([onLifecycleEvent, 'optionalCall', _112 => _112({ type: "cache-miss", cacheKey: key })]);
           const innerEffect = next(req);
           const handleSuccess = (res) => {
             swrStoreIfCacheable(req, res, key);
@@ -4202,9 +4438,9 @@ function comparePriority(a, b) {
   if (a.priority !== b.priority) return a.priority - b.priority;
   return a.arrivalOrder - b.arrivalOrder;
 }
-var PriorityQueue = (_class7 = class {constructor() { _class7.prototype.__init14.call(this);_class7.prototype.__init15.call(this); }
-  __init14() {this.heap = []}
-  __init15() {this.counter = 0}
+var PriorityQueue = (_class8 = class {constructor() { _class8.prototype.__init20.call(this);_class8.prototype.__init21.call(this); }
+  __init20() {this.heap = []}
+  __init21() {this.counter = 0}
   /**
    * Returns the number of entries in the queue (including cancelled entries).
    *
@@ -4388,14 +4624,14 @@ var PriorityQueue = (_class7 = class {constructor() { _class7.prototype.__init14
       index = smallest;
     }
   }
-}, _class7);
+}, _class8);
 
 // src/http/lifecycle/priorityScheduler.ts
 var DEFAULT_CONCURRENCY2 = 32;
 function extractPriority(req) {
   const fromPolicy = getHttpRequestPolicy(req).priority;
   if (fromPolicy !== void 0) return clampPriority2(fromPolicy);
-  const fromInit = _optionalChain([req, 'access', _106 => _106.init, 'optionalAccess', _107 => _107.priority]);
+  const fromInit = _optionalChain([req, 'access', _113 => _113.init, 'optionalAccess', _114 => _114.priority]);
   if (fromInit !== void 0) return clampPriority2(fromInit);
   return 5;
 }
@@ -4403,13 +4639,13 @@ function safeEmit3(onEvent, event) {
   if (!onEvent) return;
   try {
     onEvent(event);
-  } catch (e12) {
+  } catch (e13) {
   }
 }
 function withPriority(config) {
-  const concurrency = resolveConcurrency(_optionalChain([config, 'optionalAccess', _108 => _108.concurrency]));
-  const queueTimeoutMs = resolveQueueTimeout(_optionalChain([config, 'optionalAccess', _109 => _109.queueTimeoutMs]));
-  const onEvent = _optionalChain([config, 'optionalAccess', _110 => _110.onEvent]);
+  const concurrency = resolveConcurrency(_optionalChain([config, 'optionalAccess', _115 => _115.concurrency]));
+  const queueTimeoutMs = resolveQueueTimeout(_optionalChain([config, 'optionalAccess', _116 => _116.queueTimeoutMs]));
+  const onEvent = _optionalChain([config, 'optionalAccess', _117 => _117.onEvent]);
   const queue = new PriorityQueue();
   let inFlight = 0;
   const queueDepth = () => {
@@ -4454,7 +4690,7 @@ function withPriority(config) {
               cb({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail({ _tag: "Abort" }) });
             };
             signal.addEventListener("abort", abortHandler, { once: true });
-          } else if (_optionalChain([signal, 'optionalAccess', _111 => _111.aborted])) {
+          } else if (_optionalChain([signal, 'optionalAccess', _118 => _118.aborted])) {
             entry.cancelled = true;
             cb({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail({ _tag: "Abort" }) });
             return;
@@ -4500,7 +4736,7 @@ function withPriority(config) {
           clearTimeout(queued.timer);
           queued.timer = void 0;
         }
-        if (_optionalChain([queued, 'access', _112 => _112.signal, 'optionalAccess', _113 => _113.aborted])) {
+        if (_optionalChain([queued, 'access', _119 => _119.signal, 'optionalAccess', _120 => _120.aborted])) {
           queued.cb({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail({ _tag: "Abort" }) });
           continue;
         }
@@ -4520,23 +4756,23 @@ function resolveQueueTimeout(value) {
   return n > 0 ? n : void 0;
 }
 function getSignal(req) {
-  return _optionalChain([req, 'access', _114 => _114.init, 'optionalAccess', _115 => _115.signal]);
+  return _optionalChain([req, 'access', _121 => _121.init, 'optionalAccess', _122 => _122.signal]);
 }
 
 // src/http/lifecycle/stats.ts
-var LifecycleStatsTracker = (_class8 = class {
-  __init16() {this._cacheHits = 0}
-  __init17() {this._cacheMisses = 0}
-  __init18() {this._cacheEvictions = 0}
-  __init19() {this._dedupHits = 0}
-  __init20() {this._dedupActive = 0}
-  __init21() {this._queueDepth = 0}
-  __init22() {this._requestsStarted = 0}
-  __init23() {this._requestsCompleted = 0}
-  __init24() {this._requestsFailed = 0}
-  __init25() {this._retries = 0}
-  __init26() {this._batchDispatches = 0}
-  __init27() {this._batchedRequests = 0}
+var LifecycleStatsTracker = (_class9 = class {
+  __init22() {this._cacheHits = 0}
+  __init23() {this._cacheMisses = 0}
+  __init24() {this._cacheEvictions = 0}
+  __init25() {this._dedupHits = 0}
+  __init26() {this._dedupActive = 0}
+  __init27() {this._queueDepth = 0}
+  __init28() {this._requestsStarted = 0}
+  __init29() {this._requestsCompleted = 0}
+  __init30() {this._requestsFailed = 0}
+  __init31() {this._retries = 0}
+  __init32() {this._batchDispatches = 0}
+  __init33() {this._batchedRequests = 0}
   
   
   /**
@@ -4556,7 +4792,7 @@ var LifecycleStatsTracker = (_class8 = class {
    * });
    * ```
    */
-  constructor(opts) {;_class8.prototype.__init16.call(this);_class8.prototype.__init17.call(this);_class8.prototype.__init18.call(this);_class8.prototype.__init19.call(this);_class8.prototype.__init20.call(this);_class8.prototype.__init21.call(this);_class8.prototype.__init22.call(this);_class8.prototype.__init23.call(this);_class8.prototype.__init24.call(this);_class8.prototype.__init25.call(this);_class8.prototype.__init26.call(this);_class8.prototype.__init27.call(this);
+  constructor(opts) {;_class9.prototype.__init22.call(this);_class9.prototype.__init23.call(this);_class9.prototype.__init24.call(this);_class9.prototype.__init25.call(this);_class9.prototype.__init26.call(this);_class9.prototype.__init27.call(this);_class9.prototype.__init28.call(this);_class9.prototype.__init29.call(this);_class9.prototype.__init30.call(this);_class9.prototype.__init31.call(this);_class9.prototype.__init32.call(this);_class9.prototype.__init33.call(this);
     this._onEvent = opts.onEvent;
     this._wireStats = opts.wireStats;
   }
@@ -4741,7 +4977,7 @@ var LifecycleStatsTracker = (_class8 = class {
         ...extra
       };
       this._onEvent(event);
-    } catch (e13) {
+    } catch (e14) {
     }
   }
   // --- Snapshot ---
@@ -4783,7 +5019,7 @@ var LifecycleStatsTracker = (_class8 = class {
       wire: this._wireStats()
     });
   }
-}, _class8);
+}, _class9);
 
 // src/http/prewarm/validation.ts
 function validateOrigin(origin) {
@@ -4804,7 +5040,7 @@ function validateOrigin(origin) {
   let parsed;
   try {
     parsed = new URL(stripped);
-  } catch (e14) {
+  } catch (e15) {
     throw new Error(
       `validateOrigin: invalid origin "${origin}" \u2014 must be a valid URL origin (scheme + host + optional port)`
     );
@@ -4909,9 +5145,9 @@ async function executeProbeViaClient(client, url, signal) {
         resolve({ ok: true });
       } else {
         const cause = exit.cause;
-        if (_optionalChain([cause, 'optionalAccess', _116 => _116._tag]) === "Fail") {
+        if (_optionalChain([cause, 'optionalAccess', _123 => _123._tag]) === "Fail") {
           const err = cause.error;
-          resolve({ ok: false, error: _nullishCoalesce(_nullishCoalesce(_optionalChain([err, 'optionalAccess', _117 => _117.message]), () => ( _optionalChain([err, 'optionalAccess', _118 => _118._tag]))), () => ( "Unknown error")) });
+          resolve({ ok: false, error: _nullishCoalesce(_nullishCoalesce(_optionalChain([err, 'optionalAccess', _124 => _124.message]), () => ( _optionalChain([err, 'optionalAccess', _125 => _125._tag]))), () => ( "Unknown error")) });
         } else {
           resolve({ ok: false, error: "cancelled" });
         }
@@ -5069,7 +5305,7 @@ function makePrewarmManager(config) {
     if (onEvent) {
       try {
         onEvent(event);
-      } catch (e15) {
+      } catch (e16) {
       }
     }
   }
@@ -5287,7 +5523,7 @@ function makeLifecycleClient(config = {}) {
     priorityMiddleware = withPriority({
       ...priorityConfig2,
       onEvent: (event) => {
-        tracker.setQueueDepth(_nullishCoalesce(_optionalChain([priorityMiddleware, 'optionalAccess', _119 => _119.queueDepth, 'call', _120 => _120()]), () => ( 0)));
+        tracker.setQueueDepth(_nullishCoalesce(_optionalChain([priorityMiddleware, 'optionalAccess', _126 => _126.queueDepth, 'call', _127 => _127()]), () => ( 0)));
         tracker.emit(event.type, { priority: event.priority });
       }
     });
@@ -5350,9 +5586,9 @@ function makeLifecycleClient(config = {}) {
           attempt: event.attempt,
           delayMs: event.delayMs,
           status: event.status,
-          errorTag: _optionalChain([event, 'access', _121 => _121.error, 'optionalAccess', _122 => _122._tag])
+          errorTag: _optionalChain([event, 'access', _128 => _128.error, 'optionalAccess', _129 => _129._tag])
         });
-        _optionalChain([retryConfig2, 'access', _123 => _123.onRetry, 'optionalCall', _124 => _124(event)]);
+        _optionalChain([retryConfig2, 'access', _130 => _130.onRetry, 'optionalCall', _131 => _131(event)]);
       }
     })(composedFn);
   }
@@ -5384,13 +5620,13 @@ function makeLifecycleClient(config = {}) {
     }
   }
   return buildLifecycleClient(composedFn, tracker, {
-    cacheInvalidate: _nullishCoalesce(_optionalChain([cacheLayer, 'optionalAccess', _125 => _125.invalidate]), () => ( noopInvalidate)),
-    cacheClear: _nullishCoalesce(_optionalChain([cacheLayer, 'optionalAccess', _126 => _126.clear]), () => ( noopClear)),
+    cacheInvalidate: _nullishCoalesce(_optionalChain([cacheLayer, 'optionalAccess', _132 => _132.invalidate]), () => ( noopInvalidate)),
+    cacheClear: _nullishCoalesce(_optionalChain([cacheLayer, 'optionalAccess', _133 => _133.clear]), () => ( noopClear)),
     cancelAll: () => cancelActiveRequests(activeCancelers, prewarmMgr),
     shutdown: () => shutdownClient(activeCancelers, prewarmMgr, wireClient.shutdown),
     activeCancelers,
     adaptiveLimiter: wireClient.adaptiveLimiter,
-    queueDepth: _optionalChain([priorityMiddleware, 'optionalAccess', _127 => _127.queueDepth]),
+    queueDepth: _optionalChain([priorityMiddleware, 'optionalAccess', _134 => _134.queueDepth]),
     prewarmManager: prewarmMgr,
     afterResponse: hasPrewarm ? config.prewarm.afterResponse : void 0
   });
@@ -5402,14 +5638,14 @@ function noopInvalidate(_key) {
 }
 function noopClear() {
 }
-function buildLifecycleClient(fn2, tracker, internals) {
-  const client = (req) => trackRequest(fn2, req, tracker, internals);
+function buildLifecycleClient(fn3, tracker, internals) {
+  const client = (req) => trackRequest(fn3, req, tracker, internals);
   const stats = () => {
-    tracker.setQueueDepth(_nullishCoalesce(_optionalChain([internals, 'access', _128 => _128.queueDepth, 'optionalCall', _129 => _129()]), () => ( 0)));
+    tracker.setQueueDepth(_nullishCoalesce(_optionalChain([internals, 'access', _135 => _135.queueDepth, 'optionalCall', _136 => _136()]), () => ( 0)));
     return tracker.snapshot();
   };
   const withMw = (mw) => {
-    const wrappedFn = mw(withLifecycleMetadata(fn2, internals));
+    const wrappedFn = mw(withLifecycleMetadata(fn3, internals));
     return buildLifecycleClient(wrappedFn, tracker, internals);
   };
   const lifecycleClient = Object.assign(client, {
@@ -5425,9 +5661,9 @@ function buildLifecycleClient(fn2, tracker, internals) {
   });
   return lifecycleClient;
 }
-function withLifecycleMetadata(fn2, internals) {
-  if (!internals.adaptiveLimiter) return fn2;
-  return Object.assign(((req) => fn2(req)), {
+function withLifecycleMetadata(fn3, internals) {
+  if (!internals.adaptiveLimiter) return fn3;
+  return Object.assign(((req) => fn3(req)), {
     adaptiveLimiter: internals.adaptiveLimiter
   });
 }
@@ -5435,7 +5671,7 @@ function cancelActiveRequests(activeCancelers, prewarmMgr) {
   for (const cancel of Array.from(activeCancelers).reverse()) {
     try {
       cancel();
-    } catch (e16) {
+    } catch (e17) {
     }
   }
   if (prewarmMgr) {
@@ -5445,14 +5681,14 @@ function cancelActiveRequests(activeCancelers, prewarmMgr) {
 }
 function shutdownClient(activeCancelers, prewarmMgr, wireShutdown) {
   cancelActiveRequests(activeCancelers, prewarmMgr);
-  _optionalChain([wireShutdown, 'optionalCall', _130 => _130()]);
+  _optionalChain([wireShutdown, 'optionalCall', _137 => _137()]);
   return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0);
 }
-function trackRequest(fn2, req, tracker, internals) {
+function trackRequest(fn3, req, tracker, internals) {
   return {
     _tag: "Async",
     register: (env, cb) => {
-      const previousSignal = _optionalChain([req, 'access', _131 => _131.init, 'optionalAccess', _132 => _132.signal]);
+      const previousSignal = _optionalChain([req, 'access', _138 => _138.init, 'optionalAccess', _139 => _139.signal]);
       let done = false;
       let abortedByPreviousSignal = false;
       let abortedByLifecycle = false;
@@ -5461,7 +5697,7 @@ function trackRequest(fn2, req, tracker, internals) {
         if (done) return;
         done = true;
         const exit = (abortedByPreviousSignal || abortedByLifecycle) && exit0._tag === "Failure" && _chunkMVGUEJ5Zcjs.Cause.isInterruptedOnly(exit0.cause) ? { _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail({ _tag: "Abort" }) } : exit0;
-        _optionalChain([previousSignal, 'optionalAccess', _133 => _133.removeEventListener, 'call', _134 => _134("abort", abortFromPrevious)]);
+        _optionalChain([previousSignal, 'optionalAccess', _140 => _140.removeEventListener, 'call', _141 => _141("abort", abortFromPrevious)]);
         internals.activeCancelers.delete(cancelFromLifecycle);
         if (exit._tag === "Success") {
           tracker.requestCompleted();
@@ -5474,7 +5710,7 @@ function trackRequest(fn2, req, tracker, internals) {
                   });
                 }
               }
-            } catch (e17) {
+            } catch (e18) {
             }
           }
         } else {
@@ -5499,18 +5735,18 @@ function trackRequest(fn2, req, tracker, internals) {
         abortedByPreviousSignal = true;
         cancelActive();
       };
-      if (!_optionalChain([previousSignal, 'optionalAccess', _135 => _135.aborted])) {
-        _optionalChain([previousSignal, 'optionalAccess', _136 => _136.addEventListener, 'call', _137 => _137("abort", abortFromPrevious, { once: true })]);
+      if (!_optionalChain([previousSignal, 'optionalAccess', _142 => _142.aborted])) {
+        _optionalChain([previousSignal, 'optionalAccess', _143 => _143.addEventListener, 'call', _144 => _144("abort", abortFromPrevious, { once: true })]);
       }
       internals.activeCancelers.add(cancelFromLifecycle);
       tracker.requestStarted();
       tracker.emit("request-start");
-      if (_optionalChain([previousSignal, 'optionalAccess', _138 => _138.aborted])) {
+      if (_optionalChain([previousSignal, 'optionalAccess', _145 => _145.aborted])) {
         abortFromPrevious();
         return () => void 0;
       }
       try {
-        cancelInner = _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, fn2(req), env, finish);
+        cancelInner = _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, fn3(req), env, finish);
       } catch (error) {
         finish({
           _tag: "Failure",
@@ -5625,7 +5861,7 @@ function processResponse(res, decompressor, enabledEncodings, stats) {
   const contentEncodingKey = Object.keys(res.headers).find(
     (k) => k.toLowerCase() === "content-encoding"
   );
-  const contentEncodingValue = contentEncodingKey ? _optionalChain([res, 'access', _139 => _139.headers, 'access', _140 => _140[contentEncodingKey], 'optionalAccess', _141 => _141.trim, 'call', _142 => _142()]) : void 0;
+  const contentEncodingValue = contentEncodingKey ? _optionalChain([res, 'access', _146 => _146.headers, 'access', _147 => _147[contentEncodingKey], 'optionalAccess', _148 => _148.trim, 'call', _149 => _149()]) : void 0;
   if (!contentEncodingValue || contentEncodingValue.toLowerCase() === "identity") {
     stats.passthroughCount++;
     return res;
@@ -5700,7 +5936,7 @@ function processResponse(res, decompressor, enabledEncodings, stats) {
   };
 }
 function makeCompressionMiddleware(config) {
-  const enabledEncodings = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _143 => _143.encodings]), () => ( [...SUPPORTED_ENCODINGS]));
+  const enabledEncodings = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _150 => _150.encodings]), () => ( [...SUPPORTED_ENCODINGS]));
   const decompressor = createDecompressor();
   const mutableStats = emptyStats2();
   const middleware = (next) => {
@@ -5740,9 +5976,9 @@ function makeCompressionMiddleware(config) {
 var makeResponseCompressionMiddleware = makeCompressionMiddleware;
 var DEFAULT_REQUEST_COMPRESS_METHODS = ["POST", "PUT", "PATCH"];
 function makeRequestCompressionMiddleware(config) {
-  const encoding = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _144 => _144.encoding]), () => ( "gzip"));
-  const minBytes = Math.max(0, Math.floor(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _145 => _145.minBytes]), () => ( 1024))));
-  const methods = new Set((_nullishCoalesce(_optionalChain([config, 'optionalAccess', _146 => _146.methods]), () => ( DEFAULT_REQUEST_COMPRESS_METHODS))).map((m) => m.toUpperCase()));
+  const encoding = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _151 => _151.encoding]), () => ( "gzip"));
+  const minBytes = Math.max(0, Math.floor(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _152 => _152.minBytes]), () => ( 1024))));
+  const methods = new Set((_nullishCoalesce(_optionalChain([config, 'optionalAccess', _153 => _153.methods]), () => ( DEFAULT_REQUEST_COMPRESS_METHODS))).map((m) => m.toUpperCase()));
   const mutableStats = emptyRequestCompressionStats();
   const middleware = (next) => {
     return (req) => {
@@ -5786,7 +6022,7 @@ function compressRequest(req, encoding, minBytes, methods, stats) {
         "Content-Length": String(compressed.byteLength)
       })
     };
-  } catch (e18) {
+  } catch (e19) {
     stats.errorCount++;
     return req;
   }
@@ -5927,11 +6163,195 @@ function validatedJsonResponse(client, validator) {
 function previewJson(value) {
   try {
     return JSON.stringify(value);
-  } catch (e19) {
+  } catch (e20) {
     return "[unserializable]";
   }
 }
 
+// src/http/bareMetalClient.ts
+var fn2 = _chunkKPOL2YEOcjs.Schema.custom(
+  (value) => typeof value === "function",
+  "function"
+);
+var poolConfig2 = _chunkKPOL2YEOcjs.Schema.union([
+  _chunkKPOL2YEOcjs.Schema.literal(false),
+  _chunkKPOL2YEOcjs.Schema.object(
+    {
+      concurrency: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      maxQueue: _chunkKPOL2YEOcjs.Schema.number({ min: 0, int: true }).optional(),
+      queueTimeoutMs: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      key: _chunkKPOL2YEOcjs.Schema.union([
+        _chunkKPOL2YEOcjs.Schema.enum(["global", "origin", "host"]),
+        fn2
+      ]).optional(),
+      engine: _chunkKPOL2YEOcjs.Schema.enum(["ts", "wasm"]).optional(),
+      wasm: _chunkKPOL2YEOcjs.Schema.boolean().optional()
+    },
+    { unknownKeys: "passthrough" }
+  )
+]);
+var adaptiveLimiterConfig2 = _chunkKPOL2YEOcjs.Schema.union([
+  _chunkKPOL2YEOcjs.Schema.literal(false),
+  _chunkKPOL2YEOcjs.Schema.object(
+    {
+      preset: _chunkKPOL2YEOcjs.Schema.enum(["conservative", "balanced", "aggressive"]).optional(),
+      initialLimit: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      minLimit: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      maxLimit: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      smoothingFactor: _chunkKPOL2YEOcjs.Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "smoothingFactor must be in (0, 1]").optional(),
+      probeInterval: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      probeJitterRatio: _chunkKPOL2YEOcjs.Schema.number({ min: 0, max: 1 }).optional(),
+      windowSize: _chunkKPOL2YEOcjs.Schema.number({ min: 2, int: true }).optional(),
+      minSamples: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      baselineStrategy: _chunkKPOL2YEOcjs.Schema.enum(["min", "p5", "ema-low"]).optional(),
+      decreaseCooldownSamples: _chunkKPOL2YEOcjs.Schema.number({ min: 0, int: true }).optional(),
+      historySize: _chunkKPOL2YEOcjs.Schema.number({ min: 0, int: true }).optional(),
+      windowDecayFactor: _chunkKPOL2YEOcjs.Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "windowDecayFactor must be in (0, 1]").optional(),
+      errorWeight: _chunkKPOL2YEOcjs.Schema.number({ min: 0, max: 1 }).optional(),
+      errorSmoothingFactor: _chunkKPOL2YEOcjs.Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "errorSmoothingFactor must be in (0, 1]").optional(),
+      errorStatusThreshold: _chunkKPOL2YEOcjs.Schema.number({ min: 100, max: 599, int: true }).optional(),
+      queueStrategy: _chunkKPOL2YEOcjs.Schema.enum(["fifo", "priority"]).optional(),
+      queueLoadShedding: _chunkKPOL2YEOcjs.Schema.enum(["reject-new", "priority-evict"]).optional(),
+      rejectionBackoffThreshold: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      rejectionBackoffMs: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      stateTtlMs: _chunkKPOL2YEOcjs.Schema.union([_chunkKPOL2YEOcjs.Schema.literal(false), _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true })]).optional(),
+      warmupRequests: _chunkKPOL2YEOcjs.Schema.number({ min: 0, int: true }).optional(),
+      decreaseThreshold: _chunkKPOL2YEOcjs.Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "decreaseThreshold must be in (0, 1]").optional(),
+      increaseThreshold: _chunkKPOL2YEOcjs.Schema.number({ min: 1 }).optional(),
+      maxDecreaseRatio: _chunkKPOL2YEOcjs.Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "maxDecreaseRatio must be in (0, 1]").optional(),
+      headroomStrategy: _chunkKPOL2YEOcjs.Schema.union([
+        _chunkKPOL2YEOcjs.Schema.number({ min: 1 }),
+        _chunkKPOL2YEOcjs.Schema.enum(["fixed", "proportional"]),
+        fn2,
+        _chunkKPOL2YEOcjs.Schema.object({ type: _chunkKPOL2YEOcjs.Schema.literal("fixed"), value: _chunkKPOL2YEOcjs.Schema.number({ min: 1 }).optional() }, { unknownKeys: "passthrough" }),
+        _chunkKPOL2YEOcjs.Schema.object({
+          type: _chunkKPOL2YEOcjs.Schema.literal("proportional"),
+          ratio: _chunkKPOL2YEOcjs.Schema.number({ min: 0 }).refine((n) => n > 0, "ratio must be > 0").optional(),
+          min: _chunkKPOL2YEOcjs.Schema.number({ min: 1 }).optional(),
+          max: _chunkKPOL2YEOcjs.Schema.number({ min: 1 }).optional()
+        }, { unknownKeys: "passthrough" })
+      ]).optional(),
+      slowStartRecovery: _chunkKPOL2YEOcjs.Schema.boolean().optional(),
+      slowStartSaturationThreshold: _chunkKPOL2YEOcjs.Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "slowStartSaturationThreshold must be in (0, 1]").optional(),
+      slowStartSaturationSamples: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      key: _chunkKPOL2YEOcjs.Schema.union([_chunkKPOL2YEOcjs.Schema.enum(["global", "origin", "host"]), fn2]).optional(),
+      maxQueue: _chunkKPOL2YEOcjs.Schema.number({ min: 0, int: true }).optional(),
+      queueTimeoutMs: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+      onLimitChange: fn2.optional(),
+      percentile: _chunkKPOL2YEOcjs.Schema.enum(["p50", "p99"]).optional()
+    },
+    { unknownKeys: "passthrough" }
+  )
+]);
+var bareMetalConfigSchema = _chunkKPOL2YEOcjs.Schema.object(
+  {
+    baseUrl: _chunkKPOL2YEOcjs.Schema.string().optional(),
+    headers: _chunkKPOL2YEOcjs.Schema.record(_chunkKPOL2YEOcjs.Schema.string()).optional(),
+    timeoutMs: _chunkKPOL2YEOcjs.Schema.number({ min: 1, int: true }).optional(),
+    transport: fn2.optional(),
+    streamTransport: fn2.optional(),
+    pool: poolConfig2.optional(),
+    adaptiveLimiter: adaptiveLimiterConfig2.optional(),
+    onEvent: fn2.optional()
+  },
+  { unknownKeys: "passthrough" }
+);
+function validateBareMetalConfig(config) {
+  _chunkKPOL2YEOcjs.parseConfig.call(void 0, "BareMetalHttpConfig", bareMetalConfigSchema, config);
+}
+var transportDestroy2 = (transport) => {
+  const destroy = transport.destroy;
+  return typeof destroy === "function" ? () => destroy.call(transport) : void 0;
+};
+function makeBareMetalHttp(cfg = {}) {
+  validateBareMetalConfig(cfg);
+  const baseUrl = _nullishCoalesce(cfg.baseUrl, () => ( ""));
+  const defaultHeaders = _nullishCoalesce(cfg.headers, () => ( {}));
+  const normalize = normalizeRequest(defaultHeaders);
+  const adaptiveLimiter = makeAdaptiveLimiter(cfg);
+  const pool = adaptiveLimiter ? void 0 : makePool(cfg);
+  const metrics = makeHttpStats(pool, adaptiveLimiter);
+  const transport = _nullishCoalesce(cfg.transport, () => ( makeFetchTransport()));
+  const destroyTransport = transportDestroy2(transport);
+  const run = (req0) => {
+    const req = normalize(req0);
+    const url = resolveRequestUrl(req, baseUrl);
+    if (!(url instanceof URL)) return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, url);
+    const timeoutMs = resolvePositiveTimeout(_nullishCoalesce(req.timeoutMs, () => ( cfg.timeoutMs)));
+    if (!adaptiveLimiter && !pool && timeoutMs === void 0) {
+      return runDirectTransport(req, url, transport, metrics);
+    }
+    return runPoolTransport(req, url, transport, metrics, pool, adaptiveLimiter, void 0, timeoutMs);
+  };
+  const metadata = {};
+  if (adaptiveLimiter) metadata.adaptiveLimiter = adaptiveLimiter;
+  if (adaptiveLimiter || destroyTransport) {
+    metadata.destroy = () => {
+      _optionalChain([adaptiveLimiter, 'optionalAccess', _154 => _154.destroy, 'call', _155 => _155()]);
+      _optionalChain([destroyTransport, 'optionalCall', _156 => _156()]);
+    };
+    metadata.shutdown = () => {
+      _optionalChain([adaptiveLimiter, 'optionalAccess', _157 => _157.shutdown, 'call', _158 => _158()]);
+      _optionalChain([destroyTransport, 'optionalCall', _159 => _159()]);
+    };
+  }
+  return decorate(run, metrics.snapshot, metadata);
+}
+function makeBareMetalHttpStream(cfg = {}) {
+  validateBareMetalConfig(cfg);
+  const baseUrl = _nullishCoalesce(cfg.baseUrl, () => ( ""));
+  const defaultHeaders = _nullishCoalesce(cfg.headers, () => ( {}));
+  const normalize = normalizeRequest(defaultHeaders);
+  const adaptiveLimiter = makeAdaptiveLimiter(cfg);
+  const pool = adaptiveLimiter ? void 0 : makePool(cfg);
+  const metrics = makeHttpStats(pool, adaptiveLimiter);
+  const transport = _nullishCoalesce(cfg.streamTransport, () => ( makeFetchStreamTransport()));
+  const run = (req0) => {
+    const req = normalize(req0);
+    const url = resolveRequestUrl(req, baseUrl);
+    if (!(url instanceof URL)) return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, url);
+    const timeoutMs = resolvePositiveTimeout(_nullishCoalesce(req.timeoutMs, () => ( cfg.timeoutMs)));
+    return _chunkJKHBEWQAcjs.fromPromiseAbortable.call(void 0, 
+      async (signal, env) => {
+        let lease;
+        const linkedSignal = linkAbortSignals(signal, _optionalChain([req, 'access', _160 => _160.init, 'optionalAccess', _161 => _161.signal]));
+        try {
+          if (linkedSignal.signal.aborted) throw abortErrorForSignal(linkedSignal.signal);
+          if (adaptiveLimiter) {
+            const key = resolveHttpPoolKey(adaptiveLimiter.keyResolver, req, url);
+            lease = await adaptiveLimiter.acquire(key, linkedSignal.signal, { priority: requestPriority(req) });
+          } else if (pool) {
+            const key = resolveHttpPoolKey(pool.keyResolver, req, url);
+            lease = await pool.acquire(key, linkedSignal.signal);
+          }
+          const response = await runTransportEffect(
+            transport({ request: req, url, signal: linkedSignal.signal }),
+            env,
+            linkedSignal.signal
+          );
+          releaseSuccess(lease, adaptiveLimiter, response);
+          lease = void 0;
+          return response;
+        } finally {
+          linkedSignal.cleanup();
+          if (lease) {
+            releaseFailure(lease, adaptiveLimiter);
+          }
+        }
+      },
+      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);
+}
+
 // src/http/requestBuilder.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function splitHttpRequestInit(init) {
@@ -6029,17 +6449,18 @@ var PRESET_CONFIGS = {
   highThroughputProxy: PROXY_PRESET_CONFIG,
   balanced: BALANCED_PRESET_CONFIG,
   default: DEFAULT_PRESET_CONFIG,
-  production: DEFAULT_PRESET_CONFIG
+  production: DEFAULT_PRESET_CONFIG,
+  bareMetal: {}
 };
 function isDefaultCacheableResponse(req, res) {
   if (!DEFAULT_CACHEABLE_METHODS.has(req.method)) return false;
   if (res.status < 200 || res.status >= 400) return false;
-  const cacheControl = _optionalChain([headerValue, 'call', _147 => _147(res.headers, "cache-control"), 'optionalAccess', _148 => _148.toLowerCase, 'call', _149 => _149()]);
+  const cacheControl = _optionalChain([headerValue, 'call', _162 => _162(res.headers, "cache-control"), 'optionalAccess', _163 => _163.toLowerCase, 'call', _164 => _164()]);
   if (cacheControl) {
     const directives = cacheControl.split(",").map((part) => part.trim());
     if (directives.includes("no-store") || directives.includes("no-cache")) return false;
   }
-  if (_optionalChain([headerValue, 'call', _150 => _150(res.headers, "pragma"), 'optionalAccess', _151 => _151.toLowerCase, 'call', _152 => _152()]) === "no-cache") return false;
+  if (_optionalChain([headerValue, 'call', _165 => _165(res.headers, "pragma"), 'optionalAccess', _166 => _166.toLowerCase, 'call', _167 => _167()]) === "no-cache") return false;
   if (headerValue(res.headers, "set-cookie") !== void 0) return false;
   return true;
 }
@@ -6056,6 +6477,9 @@ function makeDefaultHttpClient(config = {}) {
     policyPresets,
     ...lifecycleOverrides
   } = config;
+  if (preset === "bareMetal") {
+    return buildBareMetalBranch(lifecycleOverrides, middleware, config);
+  }
   const lifecycleConfig2 = mergeLifecycleConfig(PRESET_CONFIGS[preset], lifecycleOverrides);
   let wire = makeLifecycleClient(lifecycleConfig2);
   const compressionResult = compression === false || compression === void 0 && isLeanPreset(preset) ? void 0 : makeCompressionMiddleware(compression === void 0 ? void 0 : compression);
@@ -6075,10 +6499,164 @@ function makeDefaultHttpClient(config = {}) {
   return buildDefaultClient(wire, {
     preset,
     features,
-    compressionStats: _optionalChain([compressionResult, 'optionalAccess', _153 => _153.stats]),
+    compressionStats: _optionalChain([compressionResult, 'optionalAccess', _168 => _168.stats]),
     useInlineDecode
   });
 }
+var LIFECYCLE_KEYS = [
+  "dedup",
+  "batch",
+  "cache",
+  "priority",
+  "retry",
+  "prewarm",
+  "adaptiveLimiter",
+  "compression"
+];
+function findIgnoredLifecycleKeys(overrides) {
+  const found = [];
+  for (const key of LIFECYCLE_KEYS) {
+    if (key in overrides && overrides[key] !== void 0 && overrides[key] !== false) {
+      found.push(key);
+    }
+  }
+  return found;
+}
+function extractBareMetalConfig(config) {
+  return {
+    baseUrl: config.baseUrl,
+    headers: config.headers,
+    timeoutMs: config.timeoutMs,
+    transport: config.transport,
+    streamTransport: config.streamTransport,
+    pool: config.pool,
+    adaptiveLimiter: void 0,
+    // bare-metal ignores adaptiveLimiter from lifecycle overrides
+    onEvent: config.onEvent
+  };
+}
+function buildBareMetalBranch(lifecycleOverrides, middleware, config) {
+  const ignored = findIgnoredLifecycleKeys(lifecycleOverrides);
+  if (ignored.length > 0 && config.onEvent) {
+    config.onEvent({
+      type: "warning",
+      message: `bareMetal preset ignores: ${ignored.join(", ")}`
+    });
+  }
+  let bareWire = makeBareMetalHttp(extractBareMetalConfig(config));
+  for (const mw of middleware) {
+    bareWire = bareWire.with(mw);
+  }
+  const features = Object.freeze({
+    dedup: false,
+    batch: false,
+    cache: false,
+    priority: false,
+    retry: false,
+    prewarm: false,
+    adaptiveLimiter: false,
+    compression: false,
+    middleware: middleware.length
+  });
+  return buildBareMetalDefaultClient(bareWire, { preset: "bareMetal", features });
+}
+function buildBareMetalDefaultClient(bareWire, meta) {
+  const withPromise = (eff) => _chunkMVGUEJ5Zcjs.withAsyncPromise.call(void 0, (e, env) => _chunkJKHBEWQAcjs.toPromise.call(void 0, e, env))(eff);
+  const requestRaw = (req) => bareWire(req);
+  const request = (req) => withPromise(requestRaw(req));
+  const get = (url, init) => request(buildHttpRequest("GET", url, init));
+  const post = (url, body, init) => request(buildHttpRequest("POST", url, init, body));
+  const getText = (url, init) => {
+    const req = buildHttpRequest("GET", url, init);
+    return withPromise(
+      _chunkMVGUEJ5Zcjs.mapTryAsync.call(void 0, requestRaw(req), (w) => toResponse(w, w.bodyText))
+    );
+  };
+  const getJson = ((url, init) => {
+    const req = setHeaderIfMissing("accept", "application/json")(
+      buildHttpRequest("GET", url, init)
+    );
+    return withPromise(
+      _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, requestRaw(req), (w) => decodeResponse(w, _optionalChain([init, 'optionalAccess', _169 => _169.schema]), _optionalChain([init, 'optionalAccess', _170 => _170.schemaName])))
+    );
+  });
+  const postJson = ((url, bodyObj, init) => {
+    return withPromise(
+      _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+        encodeJsonBodyEffect(bodyObj, _optionalChain([init, 'optionalAccess', _171 => _171.bodySchema]), { schemaName: _optionalChain([init, 'optionalAccess', _172 => _172.bodySchemaName]) }),
+        (bodyText) => {
+          const req = setHeaderIfMissing("content-type", "application/json")(
+            setHeaderIfMissing("accept", "application/json")(
+              buildHttpRequest("POST", url, init, bodyText)
+            )
+          );
+          return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, requestRaw(req), (w) => decodeResponse(w, _optionalChain([init, 'optionalAccess', _173 => _173.schema]), _optionalChain([init, 'optionalAccess', _174 => _174.schemaName])));
+        }
+      )
+    );
+  });
+  const wireAsLifecycle = Object.assign(
+    (req) => bareWire(req),
+    {
+      with: (mw) => {
+        const newBare = bareWire.with(mw);
+        return buildBareMetalDefaultClient(newBare, {
+          ...meta,
+          features: { ...meta.features, middleware: meta.features.middleware + 1 }
+        }).wire;
+      },
+      stats: () => ({
+        cacheHits: 0,
+        cacheMisses: 0,
+        cacheEvictions: 0,
+        dedupHits: 0,
+        dedupActive: 0,
+        queueDepth: 0,
+        requestsStarted: 0,
+        requestsCompleted: 0,
+        requestsFailed: 0,
+        retries: 0,
+        batchDispatches: 0,
+        batchedRequests: 0,
+        wire: bareWire.stats()
+      }),
+      cancelAll: () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0),
+      shutdown: () => {
+        _optionalChain([bareWire, 'access', _175 => _175.shutdown, 'optionalCall', _176 => _176()]);
+        return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0);
+      },
+      cache: {
+        invalidate: () => {
+        },
+        clear: () => {
+        }
+      },
+      ...bareWire.adaptiveLimiter ? { adaptiveLimiter: bareWire.adaptiveLimiter } : {}
+    }
+  );
+  return {
+    request,
+    get,
+    post,
+    getText,
+    getJson,
+    postJson,
+    with: (mw) => buildBareMetalDefaultClient(bareWire.with(mw), {
+      ...meta,
+      features: {
+        ...meta.features,
+        middleware: meta.features.middleware + 1
+      }
+    }),
+    wire: wireAsLifecycle,
+    stats: () => wireAsLifecycle.stats(),
+    cache: wireAsLifecycle.cache,
+    cancelAll: wireAsLifecycle.cancelAll,
+    shutdown: wireAsLifecycle.shutdown,
+    preset: meta.preset,
+    features: meta.features
+  };
+}
 function buildDefaultClient(wire, meta) {
   const withPromise = (eff) => _chunkMVGUEJ5Zcjs.withAsyncPromise.call(void 0, (e, env) => _chunkJKHBEWQAcjs.toPromise.call(void 0, e, env))(eff);
   const requestRaw = (req) => wire(req);
@@ -6097,24 +6675,24 @@ function buildDefaultClient(wire, meta) {
     );
     if (meta.useInlineDecode) {
       return withPromise(
-        fusedWireAndDecode(requestRaw(req), _optionalChain([init, 'optionalAccess', _154 => _154.schema]), _optionalChain([init, 'optionalAccess', _155 => _155.schemaName]))
+        fusedWireAndDecode(requestRaw(req), _optionalChain([init, 'optionalAccess', _177 => _177.schema]), _optionalChain([init, 'optionalAccess', _178 => _178.schemaName]))
       );
     }
     return withPromise(
-      _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, requestRaw(req), (w) => decodeResponse(w, _optionalChain([init, 'optionalAccess', _156 => _156.schema]), _optionalChain([init, 'optionalAccess', _157 => _157.schemaName])))
+      _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, requestRaw(req), (w) => decodeResponse(w, _optionalChain([init, 'optionalAccess', _179 => _179.schema]), _optionalChain([init, 'optionalAccess', _180 => _180.schemaName])))
     );
   });
   const postJson = ((url, bodyObj, init) => {
     return withPromise(
       _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
-        encodeJsonBodyEffect(bodyObj, _optionalChain([init, 'optionalAccess', _158 => _158.bodySchema]), { schemaName: _optionalChain([init, 'optionalAccess', _159 => _159.bodySchemaName]) }),
+        encodeJsonBodyEffect(bodyObj, _optionalChain([init, 'optionalAccess', _181 => _181.bodySchema]), { schemaName: _optionalChain([init, 'optionalAccess', _182 => _182.bodySchemaName]) }),
         (bodyText) => {
           const req = setHeaderIfMissing("content-type", "application/json")(
             setHeaderIfMissing("accept", "application/json")(
               buildHttpRequest("POST", url, init, bodyText)
             )
           );
-          return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, requestRaw(req), (w) => decodeResponse(w, _optionalChain([init, 'optionalAccess', _160 => _160.schema]), _optionalChain([init, 'optionalAccess', _161 => _161.schemaName])));
+          return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, requestRaw(req), (w) => decodeResponse(w, _optionalChain([init, 'optionalAccess', _183 => _183.schema]), _optionalChain([init, 'optionalAccess', _184 => _184.schemaName])));
         }
       )
     );
@@ -6259,7 +6837,7 @@ function isEnabled(value) {
   return value !== void 0 && value !== false;
 }
 function isLeanPreset(preset) {
-  return preset === "minimal" || preset === "proxy" || preset === "highThroughputProxy";
+  return preset === "minimal" || preset === "proxy" || preset === "highThroughputProxy" || preset === "bareMetal";
 }
 
 // src/http/layer.ts
@@ -6379,4 +6957,22 @@ function shutdownDefaultHttpClient(client) {
 
 
 
-exports.Request = Request; exports.setHeaderIfMissing = setHeaderIfMissing; exports.defineHttpPolicyPresets = defineHttpPolicyPresets; exports.httpPolicy = httpPolicy; exports.getHttpRequestPolicy = getHttpRequestPolicy; exports.withHttpRequestPolicy = withHttpRequestPolicy; exports.resolveHttpRequestPolicyPresets = resolveHttpRequestPolicyPresets; exports.withHttpPolicyPresets = withHttpPolicyPresets; exports.isHttpError = isHttpError; exports.isValidationError = isValidationError; exports.isCircuitBreakerOpen = isCircuitBreakerOpen; exports.isKnownHttpError = isKnownHttpError; exports.isAbortHttpError = isAbortHttpError; exports.isTimeoutHttpError = isTimeoutHttpError; exports.isFetchHttpError = isFetchHttpError; exports.httpErrorStatus = httpErrorStatus; exports.isRetryableHttpStatus = isRetryableHttpStatus; exports.isRetryableHttpError = isRetryableHttpError; exports.isExternalAbortError = isExternalAbortError; exports.isExternalTimeoutError = isExternalTimeoutError; exports.toHttpError = toHttpError; exports.matchHttpError = matchHttpError; exports.formatHttpError = formatHttpError; exports.defaultRetryableMethods = defaultRetryableMethods; exports.defaultRetryOnStatus = defaultRetryOnStatus; exports.defaultRetryOnError = defaultRetryOnError; exports.backoffDelayMs = backoffDelayMs; exports.retryAfterMs = retryAfterMs; exports.normalizeRetryBudget = normalizeRetryBudget; exports.withRetry = withRetry; exports.resolveHttpPoolKey = resolveHttpPoolKey; exports.HttpConcurrencyPool = HttpConcurrencyPool; exports.LatencyWindow = LatencyWindow; exports.EmaComputer = EmaComputer; exports.computeGradient = computeGradient; exports.computeNewLimit = computeNewLimit; exports.adaptiveLimiterPresets = adaptiveLimiterPresets; exports.makeAdaptiveLimiterConfig = makeAdaptiveLimiterConfig; exports.validateConfig = validateConfig; exports.resolveConfig = resolveConfig; exports.AdaptiveLimiter = AdaptiveLimiter; exports.isPromiseTransportDirect = isPromiseTransportDirect; exports.isTaggedHttpError = isTaggedHttpError; exports.isAbortError = isAbortError; exports.normalizeHttpError = normalizeHttpError; exports.headersOf = headersOf; exports.normalizeHttpHeaders = normalizeHttpHeaders; exports.abortErrorForSignal = abortErrorForSignal; exports.linkAbortSignals = linkAbortSignals; exports.makePromiseHttpTransport = makePromiseHttpTransport; exports.promiseHttpTransport = promiseHttpTransport; exports.makeFetchTransport = makeFetchTransport; exports.makeFetchStreamTransport = makeFetchStreamTransport; exports.decorate = decorate; exports.withMiddleware = withMiddleware; exports.normalizeHeadersInit = normalizeHeadersInit; exports.makeHttpStream = makeHttpStream; exports.noopSignal = noopSignal; exports.makeHttp = makeHttp; exports.withRetryStream = withRetryStream; exports.SEPARATOR = SEPARATOR; exports.DEFAULT_CACHE_RELEVANT_HEADERS = DEFAULT_CACHE_RELEVANT_HEADERS; exports.computeCacheKey = computeCacheKey; exports.parseCacheKey = parseCacheKey; exports.withDedup = withDedup; exports.withBatch = withBatch; exports.now = now; exports.LRUCache = LRUCache; exports.withCache = withCache; exports.clampPriority = clampPriority2; exports.PriorityQueue = PriorityQueue; exports.withPriority = withPriority; exports.LifecycleStatsTracker = LifecycleStatsTracker; exports.validateOrigin = validateOrigin; exports.detectPlatform = detectPlatform; exports.validateFetchAvailable = validateFetchAvailable; exports.executeProbe = executeProbe; exports.makeConnectionStateMap = makeConnectionStateMap; exports.makeBudgetSemaphore = makeBudgetSemaphore; exports.makePrewarmManager = makePrewarmManager; exports.makeLifecycleClient = makeLifecycleClient; exports.makeHttpClient = makeHttpClient; exports.SUPPORTED_ENCODINGS = SUPPORTED_ENCODINGS; exports.makeCompressionMiddleware = makeCompressionMiddleware; exports.makeResponseCompressionMiddleware = makeResponseCompressionMiddleware; exports.makeRequestCompressionMiddleware = makeRequestCompressionMiddleware; exports.makeJsonParseValidationError = makeJsonParseValidationError; exports.decodeJsonBody = decodeJsonBody; exports.encodeJsonBodyEffect = encodeJsonBodyEffect; exports.decodeJsonBodyEffect = decodeJsonBodyEffect; exports.validatedJson = validatedJson; exports.validatedJsonResponse = validatedJsonResponse; exports.buildHttpRequest = buildHttpRequest; exports.defaultHttpClientPreset = defaultHttpClientPreset; exports.makeDefaultHttpClient = makeDefaultHttpClient; exports.HttpClientService = HttpClientService; exports.makeDefaultHttpClientLayer = makeDefaultHttpClientLayer;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Request = Request; exports.setHeaderIfMissing = setHeaderIfMissing; exports.defineHttpPolicyPresets = defineHttpPolicyPresets; exports.httpPolicy = httpPolicy; exports.getHttpRequestPolicy = getHttpRequestPolicy; exports.withHttpRequestPolicy = withHttpRequestPolicy; exports.resolveHttpRequestPolicyPresets = resolveHttpRequestPolicyPresets; exports.withHttpPolicyPresets = withHttpPolicyPresets; exports.isHttpError = isHttpError; exports.isValidationError = isValidationError; exports.isCircuitBreakerOpen = isCircuitBreakerOpen; exports.isKnownHttpError = isKnownHttpError; exports.isAbortHttpError = isAbortHttpError; exports.isTimeoutHttpError = isTimeoutHttpError; exports.isFetchHttpError = isFetchHttpError; exports.httpErrorStatus = httpErrorStatus; exports.isRetryableHttpStatus = isRetryableHttpStatus; exports.isRetryableHttpError = isRetryableHttpError; exports.isExternalAbortError = isExternalAbortError; exports.isExternalTimeoutError = isExternalTimeoutError; exports.toHttpError = toHttpError; exports.matchHttpError = matchHttpError; exports.formatHttpError = formatHttpError; exports.defaultRetryableMethods = defaultRetryableMethods; exports.defaultRetryOnStatus = defaultRetryOnStatus; exports.defaultRetryOnError = defaultRetryOnError; exports.backoffDelayMs = backoffDelayMs; exports.retryAfterMs = retryAfterMs; exports.normalizeRetryBudget = normalizeRetryBudget; exports.withRetry = withRetry; exports.resolveHttpPoolKey = resolveHttpPoolKey; exports.HttpConcurrencyPool = HttpConcurrencyPool; exports.LatencyWindow = LatencyWindow; exports.EmaComputer = EmaComputer; exports.computeGradient = computeGradient; exports.computeNewLimit = computeNewLimit; exports.adaptiveLimiterPresets = adaptiveLimiterPresets; exports.makeAdaptiveLimiterConfig = makeAdaptiveLimiterConfig; exports.validateConfig = validateConfig; exports.resolveConfig = resolveConfig; exports.AdaptiveLimiter = AdaptiveLimiter; exports.isPromiseTransportDirect = isPromiseTransportDirect; exports.isTaggedHttpError = isTaggedHttpError; exports.isAbortError = isAbortError; exports.normalizeHttpError = normalizeHttpError; exports.headersOf = headersOf; exports.normalizeHttpHeaders = normalizeHttpHeaders; exports.abortErrorForSignal = abortErrorForSignal; exports.linkAbortSignals = linkAbortSignals; exports.makePromiseHttpTransport = makePromiseHttpTransport; exports.promiseHttpTransport = promiseHttpTransport; exports.makeFetchTransport = makeFetchTransport; exports.makeFetchStreamTransport = makeFetchStreamTransport; exports.decorate = decorate; exports.withMiddleware = withMiddleware; exports.decorateStream = decorateStream; exports.normalizeHeadersInit = normalizeHeadersInit; exports.normalizeRequest = normalizeRequest; exports.resolvePositiveTimeout = resolvePositiveTimeout; exports.makeHttpStats = makeHttpStats; exports.makePool = makePool; exports.makeAdaptiveLimiter = makeAdaptiveLimiter; exports.resolveRequestUrl = resolveRequestUrl; exports.fetchLabel = fetchLabel; exports.timeoutReason = timeoutReason; exports.requestPriority = requestPriority; exports.runTransportEffect = runTransportEffect; exports.runDirectTransport = runDirectTransport; exports.releaseSuccess = releaseSuccess; exports.releaseFailure = releaseFailure; exports.makeHttpStream = makeHttpStream; exports.noopSignal = noopSignal; exports.runPoolTransport = runPoolTransport; exports.makeHttp = makeHttp; exports.withRetryStream = withRetryStream; exports.SEPARATOR = SEPARATOR; exports.DEFAULT_CACHE_RELEVANT_HEADERS = DEFAULT_CACHE_RELEVANT_HEADERS; exports.computeCacheKey = computeCacheKey; exports.parseCacheKey = parseCacheKey; exports.withDedup = withDedup; exports.withBatch = withBatch; exports.now = now; exports.LRUCache = LRUCache; exports.withCache = withCache; exports.clampPriority = clampPriority2; exports.PriorityQueue = PriorityQueue; exports.withPriority = withPriority; exports.LifecycleStatsTracker = LifecycleStatsTracker; exports.validateOrigin = validateOrigin; exports.detectPlatform = detectPlatform; exports.validateFetchAvailable = validateFetchAvailable; exports.executeProbe = executeProbe; exports.makeConnectionStateMap = makeConnectionStateMap; exports.makeBudgetSemaphore = makeBudgetSemaphore; exports.makePrewarmManager = makePrewarmManager; exports.makeLifecycleClient = makeLifecycleClient; exports.makeHttpClient = makeHttpClient; exports.SUPPORTED_ENCODINGS = SUPPORTED_ENCODINGS; exports.makeCompressionMiddleware = makeCompressionMiddleware; exports.makeResponseCompressionMiddleware = makeResponseCompressionMiddleware; exports.makeRequestCompressionMiddleware = makeRequestCompressionMiddleware; exports.makeJsonParseValidationError = makeJsonParseValidationError; exports.decodeJsonBody = decodeJsonBody; exports.encodeJsonBodyEffect = encodeJsonBodyEffect; exports.decodeJsonBodyEffect = decodeJsonBodyEffect; exports.validatedJson = validatedJson; exports.validatedJsonResponse = validatedJsonResponse; exports.buildHttpRequest = buildHttpRequest; exports.validateBareMetalConfig = validateBareMetalConfig; exports.makeBareMetalHttp = makeBareMetalHttp; exports.makeBareMetalHttpStream = makeBareMetalHttpStream; exports.defaultHttpClientPreset = defaultHttpClientPreset; exports.makeDefaultHttpClient = makeDefaultHttpClient; exports.HttpClientService = HttpClientService; exports.makeDefaultHttpClientLayer = makeDefaultHttpClientLayer;