brass-runtime 1.19.2 → 1.20.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 1.19.0 - Bare-Metal HTTP Mode
+
+### Features
+
+- Added `makeBareMetalHttp` factory: a zero-overhead HTTP client that bypasses
+  all middleware layers (retry, dedup, cache, batch, priority, compression,
+  adaptive limiter, prewarm) and delegates directly to the wire transport.
+  Preserves typed errors, cancellation, pool/adaptive-limiter, and stats.
+- Added `makeBareMetalHttpStream` factory: streaming counterpart with the same
+  zero-overhead guarantees. Pool leases are released on headers received.
+- Added `preset: "bareMetal"` to `makeDefaultHttpClient` for easy opt-in via
+  the standard preset system. DX helpers (get, post, getJson, postJson, getText)
+  work identically. Lifecycle config keys are ignored with a construction-time
+  warning. User middleware is still applied.
+- Bare-metal clients expose `.with(mw)` escape hatch for composing observability
+  without pulling in the full lifecycle stack.
+- Exported `runDirectTransport`, `runPoolTransport`, and related wire-level
+  helpers from `src/http/client.ts` for advanced custom client composition.
+
+### Usage
+
+```typescript
+import { makeBareMetalHttp, makeDefaultHttpClient } from "brass-runtime/http";
+
+// Standalone factory
+const client = makeBareMetalHttp({ baseUrl: "https://api.internal" });
+
+// Via preset
+const defaultClient = makeDefaultHttpClient({ preset: "bareMetal" });
+
+// With custom transport (e.g., Axios adapter)
+const axiosClient = makeBareMetalHttp({ transport: myAxiosTransport });
+```
+
 ## 1.18.3 - HTTP Pool/Timeout Fast Path
 
 ### Performance

package/dist/{chunk-QAHW7S3Q.cjs → chunk-62IBGQOU.cjs}

@@ -4,7 +4,7 @@
 var _chunkJQCQWO47cjs = require('./chunk-JQCQWO47.cjs');
 
 
-var _chunkTWEHIAUEcjs = require('./chunk-TWEHIAUE.cjs');
+var _chunkBDTBIYAMcjs = require('./chunk-BDTBIYAM.cjs');
 
 
 var _chunkZJC3JZIEcjs = require('./chunk-ZJC3JZIE.cjs');
@@ -14,7 +14,7 @@ var _chunkVXNWVAIGcjs = require('./chunk-VXNWVAIG.cjs');
 
 
 
-var _chunkUOKXJQAIcjs = require('./chunk-UOKXJQAI.cjs');
+var _chunkLA2PAO7Jcjs = require('./chunk-LA2PAO7J.cjs');
 
 
 
