brass-runtime 1.19.1 → 1.20.0

package/dist/{chunk-ID2WOCBA.mjs → chunk-6NXQL3IC.mjs}

@@ -12,6 +12,8 @@ import {
 } from "./chunk-XRRC5BBM.mjs";
 import {
   fromPromiseAbortable,
+  recordAbortablePromiseFinish,
+  recordAbortablePromiseStart,
   resolveWasmModule,
   toPromise
 } from "./chunk-BFNBU47C.mjs";
@@ -3182,6 +3184,275 @@ var noopSignal = (() => {
   globalThis.__brassNoopSignal = s;
   return s;
 })();
+var PoolRequestState = class {
+  constructor(req, url, transport, metrics, pool, adaptiveLimiter, timerWheel, timeoutMs, env, cb, previousSignal, controller, signal, label, startedAt) {
+    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;
+  }
+  req;
+  url;
+  transport;
+  metrics;
+  pool;
+  adaptiveLimiter;
+  timerWheel;
+  timeoutMs;
+  env;
+  cb;
+  previousSignal;
+  controller;
+  signal;
+  label;
+  startedAt;
+  done = false;
+  cancelInner = void 0;
+  timerHandle = void 0;
+  timeoutHandle = void 0;
+  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;
+    recordAbortablePromiseFinish(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: Cause.fail(error) }, error);
+  }
+  abortCurrent(reason) {
+    if (!this.controller) return;
+    try {
+      this.controller.abort(reason);
+    } catch {
+      this.controller.abort();
+    }
+  }
+  /**
+   * Bound reference for addEventListener/removeEventListener.
+   * Only allocated when previousSignal is present (not on the hot path).
+   */
+  boundAbortFromPrevious = void 0;
+  abortFromPrevious() {
+    const error = this.previousSignal ? abortErrorForSignal(this.previousSignal) : { _tag: "Abort" };
+    this.abortCurrent(this.previousSignal?.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);
+      cancel?.();
+    });
+  }
+  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 = registerHttpEffect(
+          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));
+    }
+  }
+};
+var runPoolTransport = (req, url, transport, metrics, pool, adaptiveLimiter, timerWheel, timeoutMs) => ({
+  _tag: "Async",
+  register: (env, cb) => {
+    const previousSignal = req.init?.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
+    );
+    recordAbortablePromiseStart(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);
+        cancel?.();
+      };
+      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: Cause.interrupt() });
+          cancel?.();
+        };
+      }
+    } 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: Cause.interrupt() });
+          cancel?.();
+        };
+      }
+    }
+    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: Cause.interrupt() });
+      cancel?.();
+    };
+  }
+});
 function makeHttp(cfg = {}) {
   validateMakeHttpConfig(cfg);
   const baseUrl = cfg.baseUrl ?? "";
@@ -3200,42 +3471,7 @@ function makeHttp(cfg = {}) {
     if (!adaptiveLimiter && !pool && timeoutMs === void 0) {
       return runDirectTransport(req, url, transport, metrics);
     }
-    return fromPromiseAbortable(
-      async (signal, env) => {
-        let lease;
-        const linkedSignal = linkAbortSignals(signal, req.init?.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;
@@ -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(internals.queueDepth?.() ?? 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
   });
 }
@@ -5448,7 +5684,7 @@ function shutdownClient(activeCancelers, prewarmMgr, wireShutdown) {
   wireShutdown?.();
   return asyncSucceed(void 0);
 }
-function trackRequest(fn2, req, tracker, internals) {
+function trackRequest(fn3, req, tracker, internals) {
   return {
     _tag: "Async",
     register: (env, cb) => {
@@ -5510,7 +5746,7 @@ function trackRequest(fn2, req, tracker, internals) {
         return () => void 0;
       }
       try {
-        cancelInner = registerHttpEffect(fn2(req), env, finish);
+        cancelInner = registerHttpEffect(fn3(req), env, finish);
       } catch (error) {
         finish({
           _tag: "Failure",
@@ -5932,6 +6168,190 @@ function previewJson(value) {
   }
 }
 
+// src/http/bareMetalClient.ts
+var fn2 = Schema.custom(
+  (value) => typeof value === "function",
+  "function"
+);
+var poolConfig2 = Schema.union([
+  Schema.literal(false),
+  Schema.object(
+    {
+      concurrency: Schema.number({ min: 1, int: true }).optional(),
+      maxQueue: Schema.number({ min: 0, int: true }).optional(),
+      queueTimeoutMs: Schema.number({ min: 1, int: true }).optional(),
+      key: Schema.union([
+        Schema.enum(["global", "origin", "host"]),
+        fn2
+      ]).optional(),
+      engine: Schema.enum(["ts", "wasm"]).optional(),
+      wasm: Schema.boolean().optional()
+    },
+    { unknownKeys: "passthrough" }
+  )
+]);
+var adaptiveLimiterConfig2 = Schema.union([
+  Schema.literal(false),
+  Schema.object(
+    {
+      preset: Schema.enum(["conservative", "balanced", "aggressive"]).optional(),
+      initialLimit: Schema.number({ min: 1, int: true }).optional(),
+      minLimit: Schema.number({ min: 1, int: true }).optional(),
+      maxLimit: Schema.number({ min: 1, int: true }).optional(),
+      smoothingFactor: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "smoothingFactor must be in (0, 1]").optional(),
+      probeInterval: Schema.number({ min: 1, int: true }).optional(),
+      probeJitterRatio: Schema.number({ min: 0, max: 1 }).optional(),
+      windowSize: Schema.number({ min: 2, int: true }).optional(),
+      minSamples: Schema.number({ min: 1, int: true }).optional(),
+      baselineStrategy: Schema.enum(["min", "p5", "ema-low"]).optional(),
+      decreaseCooldownSamples: Schema.number({ min: 0, int: true }).optional(),
+      historySize: Schema.number({ min: 0, int: true }).optional(),
+      windowDecayFactor: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "windowDecayFactor must be in (0, 1]").optional(),
+      errorWeight: Schema.number({ min: 0, max: 1 }).optional(),
+      errorSmoothingFactor: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "errorSmoothingFactor must be in (0, 1]").optional(),
+      errorStatusThreshold: Schema.number({ min: 100, max: 599, int: true }).optional(),
+      queueStrategy: Schema.enum(["fifo", "priority"]).optional(),
+      queueLoadShedding: Schema.enum(["reject-new", "priority-evict"]).optional(),
+      rejectionBackoffThreshold: Schema.number({ min: 1, int: true }).optional(),
+      rejectionBackoffMs: Schema.number({ min: 1, int: true }).optional(),
+      stateTtlMs: Schema.union([Schema.literal(false), Schema.number({ min: 1, int: true })]).optional(),
+      warmupRequests: Schema.number({ min: 0, int: true }).optional(),
+      decreaseThreshold: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "decreaseThreshold must be in (0, 1]").optional(),
+      increaseThreshold: Schema.number({ min: 1 }).optional(),
+      maxDecreaseRatio: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "maxDecreaseRatio must be in (0, 1]").optional(),
+      headroomStrategy: Schema.union([
+        Schema.number({ min: 1 }),
+        Schema.enum(["fixed", "proportional"]),
+        fn2,
+        Schema.object({ type: Schema.literal("fixed"), value: Schema.number({ min: 1 }).optional() }, { unknownKeys: "passthrough" }),
+        Schema.object({
+          type: Schema.literal("proportional"),
+          ratio: Schema.number({ min: 0 }).refine((n) => n > 0, "ratio must be > 0").optional(),
+          min: Schema.number({ min: 1 }).optional(),
+          max: Schema.number({ min: 1 }).optional()
+        }, { unknownKeys: "passthrough" })
+      ]).optional(),
+      slowStartRecovery: Schema.boolean().optional(),
+      slowStartSaturationThreshold: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "slowStartSaturationThreshold must be in (0, 1]").optional(),
+      slowStartSaturationSamples: Schema.number({ min: 1, int: true }).optional(),
+      key: Schema.union([Schema.enum(["global", "origin", "host"]), fn2]).optional(),
+      maxQueue: Schema.number({ min: 0, int: true }).optional(),
+      queueTimeoutMs: Schema.number({ min: 1, int: true }).optional(),
+      onLimitChange: fn2.optional(),
+      percentile: Schema.enum(["p50", "p99"]).optional()
+    },
+    { unknownKeys: "passthrough" }
+  )
+]);
+var bareMetalConfigSchema = Schema.object(
+  {
+    baseUrl: Schema.string().optional(),
+    headers: Schema.record(Schema.string()).optional(),
+    timeoutMs: 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) {
+  parseConfig("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 = cfg.baseUrl ?? "";
+  const defaultHeaders = cfg.headers ?? {};
+  const normalize = normalizeRequest(defaultHeaders);
+  const adaptiveLimiter = makeAdaptiveLimiter(cfg);
+  const pool = adaptiveLimiter ? void 0 : makePool(cfg);
+  const metrics = makeHttpStats(pool, adaptiveLimiter);
+  const transport = cfg.transport ?? makeFetchTransport();
+  const destroyTransport = transportDestroy2(transport);
+  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);
+    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 = () => {
+      adaptiveLimiter?.destroy();
+      destroyTransport?.();
+    };
+    metadata.shutdown = () => {
+      adaptiveLimiter?.shutdown();
+      destroyTransport?.();
+    };
+  }
+  return decorate(run, metrics.snapshot, metadata);
+}
+function makeBareMetalHttpStream(cfg = {}) {
+  validateBareMetalConfig(cfg);
+  const baseUrl = cfg.baseUrl ?? "";
+  const defaultHeaders = cfg.headers ?? {};
+  const normalize = normalizeRequest(defaultHeaders);
+  const adaptiveLimiter = makeAdaptiveLimiter(cfg);
+  const pool = adaptiveLimiter ? void 0 : makePool(cfg);
+  const metrics = makeHttpStats(pool, adaptiveLimiter);
+  const transport = cfg.streamTransport ?? makeFetchStreamTransport();
+  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, env) => {
+        let lease;
+        const linkedSignal = linkAbortSignals(signal, req.init?.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,7 +6449,8 @@ 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;
@@ -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);
@@ -6079,6 +6503,160 @@ function makeDefaultHttpClient(config = {}) {
     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) => withAsyncPromise((e, env) => toPromise(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(
+      mapTryAsync(requestRaw(req), (w) => toResponse(w, w.bodyText))
+    );
+  };
+  const getJson = ((url, init) => {
+    const req = setHeaderIfMissing("accept", "application/json")(
+      buildHttpRequest("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")(
+              buildHttpRequest("POST", url, init, bodyText)
+            )
+          );
+          return asyncFlatMap(requestRaw(req), (w) => decodeResponse(w, init?.schema, init?.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: () => asyncSucceed(void 0),
+      shutdown: () => {
+        bareWire.shutdown?.();
+        return asyncSucceed(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) => withAsyncPromise((e, env) => toPromise(e, env))(eff);
   const requestRaw = (req) => wire(req);
@@ -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
@@ -6337,9 +6915,24 @@ export {
   makeFetchStreamTransport,
   decorate,
   withMiddleware,
+  decorateStream,
   normalizeHeadersInit,
+  normalizeRequest,
+  resolvePositiveTimeout,
+  makeHttpStats,
+  makePool,
+  makeAdaptiveLimiter,
+  resolveRequestUrl,
+  fetchLabel,
+  timeoutReason,
+  requestPriority,
+  runTransportEffect,
+  runDirectTransport,
+  releaseSuccess,
+  releaseFailure,
   makeHttpStream,
   noopSignal,
+  runPoolTransport,
   makeHttp,
   withRetryStream,
   SEPARATOR,
@@ -6375,6 +6968,9 @@ export {
   validatedJson,
   validatedJsonResponse,
   buildHttpRequest,
+  validateBareMetalConfig,
+  makeBareMetalHttp,
+  makeBareMetalHttpStream,
   defaultHttpClientPreset,
   makeDefaultHttpClient,
   HttpClientService,