brass-runtime 1.19.2 → 1.20.0

package/dist/{chunk-HKLZJ5UK.js → chunk-POH2WZBI.js}

@@ -5638,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, {
@@ -5661,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
   });
 }
@@ -5684,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) => {
@@ -5746,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",
@@ -6168,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) {
@@ -6265,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;
@@ -6292,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);
@@ -6315,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);
@@ -6495,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
@@ -6573,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,
@@ -6611,6 +6968,9 @@ export {
   validatedJson,
   validatedJsonResponse,
   buildHttpRequest,
+  validateBareMetalConfig,
+  makeBareMetalHttp,
+  makeBareMetalHttpStream,
   defaultHttpClientPreset,
   makeDefaultHttpClient,
   HttpClientService,

package/dist/{chunk-BHX4MD35.js → chunk-VXZIP3IU.js}

@@ -20,7 +20,7 @@ import {
   httpErrorStatus,
   isRetryableHttpError,
   makeDefaultHttpClient
-} from "./chunk-HKLZJ5UK.js";
+} from "./chunk-POH2WZBI.js";
 import {
   registerHttpEffect
 } from "./chunk-TRM4JUZQ.js";

package/dist/{defaultClient-hyVSNzSJ.d.ts → defaultClient-DLOa3gdw.d.ts}

@@ -1,4 +1,4 @@
-import { A as Async, D as AsyncWithPromise } from './effect-DbEMiMvv.js';
+import { A as Async, u as AbortablePromiseFinish, D as AsyncWithPromise } from './effect-DbEMiMvv.js';
 import { Z as ZStream } from './stream-B8c_UKZq.js';
 import { l as Schedule, r as ScheduleObserver, d as CircuitBreakerError } from './layer-CsNGeVee.js';
 import { SchemaIssue, JsonSchemaLike, AnyJsonSchemaLike, InferJsonSchema } from './schema/index.js';
@@ -713,6 +713,63 @@ declare function promiseHttpTransport(): PromiseHttpTransportStartBuilder;
 declare function makeFetchTransport(): HttpTransport;
 declare function makeFetchStreamTransport(): HttpStreamTransport;
 