@@ -862,24 +862,24 @@ function baseHttpConfig(baseUrl, scenario) {
   };
 }
 function makeWireClient(baseUrl, scenario) {
-  return _chunkUOKXJQAIcjs.makeHttp.call(void 0, baseHttpConfig(baseUrl, scenario));
+  return _chunkLA2PAO7Jcjs.makeHttp.call(void 0, baseHttpConfig(baseUrl, scenario));
 }
 function makeMinimalClient(baseUrl, scenario) {
-  return _chunkUOKXJQAIcjs.makeDefaultHttpClient.call(void 0, {
+  return _chunkLA2PAO7Jcjs.makeDefaultHttpClient.call(void 0, {
     preset: "minimal",
     compression: false,
     ...baseHttpConfig(baseUrl, scenario)
   });
 }
 function makeDefaultClient(baseUrl, scenario, preset, disableAdaptiveLimiter, observability) {
-  return _chunkUOKXJQAIcjs.makeDefaultHttpClient.call(void 0, {
+  return _chunkLA2PAO7Jcjs.makeDefaultHttpClient.call(void 0, {
     preset,
     compression: false,
     ...baseHttpConfig(baseUrl, scenario),
     ...disableAdaptiveLimiter ? { adaptiveLimiter: false } : {},
     ...observability ? {
       middleware: [
-        _chunkTWEHIAUEcjs.withHttpObservability.call(void 0, {
+        _chunkBDTBIYAMcjs.withHttpObservability.call(void 0, {
           metrics: observability.metrics,
           logs: false,
           spans: {},

package/dist/{chunk-6AGAZD32.js → chunk-6LF3M4JC.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-RZQK32C6.js";
 import {
   withHttpObservability
-} from "./chunk-BHX4MD35.js";
+} from "./chunk-VXZIP3IU.js";
 import {
   makeObservability
 } from "./chunk-TAPB4NN5.js";
@@ -14,7 +14,7 @@ import {
 import {
   makeDefaultHttpClient,
   makeHttp
-} from "./chunk-HKLZJ5UK.js";
+} from "./chunk-POH2WZBI.js";
 import {
   Runtime,
   Scheduler

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

@@ -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-TWEHIAUE.cjs → chunk-BDTBIYAM.cjs}

@@ -20,7 +20,7 @@ var _chunkZJC3JZIEcjs = require('./chunk-ZJC3JZIE.cjs');
 
 
 
-var _chunkUOKXJQAIcjs = require('./chunk-UOKXJQAI.cjs');
+var _chunkLA2PAO7Jcjs = require('./chunk-LA2PAO7J.cjs');
 
 
 var _chunkL6VB5N7Qcjs = require('./chunk-L6VB5N7Q.cjs');
@@ -217,13 +217,13 @@ function withHttpObservability(options) {
           cb({ _tag: "Success", value: res });
         };
         const onError = (error) => {
-          const status = _chunkUOKXJQAIcjs.httpErrorStatus.call(void 0, error);
+          const status = _chunkLA2PAO7Jcjs.httpErrorStatus.call(void 0, error);
           const finish = completeFinish(
             httpErrorOutcome(error),
             status !== void 0 ? String(status) : void 0,
             {
               "error.type": error._tag,
-              "http.retryable": _chunkUOKXJQAIcjs.isRetryableHttpError.call(void 0, error)
+              "http.retryable": _chunkLA2PAO7Jcjs.isRetryableHttpError.call(void 0, error)
             }
           );
           const adaptiveAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
@@ -244,7 +244,7 @@ function withHttpObservability(options) {
               durationMs: finish.durationMs,
               ...status !== void 0 ? { status } : {},
               ...statusText ? { statusText } : {},
-              retryable: _chunkUOKXJQAIcjs.isRetryableHttpError.call(void 0, error),
+              retryable: _chunkLA2PAO7Jcjs.isRetryableHttpError.call(void 0, error),
               errorTag: error._tag,
               message: httpErrorMessage(error)
             });
@@ -312,7 +312,7 @@ function withLeanHttpSampledSpanObservability(next, options, metricCache) {
         finishLeanHttpSpan(span, "success");
       } else {
         const error = httpErrorFromCause(exit.cause);
-        const status = _chunkUOKXJQAIcjs.httpErrorStatus.call(void 0, error);
+        const status = _chunkLA2PAO7Jcjs.httpErrorStatus.call(void 0, error);
         recordHttpMetricsFinish(
           handles,
           httpErrorOutcome(error),
@@ -375,7 +375,7 @@ function withLeanHttpMetricsObservability(next, options, metricCache) {
         );
       } else {
         const error = httpErrorFromCause(exit.cause);
-        const status = _chunkUOKXJQAIcjs.httpErrorStatus.call(void 0, error);
+        const status = _chunkLA2PAO7Jcjs.httpErrorStatus.call(void 0, error);
         recordHttpMetricsFinish(
           handles,
           httpErrorOutcome(error),
@@ -594,7 +594,7 @@ function getCachedBaseLabels(req, options, cache) {
   if (cache.disabled) return requestBaseLabels(req, options);
   const route = requestRoute(req, options);
   const host = options.includeHostLabel ? requestHost(req) : void 0;
-  const policy = _chunkUOKXJQAIcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkLA2PAO7Jcjs.getHttpRequestPolicy.call(void 0, req);
   const preset = typeof policy === "string" ? policy : _optionalChain([policy, 'optionalAccess', _46 => _46.preset]);
   const key = `${req.method}|${_nullishCoalesce(host, () => ( ""))}|${_nullishCoalesce(route, () => ( ""))}|${_nullishCoalesce(preset, () => ( ""))}`;
   const existing = cache.baseLabelsCache.get(key);
@@ -727,7 +727,7 @@ function adaptiveLimiterLabels(req, stats, options) {
   });
 }
 function inferAdaptiveLimiterKey(req, stats) {
-  const policy = _chunkUOKXJQAIcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkLA2PAO7Jcjs.getHttpRequestPolicy.call(void 0, req);
   if (policy.poolKey) return policy.poolKey;
   const host = requestHost(req);
   if (host) return host;
@@ -809,7 +809,7 @@ function requestLogFields(req, options) {
 }
 function requestPolicyLogFields(req, options) {
   if (!options.policy.enabled) return void 0;
-  const policy = _chunkUOKXJQAIcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkLA2PAO7Jcjs.getHttpRequestPolicy.call(void 0, req);
   const fields = {
     ...policy.preset ? { preset: policy.preset } : {},
     ...policy.lane ? { lane: policy.lane } : {},
@@ -822,7 +822,7 @@ function requestPolicyLogFields(req, options) {
 }
 function requestPolicySpanAttributes(req, options) {
   if (!options.policy.enabled) return {};
-  const policy = _chunkUOKXJQAIcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkLA2PAO7Jcjs.getHttpRequestPolicy.call(void 0, req);
   return {
     ...compactSpanAttributes({
       "http.request.policy.lane": policy.lane,
@@ -836,7 +836,7 @@ function requestPolicySpanAttributes(req, options) {
 }
 function requestPolicyMetricLabels(req, options) {
   if (!options.policy.enabled || options.policy.labelKeys.length === 0) return {};
-  const policy = _chunkUOKXJQAIcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkLA2PAO7Jcjs.getHttpRequestPolicy.call(void 0, req);
   const values = {
     preset: policy.preset,
     lane: policy.lane,
@@ -1217,7 +1217,7 @@ function makeObservedRuntimeLayer(options = {}) {
 }
 function makeObservedHttpClientLayer(config = {}, options = {}) {
   const observabilityTag = _nullishCoalesce(options.observabilityTag, () => ( ObservabilityService));
-  const httpTag = _nullishCoalesce(options.httpTag, () => ( _chunkUOKXJQAIcjs.HttpClientService));
+  const httpTag = _nullishCoalesce(options.httpTag, () => ( _chunkLA2PAO7Jcjs.HttpClientService));
   return _chunkZZ2CMYJLcjs.layerEffect.call(void 0, 
     httpTag,
     (context) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
@@ -1228,7 +1228,7 @@ function makeObservedHttpClientLayer(config = {}, options = {}) {
         context,
         observability
       );
-      return _chunkUOKXJQAIcjs.makeDefaultHttpClient.call(void 0, {
+      return _chunkLA2PAO7Jcjs.makeDefaultHttpClient.call(void 0, {
         ...httpConfig,
         middleware: [
           ..._nullishCoalesce(httpConfig.middleware, () => ( [])),