+interface TimerWheelConfig {
+    /** Tick resolution in ms. Default: 10. Range: [1, 16]. Values outside are clamped. */
+    readonly tickMs?: number;
+    /** Number of wheel slots. Default: 512. Must be power of 2. */
+    readonly slots?: number;
+    /** Fine tick resolution in ms for short deadlines. Default: 4. Range: [1, 16]. */
+    readonly fineTickMs?: number;
+    /** Deadline threshold in ms: entries with deadline ≤ this use fine tick. Default: 50. */
+    readonly fineThresholdMs?: number;
+}
+interface TimerHandle {
+    cancel(): void;
+}
+declare class TimerWheel {
+    private readonly tickMs;
+    private readonly mask;
+    private readonly wheel;
+    private currentTick;
+    private timer;
+    private pending;
+    private readonly fineTickMs;
+    private readonly fineThresholdMs;
+    private fineHead;
+    private fineTimer;
+    private finePending;
+    constructor(config?: TimerWheelConfig);
+    /**
+     * Schedule a timeout. Returns a cancel handle. O(1).
+     * @param timeoutMs - Timeout duration in milliseconds.
+     * @param cb - Callback to invoke on expiry.
+     * @param now - Optional pre-captured `performance.now()` value to avoid an extra call.
+     */
+    schedule(timeoutMs: number, cb: () => void, now?: number): TimerHandle;
+    /** Schedule on the normal (coarse) wheel path. */
+    private scheduleNormal;
+    /** Schedule on the fine-resolution path for short deadlines. */
+    private scheduleFine;
+    /** Advance the wheel, expiring due entries. Called by internal setTimeout. */
+    private tick;
+    /** Tick the fine-resolution linked list, expiring due entries. */
+    private fineTick;
+    /** Start the background timer if not running. */
+    private ensureTimer;
+    /** Start the fine-tick timer if not running. */
+    private ensureFineTimer;
+    /** Stop the background timer if no entries pending. */
+    private maybeStopTimer;
+    /** Stop the fine-tick timer if no fine entries pending. */
+    private maybeStopFineTimer;
+    /** Cancel all pending entries and stop. */
+    destroy(): void;
+    /** Unlink an entry from its slot's doubly-linked list. O(1). */
+    private unlink;
+    /** Unlink an entry from the fine-tick linked list. O(1). */
+    private unlinkFine;
+}
+
 type HttpError = {
     _tag: "Abort";
 } | {
@@ -835,13 +892,54 @@ type HttpClient = HttpClientFn & {
 type HttpClientMetadata = Pick<HttpClient, "adaptiveLimiter" | "destroy" | "shutdown">;
 declare const decorate: (run: HttpClientFn, stats?: () => HttpClientStats, metadata?: HttpClientMetadata) => HttpClient;
 declare const withMiddleware: (mw: HttpMiddleware) => (c: HttpClient) => HttpClient;
+declare const decorateStream: (run: HttpClientStreamFn, stats?: () => HttpClientStats) => HttpClientStream;
 declare const normalizeHeadersInit: (h: any) => Record<string, string> | undefined;
+declare const normalizeRequest: (defaultHeaders: Record<string, string>) => (req0: HttpRequest) => HttpRequest;
+declare const resolvePositiveTimeout: (value: number | undefined) => number | undefined;
+declare const makeHttpStats: (pool: HttpConcurrencyPool | undefined, adaptiveLimiter: AdaptiveLimiter | undefined) => {
+    onStart: () => void;
+    onFinish: (finish: AbortablePromiseFinish) => void;
+    snapshot: () => HttpClientStats;
+};
+type HttpMetrics = ReturnType<typeof makeHttpStats>;
+declare const makePool: (cfg: MakeHttpConfig) => HttpConcurrencyPool | undefined;
+declare const makeAdaptiveLimiter: (cfg: MakeHttpConfig) => AdaptiveLimiter | undefined;
+declare const resolveRequestUrl: (req: HttpRequest, baseUrl: string) => URL | HttpError;
+declare const fetchLabel: (req: HttpRequest, url: URL) => string;
+declare const timeoutReason: (req: HttpRequest, url: URL, timeoutMs: number) => HttpError;
+declare const requestPriority: (req: HttpRequest) => number | undefined;
+declare const runTransportEffect: <A>(effect: Async<unknown, HttpError, A>, env: unknown, signal: AbortSignal) => Promise<A>;
+declare const runDirectTransport: (req: HttpRequest, url: URL, transport: HttpTransport, metrics: HttpMetrics) => Async<unknown, HttpError, HttpWireResponse>;
+type HttpLease = {
+    release: (...args: any[]) => void;
+};
+declare const releaseSuccess: (lease: HttpLease | undefined, adaptiveLimiter: AdaptiveLimiter | undefined, response: {
+    readonly status: number;
+    readonly ms: number;
+}) => undefined;
+declare const releaseFailure: (lease: HttpLease | undefined, adaptiveLimiter: AdaptiveLimiter | undefined) => undefined;
 declare function makeHttpStream(cfg?: MakeHttpConfig): HttpClientStream;
 /**
  * Shared no-op AbortSignal used when no external signal is present.
  * This avoids allocating a new AbortController per request in the common case.
  */
 declare const noopSignal: AbortSignal;
+/**
+ * Synchronous fast-path for pool/adaptive-limiter + timeout requests.
+ *
+ * When the pool/limiter acquire is uncontended (tryAcquireSync succeeds) and the
+ * transport effect resolves synchronously, this avoids ALL Promise/microtask
+ * boundaries — the entire request completes in a single call frame.
+ *
+ * Falls back to async acquire when contended (pool full or limiter at limit).
+ *
+ * Closure budget for uncontended sync path:
+ *   1. The cancel function returned to caller
+ *   2. The transport completion callback (success/failure handler)
+ *   3. The timeout callback (when timeoutMs is set)
+ * All other functions are methods on PoolRequestState — no per-request closure allocation.
+ */
+declare const runPoolTransport: (req: HttpRequest, url: URL, transport: HttpTransport, metrics: HttpMetrics, pool: HttpConcurrencyPool | undefined, adaptiveLimiter: AdaptiveLimiter | undefined, timerWheel: TimerWheel | undefined, timeoutMs: number | undefined) => Async<unknown, HttpError, HttpWireResponse>;
 declare function makeHttp(cfg?: MakeHttpConfig): HttpClient;
 declare const withRetryStream: (p: RetryPolicy) => (next: HttpClientStream) => HttpClientStream;
 
@@ -1583,7 +1681,7 @@ type DefaultPostJson = {
     <Validator extends AnyJsonSchemaLike>(url: string, bodyObj: unknown, init: HttpPostJsonInit<Validator>): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<InferJsonSchema<Validator>>>;
     <A = unknown>(url: string, bodyObj: unknown, init?: PostJsonInitNoSchema): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<A>>;
 };
-type DefaultHttpClientPreset = "minimal" | "proxy" | "highThroughputProxy" | "balanced" | "default" | "production";
+type DefaultHttpClientPreset = "minimal" | "proxy" | "highThroughputProxy" | "balanced" | "default" | "production" | "bareMetal";
 type DefaultHttpClientFeatures = {
     readonly dedup: boolean;
     readonly batch: boolean;
@@ -1645,4 +1743,4 @@ declare const defaultHttpClientPreset: DefaultHttpClientPreset;
  */
 declare function makeDefaultHttpClient(config?: DefaultHttpClientConfig): DefaultHttpClient;
 
-export { type DefaultHttpClientFeatures as $, type AdaptiveLimiterStats as A, type BatchConfig as B, type CompressionConfig as C, type DefaultHttpClient as D, type AdaptiveLimiterPreset as E, type HttpPoolConfig as F, type AdaptiveAcquireOptions as G, type HttpRequest as H, type AdaptiveBaselineStrategy as I, type AdaptiveHeadroomContext as J, type AdaptiveHeadroomMode as K, type LifecycleClientConfig as L, type AdaptiveHeadroomStrategy as M, type AdaptiveLease as N, type AdaptiveLimiterDiagnostics as O, type PrewarmResult as P, type AdaptiveLimiterKeySnapshot as Q, type RequestCompressionConfig as R, type AdaptiveQueueLoadShedding as S, type AdaptiveQueueStrategy as T, type AdaptiveReleaseInfo as U, type BatchFunction as V, type CachePolicyResult as W, type CompressionStats as X, type DecompressResult as Y, type Decompressor as Z, type DefaultGetJson as _, type HttpClient as a, abortErrorForSignal as a$, type DefaultPostJson as a0, type Dx as a1, type HttpBody as a2, type HttpClientStream as a3, type HttpClientStreamFn as a4, HttpConcurrencyPool as a5, type HttpErrorHandlers as a6, type HttpInit as a7, type HttpJsonInit as a8, type HttpMeta as a9, type PerRequestRetryOverride as aA, type PrewarmEvent as aB, type PrewarmEventType as aC, type PrewarmOriginStatus as aD, type PrewarmResultStatus as aE, type PromiseHttpTransportBodyBuilder as aF, type PromiseHttpTransportBodySelector as aG, type PromiseHttpTransportConfig as aH, type PromiseHttpTransportConfigWithSignal as aI, type PromiseHttpTransportFluentResponseBuilder as aJ, type PromiseHttpTransportRequestConfigBuilder as aK, type PromiseHttpTransportRequestConfigContext as aL, type PromiseHttpTransportRequestConfigMapper as aM, type PromiseHttpTransportResponse as aN, type PromiseHttpTransportResponseInfo as aO, type PromiseHttpTransportResponseInfoMapper as aP, type PromiseHttpTransportStartBuilder as aQ, type RequestCompressionStats as aR, type ResolveHttpRequestPolicyOptions as aS, type ResolvedConfig as aT, type RetryEvent as aU, type RetryScheduleInput as aV, type RetryableHttpErrorOptions as aW, SUPPORTED_ENCODINGS as aX, type SupportedEncoding as aY, type ToHttpErrorOptions as aZ, type ValidationError as a_, type HttpPolicyPreset as aa, type HttpPolicyPresets as ab, type HttpPoolKeyResolver as ac, type HttpPoolKeyStats as ad, type HttpPoolLease as ae, type HttpPoolStats as af, type HttpPostJsonBodyInit as ag, type HttpPostJsonInit as ah, type HttpPostJsonSchemaBodyInit as ai, type HttpRequestPolicy as aj, type HttpRequestPolicyRef as ak, type HttpRequestRetryOverride as al, type HttpResponse as am, type HttpResponseWithMeta as an, type HttpRetryScheduleInput as ao, type HttpStreamTransport as ap, type HttpTransportContext as aq, type HttpTransportTiming as ar, type HttpWireResponseStream as as, type HttpWireWithMeta as at, type JsonDecodeResult as au, type KnownHttpError as av, type KnownHttpErrorTag as aw, type LifecycleRequestOptions as ax, type LimitChangeEvent as ay, type MakeHttpConfig as az, type HttpWireResponse as b, adaptiveLimiterPresets as b0, backoffDelayMs as b1, decodeJsonBody as b2, decodeJsonBodyEffect as b3, decorate as b4, defaultHttpClientPreset as b5, defaultRetryOnError as b6, defaultRetryOnStatus as b7, defaultRetryableMethods as b8, defineHttpPolicyPresets as b9, makeFetchStreamTransport as bA, makeFetchTransport as bB, makeHttp as bC, makeHttpStream as bD, makeJsonParseValidationError as bE, makePromiseHttpTransport as bF, matchHttpError as bG, noopSignal as bH, normalizeHeadersInit as bI, normalizeHttpError as bJ, normalizeHttpHeaders as bK, normalizeRetryBudget as bL, promiseHttpTransport as bM, resolveConfig as bN, resolveHttpPoolKey as bO, resolveHttpRequestPolicyPresets as bP, retryAfterMs as bQ, toHttpError as bR, validateConfig as bS, validatedJson as bT, validatedJsonResponse as bU, withBatch as bV, withHttpPolicyPresets as bW, withHttpRequestPolicy as bX, withMiddleware as bY, withRetry as bZ, withRetryStream as b_, encodeJsonBodyEffect as ba, formatHttpError as bb, getHttpRequestPolicy as bc, headersOf as bd, httpClient as be, httpClientStream as bf, httpClientWithMeta as bg, httpErrorStatus as bh, httpPolicy as bi, isAbortError as bj, isAbortHttpError as bk, isCircuitBreakerOpen as bl, isExternalAbortError as bm, isExternalTimeoutError as bn, isFetchHttpError as bo, isHttpError as bp, isKnownHttpError as bq, isPromiseTransportDirect as br, isRetryableHttpError as bs, isRetryableHttpStatus as bt, isTaggedHttpError as bu, isTimeoutHttpError as bv, isValidationError as bw, linkAbortSignals as bx, makeAdaptiveLimiterConfig as by, makeDefaultHttpClient as bz, type HttpError as c, type HttpMiddleware as d, type DefaultHttpClientConfig as e, type CompressionMiddlewareResult as f, type RequestCompressionMiddlewareResult as g, type HttpTransport as h, AdaptiveLimiter as i, type LifecycleClient as j, type LifecycleEvent as k, type HttpClientStats as l, type LifecycleEventType as m, type LifecycleStats as n, type PrewarmStatusSnapshot as o, type PrewarmConfig as p, type HttpClientFn as q, type PrewarmOriginState as r, type HttpMethod as s, type DefaultHttpClientPreset as t, type DedupConfig as u, type CacheConfig as v, type PriorityConfig as w, type RetryPolicy as x, type PrewarmLifecycleConfig as y, type AdaptiveLimiterConfig as z };
+export { type Decompressor as $, type AdaptiveLimiterStats as A, type BatchConfig as B, type CompressionConfig as C, type DefaultHttpClient as D, type PriorityConfig as E, type RetryPolicy as F, type PrewarmLifecycleConfig as G, type HttpRequest as H, type AdaptiveLimiterPreset as I, type AdaptiveAcquireOptions as J, type AdaptiveBaselineStrategy as K, type LifecycleClientConfig as L, type AdaptiveHeadroomContext as M, type AdaptiveHeadroomMode as N, type AdaptiveHeadroomStrategy as O, type PrewarmResult as P, type AdaptiveLease as Q, type RequestCompressionConfig as R, type AdaptiveLimiterDiagnostics as S, type AdaptiveLimiterKeySnapshot as T, type AdaptiveQueueLoadShedding as U, type AdaptiveQueueStrategy as V, type AdaptiveReleaseInfo as W, type BatchFunction as X, type CachePolicyResult as Y, type CompressionStats as Z, type DecompressResult as _, type HttpClient as a, abortErrorForSignal as a$, type DefaultGetJson as a0, type DefaultHttpClientFeatures as a1, type DefaultPostJson as a2, type Dx as a3, type HttpBody as a4, type HttpClientStreamFn as a5, HttpConcurrencyPool as a6, type HttpErrorHandlers as a7, type HttpInit as a8, type HttpJsonInit as a9, type PerRequestRetryOverride as aA, type PrewarmEvent as aB, type PrewarmEventType as aC, type PrewarmOriginStatus as aD, type PrewarmResultStatus as aE, type PromiseHttpTransportBodyBuilder as aF, type PromiseHttpTransportBodySelector as aG, type PromiseHttpTransportConfig as aH, type PromiseHttpTransportConfigWithSignal as aI, type PromiseHttpTransportFluentResponseBuilder as aJ, type PromiseHttpTransportRequestConfigBuilder as aK, type PromiseHttpTransportRequestConfigContext as aL, type PromiseHttpTransportRequestConfigMapper as aM, type PromiseHttpTransportResponse as aN, type PromiseHttpTransportResponseInfo as aO, type PromiseHttpTransportResponseInfoMapper as aP, type PromiseHttpTransportStartBuilder as aQ, type RequestCompressionStats as aR, type ResolveHttpRequestPolicyOptions as aS, type ResolvedConfig as aT, type RetryEvent as aU, type RetryScheduleInput as aV, type RetryableHttpErrorOptions as aW, SUPPORTED_ENCODINGS as aX, type SupportedEncoding as aY, type ToHttpErrorOptions as aZ, type ValidationError as a_, type HttpMeta as aa, type HttpPolicyPreset as ab, type HttpPolicyPresets as ac, type HttpPoolKeyResolver as ad, type HttpPoolKeyStats as ae, type HttpPoolLease as af, type HttpPoolStats as ag, type HttpPostJsonBodyInit as ah, type HttpPostJsonInit as ai, type HttpPostJsonSchemaBodyInit as aj, type HttpRequestPolicy as ak, type HttpRequestPolicyRef as al, type HttpRequestRetryOverride as am, type HttpResponse as an, type HttpResponseWithMeta as ao, type HttpRetryScheduleInput as ap, type HttpTransportContext as aq, type HttpTransportTiming as ar, type HttpWireResponseStream as as, type HttpWireWithMeta as at, type JsonDecodeResult as au, type KnownHttpError as av, type KnownHttpErrorTag as aw, type LifecycleRequestOptions as ax, type LimitChangeEvent as ay, type MakeHttpConfig as az, type HttpWireResponse as b, retryAfterMs as b$, adaptiveLimiterPresets as b0, backoffDelayMs as b1, decodeJsonBody as b2, decodeJsonBodyEffect as b3, decorate as b4, decorateStream as b5, defaultHttpClientPreset as b6, defaultRetryOnError as b7, defaultRetryOnStatus as b8, defaultRetryableMethods as b9, makeAdaptiveLimiter as bA, makeAdaptiveLimiterConfig as bB, makeDefaultHttpClient as bC, makeFetchStreamTransport as bD, makeFetchTransport as bE, makeHttp as bF, makeHttpStats as bG, makeHttpStream as bH, makeJsonParseValidationError as bI, makePool as bJ, makePromiseHttpTransport as bK, matchHttpError as bL, noopSignal as bM, normalizeHeadersInit as bN, normalizeHttpError as bO, normalizeHttpHeaders as bP, normalizeRequest as bQ, normalizeRetryBudget as bR, promiseHttpTransport as bS, releaseFailure as bT, releaseSuccess as bU, requestPriority as bV, resolveConfig as bW, resolveHttpPoolKey as bX, resolveHttpRequestPolicyPresets as bY, resolvePositiveTimeout as bZ, resolveRequestUrl as b_, defineHttpPolicyPresets as ba, encodeJsonBodyEffect as bb, fetchLabel as bc, formatHttpError as bd, getHttpRequestPolicy as be, headersOf as bf, httpClient as bg, httpClientStream as bh, httpClientWithMeta as bi, httpErrorStatus as bj, httpPolicy as bk, isAbortError as bl, isAbortHttpError as bm, isCircuitBreakerOpen as bn, isExternalAbortError as bo, isExternalTimeoutError as bp, isFetchHttpError as bq, isHttpError as br, isKnownHttpError as bs, isPromiseTransportDirect as bt, isRetryableHttpError as bu, isRetryableHttpStatus as bv, isTaggedHttpError as bw, isTimeoutHttpError as bx, isValidationError as by, linkAbortSignals as bz, type HttpError as c, runDirectTransport as c0, runPoolTransport as c1, runTransportEffect as c2, timeoutReason as c3, toHttpError as c4, validateConfig as c5, validatedJson as c6, validatedJsonResponse as c7, withBatch as c8, withHttpPolicyPresets as c9, withHttpRequestPolicy as ca, withMiddleware as cb, withRetry as cc, withRetryStream as cd, type HttpMiddleware as d, type DefaultHttpClientConfig as e, type CompressionMiddlewareResult as f, type RequestCompressionMiddlewareResult as g, type HttpTransport as h, AdaptiveLimiter as i, type LifecycleClient as j, type LifecycleEvent as k, type HttpClientStats as l, type LifecycleEventType as m, type LifecycleStats as n, type PrewarmStatusSnapshot as o, type PrewarmConfig as p, type HttpClientFn as q, type PrewarmOriginState as r, type HttpMethod as s, type HttpStreamTransport as t, type HttpPoolConfig as u, type AdaptiveLimiterConfig as v, type HttpClientStream as w, type DefaultHttpClientPreset as x, type DedupConfig as y, type CacheConfig as z };