brass-runtime 1.17.0 → 1.18.0

package/dist/{chunk-F6XWZQY4.cjs → chunk-KHACHFBQ.cjs}

@@ -1,5 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
+var _chunk5XADBMSUcjs = require('./chunk-5XADBMSU.cjs');
 
 
 
@@ -9,15 +10,31 @@
 
 
 
-var _chunkWBGRHGBPcjs = require('./chunk-WBGRHGBP.cjs');
 
 
 
+var _chunkLXBU5E77cjs = require('./chunk-LXBU5E77.cjs');
 
-var _chunk3LOYJFRRcjs = require('./chunk-3LOYJFRR.cjs');
 
 
-var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
+
+
+
+var _chunkVIFA4DPNcjs = require('./chunk-VIFA4DPN.cjs');
+
+
+var _chunkL6VB5N7Qcjs = require('./chunk-L6VB5N7Q.cjs');
+
+
+
+var _chunk7TXQJFZXcjs = require('./chunk-7TXQJFZX.cjs');
+
+
+
+
+var _chunkSSQJKDN3cjs = require('./chunk-SSQJKDN3.cjs');
+
+
 
 
 
@@ -28,6 +45,9 @@ var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
 
 // src/observability/http.ts
 var DEFAULT_DURATION_BUCKETS = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4];
+var MAX_HTTP_METRIC_CACHE_ENTRIES = 4096;
+var EMPTY_SPAN_ATTRIBUTES = Object.freeze({});
+var TRACE_SAMPLER_RATIO = /* @__PURE__ */ Symbol.for("brass-runtime.traceSampler.ratio");
 var POLICY_LABEL_NAMES = {
   preset: "policy",
   lane: "lane",
@@ -100,13 +120,22 @@ var HTTP_OBSERVABILITY_CONTRACT = Object.freeze({
 });
 function withHttpObservability(options) {
   if (!isObservabilityInstance(options)) {
-    _chunkWBGRHGBPcjs.validateHttpObservabilityOptions.call(void 0, _nullishCoalesce(options, () => ( {})));
+    _chunkLXBU5E77cjs.validateHttpObservabilityOptions.call(void 0, _nullishCoalesce(options, () => ( {})));
   }
   const resolved = resolveHttpObservabilityOptions(options);
+  const metricCache = makeHttpMetricCache();
+  attachMetricCache(resolved.metrics, metricCache);
   return (next) => {
+    const adaptiveLimiter = adaptiveLimiterOf(next);
+    if (canUseLeanHttpMetricsPath(resolved, adaptiveLimiter)) {
+      return withLeanHttpMetricsObservability(next, resolved, metricCache);
+    }
+    if (canUseLeanHttpSampledSpanPath(resolved, adaptiveLimiter)) {
+      return withLeanHttpSampledSpanObservability(next, resolved, metricCache);
+    }
     return (req) => {
       const run = _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
-        beginHttpObservation(req, resolved),
+        beginHttpObservation(req, resolved, metricCache),
         (state) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
           logHttpRequest(req, resolved),
           () => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
@@ -116,23 +145,25 @@ function withHttpObservability(options) {
               (error) => {
                 const finish = state.finishWithError(error);
                 const adaptiveLimiterAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
+                const traceEvent = !shouldEmitHttpSpanEvents(resolved) ? _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0) : _chunkLXBU5E77cjs.spanEvent.call(void 0, "http.client.error", {
+                  ...finish.spanAttributes,
+                  ...adaptiveLimiterAttrs,
+                  "error.type": error._tag
+                });
                 return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
-                  _chunkWBGRHGBPcjs.spanEvent.call(void 0, "http.client.error", {
-                    ...finish.spanAttributes,
-                    ...adaptiveLimiterAttrs,
-                    "error.type": error._tag
-                  }),
+                  traceEvent,
                   () => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, logHttpError(req, error, finish, resolved), () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error))
                 );
               },
               (res) => {
                 const finish = state.finishWithResponse(res);
                 const adaptiveLimiterAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
+                const traceEvent = !shouldEmitHttpSpanEvents(resolved) ? _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0) : _chunkLXBU5E77cjs.spanEvent.call(void 0, "http.client.response", {
+                  ...finish.spanAttributes,
+                  ...adaptiveLimiterAttrs
+                });
                 return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
-                  _chunkWBGRHGBPcjs.spanEvent.call(void 0, "http.client.response", {
-                    ...finish.spanAttributes,
-                    ...adaptiveLimiterAttrs
-                  }),
+                  traceEvent,
                   () => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, logHttpResponse(req, res, finish, resolved), () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, res))
                 );
               }
@@ -141,31 +172,415 @@ function withHttpObservability(options) {
         )
       );
       if (resolved.spans === false) return run;
-      return _chunkWBGRHGBPcjs.withSpan.call(void 0, spanName(req, resolved.spans), run, spanStartAttributes(req, resolved));
+      return _chunkLXBU5E77cjs.withSpan.call(void 0, spanName(req, resolved.spans), run, spanStartAttributes(req, resolved));
     };
   };
 }
 var makeHttpObservabilityMiddleware = withHttpObservability;
-function beginHttpObservation(req, options) {
+var metricResetRegistry = /* @__PURE__ */ new WeakMap();
+function canUseLeanHttpMetricsPath(options, adaptiveLimiter) {
+  return Boolean(
+    options.metrics && options.logs === false && options.spans === false && !options.injectTraceHeaders && (!options.adaptiveLimiter.enabled || !adaptiveLimiter)
+  );
+}
+function canUseLeanHttpSampledSpanPath(options, adaptiveLimiter) {
+  return Boolean(
+    options.spans !== false && options.spans.events === false && options.logs === false && !options.injectTraceHeaders && (!options.adaptiveLimiter.enabled || !adaptiveLimiter)
+  );
+}
+function withLeanHttpSampledSpanObservability(next, options, metricCache) {
+  return (req) => _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const startedAt = options.clock();
+    const baseLabels = requestBaseLabels(req, options);
+    const handles = beginLeanHttpMetricsObservation(baseLabels, options, metricCache);
+    const span = startLeanHttpSpan(req, options);
+    let finished = false;
+    let cancelInner;
+    const finish = (exit) => {
+      if (finished) return;
+      finished = true;
+      cancelInner = void 0;
+      if (exit._tag === "Success") {
+        recordHttpMetricsFinish(
+          handles,
+          httpStatusOutcome(exit.value.status),
+          String(exit.value.status),
+          startedAt,
+          options,
+          metricCache
+        );
+        finishLeanHttpSpan(span, "success");
+      } else {
+        const error = httpErrorFromCause(exit.cause);
+        const status = _chunkVIFA4DPNcjs.httpErrorStatus.call(void 0, error);
+        recordHttpMetricsFinish(
+          handles,
+          httpErrorOutcome(error),
+          status !== void 0 ? String(status) : void 0,
+          startedAt,
+          options,
+          metricCache
+        );
+        finishLeanHttpSpan(span, _chunkMVGUEJ5Zcjs.Cause.containsInterrupt(exit.cause) ? "interrupted" : "failure", error);
+      }
+      cb(exit);
+    };
+    try {
+      cancelInner = _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, next(req), env, finish);
+    } catch (error) {
+      const defectExit = {
+        _tag: "Failure",
+        cause: _chunkMVGUEJ5Zcjs.Cause.die(error)
+      };
+      finish(defectExit);
+    }
+    return () => {
+      if (!finished) {
+        finished = true;
+        recordHttpMetricsFinish(
+          handles,
+          "abort",
+          void 0,
+          startedAt,
+          options,
+          metricCache
+        );
+        finishLeanHttpSpan(span, "interrupted");
+      }
+      const cancel = cancelInner;
+      cancelInner = void 0;
+      _optionalChain([cancel, 'optionalCall', _ => _()]);
+    };
+  });
+}
+function withLeanHttpMetricsObservability(next, options, metricCache) {
+  return (req) => _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const startedAt = options.clock();
+    const baseLabels = requestBaseLabels(req, options);
+    const handles = beginLeanHttpMetricsObservation(baseLabels, options, metricCache);
+    let finished = false;
+    let cancelInner;
+    const finish = (exit) => {
+      if (finished) return;
+      finished = true;
+      cancelInner = void 0;
+      if (exit._tag === "Success") {
+        recordHttpMetricsFinish(
+          handles,
+          httpStatusOutcome(exit.value.status),
+          String(exit.value.status),
+          startedAt,
+          options,
+          metricCache
+        );
+      } else {
+        const error = httpErrorFromCause(exit.cause);
+        const status = _chunkVIFA4DPNcjs.httpErrorStatus.call(void 0, error);
+        recordHttpMetricsFinish(
+          handles,
+          httpErrorOutcome(error),
+          status !== void 0 ? String(status) : void 0,
+          startedAt,
+          options,
+          metricCache
+        );
+      }
+      cb(exit);
+    };
+    try {
+      cancelInner = _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, next(req), env, finish);
+    } catch (error) {
+      const defectExit = {
+        _tag: "Failure",
+        cause: _chunkMVGUEJ5Zcjs.Cause.die(error)
+      };
+      finish(defectExit);
+    }
+    return () => {
+      if (!finished) {
+        finished = true;
+        recordHttpMetricsFinish(
+          handles,
+          "abort",
+          void 0,
+          startedAt,
+          options,
+          metricCache
+        );
+      }
+      const cancel = cancelInner;
+      cancelInner = void 0;
+      _optionalChain([cancel, 'optionalCall', _2 => _2()]);
+    };
+  });
+}
+function beginLeanHttpMetricsObservation(baseLabels, options, metricCache) {
+  const cacheKey = metricCacheKey("brass_http_client", baseLabels);
+  const existing = metricCache.disabled ? void 0 : metricCache.leanEntries.get(cacheKey);
+  if (existing) {
+    _optionalChain([existing, 'access', _3 => _3.inFlight, 'optionalAccess', _4 => _4.increment, 'call', _5 => _5()]);
+    return existing;
+  }
+  const inFlight = options.metrics ? getCachedMetric(
+    metricCache,
+    metricCache.inFlightGauges,
+    metricCacheKey("brass_http_client_in_flight", baseLabels),
+    () => options.metrics.gauge("brass_http_client_in_flight", baseLabels)
+  ) : void 0;
+  _optionalChain([inFlight, 'optionalAccess', _6 => _6.increment, 'call', _7 => _7()]);
+  const created = {
+    baseLabels,
+    inFlight,
+    finishMetrics: /* @__PURE__ */ new Map()
+  };
+  if (!metricCache.disabled && metricCache.leanEntries.size < MAX_HTTP_METRIC_CACHE_ENTRIES) {
+    metricCache.leanEntries.set(cacheKey, created);
+  }
+  return created;
+}
+function recordHttpMetricsFinish(handles, outcome, status, startedAt, options, metricCache) {
+  const durationMs = Math.max(0, options.clock() - startedAt);
+  _optionalChain([handles, 'access', _8 => _8.inFlight, 'optionalAccess', _9 => _9.decrement, 'call', _10 => _10()]);
+  if (!options.metrics) return;
+  const finishKey = `${outcome}|${_nullishCoalesce(status, () => ( "none"))}`;
+  let finishMetrics = metricCache.disabled ? void 0 : handles.finishMetrics.get(finishKey);
+  if (!finishMetrics) {
+    const labels = requestFinishLabelsFromBase(handles.baseLabels, outcome, status);
+    finishMetrics = {
+      counter: options.metrics.counter("brass_http_client_requests_total", labels),
+      histogram: options.metrics.histogram(
+        "brass_http_client_duration_ms",
+        [..._nullishCoalesce(options.durationBuckets, () => ( DEFAULT_DURATION_BUCKETS))],
+        labels
+      )
+    };
+    if (!metricCache.disabled) handles.finishMetrics.set(finishKey, finishMetrics);
+  }
+  finishMetrics.counter.increment();
+  finishMetrics.histogram.observe(durationMs);
+}
+function startLeanHttpSpan(req, options) {
+  const configuredSampleRate = options.spans === false ? void 0 : options.spans.sampleRate;
+  if (configuredSampleRate !== void 0) {
+    if (configuredSampleRate <= 0) return void 0;
+    if (configuredSampleRate < 1 && Math.random() >= configuredSampleRate) return void 0;
+  }
+  const fiber = _chunkSSQJKDN3cjs.getCurrentFiber.call(void 0, );
+  const runtime = _optionalChain([fiber, 'optionalAccess', _11 => _11.runtime]);
+  const sink = _nullishCoalesce(options.spanSink, () => ( _optionalChain([runtime, 'optionalAccess', _12 => _12.hooks])));
+  if (!_optionalChain([fiber, 'optionalAccess', _13 => _13.fiberContext]) || !runtime || !sink) return void 0;
+  const previousTrace = _nullishCoalesce(fiber.fiberContext.trace, () => ( null));
+  const brass = _optionalChain([runtime, 'access', _14 => _14.env, 'optionalAccess', _15 => _15.brass]);
+  if (_optionalChain([previousTrace, 'optionalAccess', _16 => _16.sampled]) === false && _optionalChain([brass, 'optionalAccess', _17 => _17.respectRemoteSampled]) !== false) return void 0;
+  const name = spanName(req, options.spans);
+  const tracer = resolveRuntimeTracer(runtime);
+  let traceId = _optionalChain([previousTrace, 'optionalAccess', _18 => _18.traceId]);
+  let sampled = _optionalChain([previousTrace, 'optionalAccess', _19 => _19.sampled]);
+  let attributes;
+  if (!previousTrace && configuredSampleRate === void 0) {
+    const ratio = traceSamplerRatio(_optionalChain([brass, 'optionalAccess', _20 => _20.sampler]));
+    if (ratio !== void 0) {
+      if (ratio <= 0) return void 0;
+      if (ratio < 1 && Math.random() >= ratio) return void 0;
+      sampled = true;
+    }
+    traceId = tracer.newTraceId();
+  } else if (!previousTrace) {
+    sampled = true;
+    traceId = tracer.newTraceId();
+  }
+  attributes = spanStartAttributes(req, options);
+  if (sampled === void 0) {
+    traceId = _nullishCoalesce(traceId, () => ( tracer.newTraceId()));
+    sampled = _chunkLXBU5E77cjs.shouldSampleWith.call(void 0, _optionalChain([brass, 'optionalAccess', _21 => _21.sampler]), {
+      traceId,
+      spanName: name,
+      parentSampled: _optionalChain([previousTrace, 'optionalAccess', _22 => _22.sampled]),
+      attributes
+    });
+  }
+  if (sampled === false) return void 0;
+  const trace = {
+    traceId: _nullishCoalesce(traceId, () => ( tracer.newTraceId())),
+    spanId: tracer.newSpanId(),
+    parentSpanId: _optionalChain([previousTrace, 'optionalAccess', _23 => _23.spanId]),
+    sampled: true,
+    traceState: _optionalChain([previousTrace, 'optionalAccess', _24 => _24.traceState]),
+    ..._optionalChain([previousTrace, 'optionalAccess', _25 => _25.baggage]) ? { baggage: previousTrace.baggage } : {}
+  };
+  const state = {
+    fiber,
+    sink,
+    previousTrace,
+    trace,
+    name,
+    ended: false
+  };
+  fiber.fiberContext = { ...fiber.fiberContext, trace };
+  _optionalChain([fiber, 'access', _26 => _26.addFinalizer, 'optionalCall', _27 => _27((exit) => {
+    const status = _optionalChain([exit, 'optionalAccess', _28 => _28._tag]) === "Success" ? "success" : _optionalChain([exit, 'optionalAccess', _29 => _29.cause]) && _chunkMVGUEJ5Zcjs.Cause.containsInterrupt(exit.cause) ? "interrupted" : "failure";
+    finishLeanHttpSpan(state, status, _optionalChain([exit, 'optionalAccess', _30 => _30._tag]) === "Failure" ? exit.cause : void 0);
+  })]);
+  sink.emit(
+    { type: "span.start", name, attributes, links: [] },
+    leanSpanContext(fiber, trace)
+  );
+  return state;
+}
+function finishLeanHttpSpan(state, status, error) {
+  if (!state || state.ended) return;
+  state.ended = true;
+  state.sink.emit(
+    { type: "span.end", name: state.name, status, error },
+    leanSpanContext(state.fiber, state.trace)
+  );
+  if (_optionalChain([state, 'access', _31 => _31.fiber, 'optionalAccess', _32 => _32.fiberContext])) {
+    state.fiber.fiberContext = { ...state.fiber.fiberContext, trace: state.previousTrace };
+  }
+}
+function leanSpanContext(fiber, trace) {
+  return {
+    fiberId: _optionalChain([fiber, 'optionalAccess', _33 => _33.id]),
+    scopeId: _optionalChain([fiber, 'optionalAccess', _34 => _34.scopeId]),
+    traceId: trace.traceId,
+    spanId: trace.spanId,
+    parentSpanId: trace.parentSpanId,
+    traceState: trace.traceState,
+    baggage: trace.baggage,
+    sampled: trace.sampled
+  };
+}
+function resolveRuntimeTracer(runtime) {
+  const tracer = _optionalChain([runtime, 'optionalAccess', _35 => _35.env, 'optionalAccess', _36 => _36.brass, 'optionalAccess', _37 => _37.tracer]);
+  if (_optionalChain([tracer, 'optionalAccess', _38 => _38.newTraceId]) && _optionalChain([tracer, 'optionalAccess', _39 => _39.newSpanId])) return tracer;
+  return {
+    newTraceId: () => randomRuntimeId("trace"),
+    newSpanId: () => randomRuntimeId("span")
+  };
+}
+function traceSamplerRatio(sampler) {
+  if (!sampler || typeof sampler === "function") return void 0;
+  const ratio = sampler[TRACE_SAMPLER_RATIO];
+  return typeof ratio === "number" && Number.isFinite(ratio) ? ratio : void 0;
+}
+function randomRuntimeId(prefix) {
+  const cryptoLike = globalThis.crypto;
+  if (typeof _optionalChain([cryptoLike, 'optionalAccess', _40 => _40.randomUUID]) === "function") return cryptoLike.randomUUID();
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function httpErrorFromCause(cause) {
+  const failure = _chunkMVGUEJ5Zcjs.Cause.firstFailure(cause);
+  if (failure._tag === "Some") return failure.value;
+  if (_chunkMVGUEJ5Zcjs.Cause.containsInterrupt(cause)) return { _tag: "Abort" };
+  const defect = _chunkMVGUEJ5Zcjs.Cause.firstDefect(cause);
+  const value = defect._tag === "Some" ? defect.value : _chunkMVGUEJ5Zcjs.Cause.toError(cause);
+  return {
+    _tag: "FetchError",
+    message: value instanceof Error ? value.message : String(value),
+    cause: value
+  };
+}
+function makeHttpMetricCache() {
+  return {
+    disabled: false,
+    leanEntries: /* @__PURE__ */ new Map(),
+    inFlightGauges: /* @__PURE__ */ new Map(),
+    requestCounters: /* @__PURE__ */ new Map(),
+    durationHistograms: /* @__PURE__ */ new Map()
+  };
+}
+function attachMetricCache(metrics, cache) {
+  if (!metrics) return;
+  const existing = metricResetRegistry.get(metrics);
+  if (existing) {
+    existing.caches.add(cache);
+    return;
+  }
+  const entry = {
+    caches: /* @__PURE__ */ new Set([cache]),
+    reset: metrics.reset.bind(metrics)
+  };
+  try {
+    Object.defineProperty(metrics, "reset", {
+      configurable: true,
+      value: () => {
+        for (const cached of entry.caches) clearHttpMetricCache(cached);
+        entry.reset();
+      }
+    });
+    metricResetRegistry.set(metrics, entry);
+  } catch (e) {
+    cache.disabled = true;
+  }
+}
+function clearHttpMetricCache(cache) {
+  cache.leanEntries.clear();
+  cache.inFlightGauges.clear();
+  cache.requestCounters.clear();
+  cache.durationHistograms.clear();
+}
+function getCachedMetric(owner, cache, key, create) {
+  if (owner.disabled) return create();
+  const existing = cache.get(key);
+  if (existing) return existing;
+  const created = create();
+  if (cache.size < MAX_HTTP_METRIC_CACHE_ENTRIES) {
+    cache.set(key, created);
+  }
+  return created;
+}
+function metricCacheKey(name, labels) {
+  let key = name;
+  for (const [label, value] of Object.entries(labels)) {
+    key += `|${label.length}:${label}=${value.length}:${value}`;
+  }
+  return key;
+}
+function beginHttpObservation(req, options, metricCache) {
   return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
     const startedAt = options.clock();
     let finished = false;
-    const inFlight = _optionalChain([options, 'access', _ => _.metrics, 'optionalAccess', _2 => _2.gauge, 'call', _3 => _3("brass_http_client_in_flight", requestBaseLabels(req, options))]);
-    _optionalChain([inFlight, 'optionalAccess', _4 => _4.increment, 'call', _5 => _5()]);
+    const baseLabels = requestBaseLabels(req, options);
+    const inFlight = options.metrics ? getCachedMetric(
+      metricCache,
+      metricCache.inFlightGauges,
+      metricCacheKey("brass_http_client_in_flight", baseLabels),
+      () => options.metrics.gauge("brass_http_client_in_flight", baseLabels)
+    ) : void 0;
+    _optionalChain([inFlight, 'optionalAccess', _41 => _41.increment, 'call', _42 => _42()]);
     const finish = (outcome, status, extra = {}) => {
       const durationMs = Math.max(0, options.clock() - startedAt);
-      const labels = requestFinishLabels(req, outcome, status, options);
+      const labels = requestFinishLabelsFromBase(baseLabels, outcome, status);
       if (!finished) {
         finished = true;
         if (inFlight && inFlight.value() > 0) inFlight.decrement();
-        _optionalChain([options, 'access', _6 => _6.metrics, 'optionalAccess', _7 => _7.counter, 'call', _8 => _8("brass_http_client_requests_total", labels), 'access', _9 => _9.increment, 'call', _10 => _10()]);
-        _optionalChain([options, 'access', _11 => _11.metrics, 'optionalAccess', _12 => _12.histogram, 'call', _13 => _13("brass_http_client_duration_ms", [..._nullishCoalesce(options.durationBuckets, () => ( DEFAULT_DURATION_BUCKETS))], labels), 'access', _14 => _14.observe, 'call', _15 => _15(durationMs, currentTraceExemplar(durationMs, startedAt + durationMs))]);
+        if (options.metrics) {
+          getCachedMetric(
+            metricCache,
+            metricCache.requestCounters,
+            metricCacheKey("brass_http_client_requests_total", labels),
+            () => options.metrics.counter("brass_http_client_requests_total", labels)
+          ).increment();
+          getCachedMetric(
+            metricCache,
+            metricCache.durationHistograms,
+            metricCacheKey("brass_http_client_duration_ms", labels),
+            () => options.metrics.histogram(
+              "brass_http_client_duration_ms",
+              [..._nullishCoalesce(options.durationBuckets, () => ( DEFAULT_DURATION_BUCKETS))],
+              labels
+            )
+          ).observe(
+            durationMs,
+            options.spans === false ? void 0 : currentTraceExemplar(durationMs, startedAt + durationMs)
+          );
+        }
       }
       return {
         durationMs,
         outcome,
         labels,
-        spanAttributes: {
+        spanAttributes: options.spans === false ? EMPTY_SPAN_ATTRIBUTES : {
           "http.duration_ms": durationMs,
           "http.outcome": outcome,
           ...status ? { "http.status_code": Number(status) } : {},
@@ -174,17 +589,17 @@ function beginHttpObservation(req, options) {
         }
       };
     };
-    const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
-    _optionalChain([fiber, 'optionalAccess', _16 => _16.addFinalizer, 'optionalCall', _17 => _17(() => {
+    const fiber = _chunkSSQJKDN3cjs.getCurrentFiber.call(void 0, );
+    _optionalChain([fiber, 'optionalAccess', _43 => _43.addFinalizer, 'optionalCall', _44 => _44(() => {
       finish("abort", void 0, { "http.cancelled": true });
     })]);
     return {
       finishWithResponse: (res) => finish(httpStatusOutcome(res.status), String(res.status)),
       finishWithError: (error) => {
-        const status = _chunk3LOYJFRRcjs.httpErrorStatus.call(void 0, error);
+        const status = _chunkVIFA4DPNcjs.httpErrorStatus.call(void 0, error);
         return finish(httpErrorOutcome(error), status !== void 0 ? String(status) : void 0, {
           "error.type": error._tag,
-          "http.retryable": _chunk3LOYJFRRcjs.isRetryableHttpError.call(void 0, error)
+          "http.retryable": _chunkVIFA4DPNcjs.isRetryableHttpError.call(void 0, error)
         });
       }
     };
@@ -197,13 +612,13 @@ function prepareHttpRequest(req, options) {
 function logHttpRequest(req, options) {
   const level = options.logs === false ? false : _nullishCoalesce(options.logs.requestLevel, () => ( false));
   if (!level) return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0);
-  return _chunkWBGRHGBPcjs.logEffect.call(void 0, level, "http.client.request", requestLogFields(req, options));
+  return _chunkLXBU5E77cjs.logEffect.call(void 0, level, "http.client.request", requestLogFields(req, options));
 }
 function logHttpResponse(req, res, finish, options) {
   const configured = options.logs === false ? false : _nullishCoalesce(options.logs.responseLevel, () => ( false));
   const level = configured || (finish.outcome === "error" ? options.logs !== false ? _nullishCoalesce(options.logs.errorLevel, () => ( "warn")) : false : false);
   if (!level) return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0);
-  return _chunkWBGRHGBPcjs.logEffect.call(void 0, level, "http.client.response", {
+  return _chunkLXBU5E77cjs.logEffect.call(void 0, level, "http.client.response", {
     ...requestLogFields(req, options),
     status: res.status,
     statusText: res.statusText,
@@ -214,15 +629,15 @@ function logHttpResponse(req, res, finish, options) {
 function logHttpError(req, error, finish, options) {
   const level = options.logs === false ? false : _nullishCoalesce(options.logs.errorLevel, () => ( "error"));
   if (!level) return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0);
-  const status = _chunk3LOYJFRRcjs.httpErrorStatus.call(void 0, error);
+  const status = _chunkVIFA4DPNcjs.httpErrorStatus.call(void 0, error);
   const statusText = httpErrorStatusText(error);
-  return _chunkWBGRHGBPcjs.logEffect.call(void 0, level, "http.client.error", {
+  return _chunkLXBU5E77cjs.logEffect.call(void 0, level, "http.client.error", {
     ...requestLogFields(req, options),
     outcome: finish.outcome,
     durationMs: finish.durationMs,
     ...status !== void 0 ? { status } : {},
     ...statusText ? { statusText } : {},
-    retryable: _chunk3LOYJFRRcjs.isRetryableHttpError.call(void 0, error),
+    retryable: _chunkVIFA4DPNcjs.isRetryableHttpError.call(void 0, error),
     errorTag: error._tag,
     message: httpErrorMessage(error)
   });
@@ -231,16 +646,17 @@ function resolveHttpObservabilityOptions(options) {
   const maybeObservability = isObservabilityInstance(options) ? options : void 0;
   const raw = maybeObservability ? { metrics: maybeObservability.metrics } : options;
   return {
-    metrics: _optionalChain([raw, 'optionalAccess', _18 => _18.metrics]) === false ? void 0 : _optionalChain([raw, 'optionalAccess', _19 => _19.metrics]),
-    logs: _nullishCoalesce(_optionalChain([raw, 'optionalAccess', _20 => _20.logs]), () => ( {})),
-    spans: _nullishCoalesce(_optionalChain([raw, 'optionalAccess', _21 => _21.spans]), () => ( {})),
-    adaptiveLimiter: resolveAdaptiveLimiterObservabilityOptions(_optionalChain([raw, 'optionalAccess', _22 => _22.adaptiveLimiter])),
-    policy: resolveHttpPolicyObservabilityOptions(_optionalChain([raw, 'optionalAccess', _23 => _23.policy])),
-    injectTraceHeaders: _nullishCoalesce(_optionalChain([raw, 'optionalAccess', _24 => _24.injectTraceHeaders]), () => ( true)),
-    includeHostLabel: _nullishCoalesce(_optionalChain([raw, 'optionalAccess', _25 => _25.includeHostLabel]), () => ( true)),
-    route: _optionalChain([raw, 'optionalAccess', _26 => _26.route]),
-    clock: _nullishCoalesce(_optionalChain([raw, 'optionalAccess', _27 => _27.clock]), () => ( Date.now)),
-    durationBuckets: _optionalChain([raw, 'optionalAccess', _28 => _28.durationBuckets])
+    metrics: _optionalChain([raw, 'optionalAccess', _45 => _45.metrics]) === false ? void 0 : _optionalChain([raw, 'optionalAccess', _46 => _46.metrics]),
+    logs: _nullishCoalesce(_optionalChain([raw, 'optionalAccess', _47 => _47.logs]), () => ( {})),
+    spans: _nullishCoalesce(_optionalChain([raw, 'optionalAccess', _48 => _48.spans]), () => ( {})),
+    spanSink: _optionalChain([raw, 'optionalAccess', _49 => _49.spanSink]) === false ? void 0 : _optionalChain([raw, 'optionalAccess', _50 => _50.spanSink]),
+    adaptiveLimiter: resolveAdaptiveLimiterObservabilityOptions(_optionalChain([raw, 'optionalAccess', _51 => _51.adaptiveLimiter])),
+    policy: resolveHttpPolicyObservabilityOptions(_optionalChain([raw, 'optionalAccess', _52 => _52.policy])),
+    injectTraceHeaders: _nullishCoalesce(_optionalChain([raw, 'optionalAccess', _53 => _53.injectTraceHeaders]), () => ( true)),
+    includeHostLabel: _nullishCoalesce(_optionalChain([raw, 'optionalAccess', _54 => _54.includeHostLabel]), () => ( true)),
+    route: _optionalChain([raw, 'optionalAccess', _55 => _55.route]),
+    clock: _nullishCoalesce(_optionalChain([raw, 'optionalAccess', _56 => _56.clock]), () => ( Date.now)),
+    durationBuckets: _optionalChain([raw, 'optionalAccess', _57 => _57.durationBuckets])
   };
 }
 function isObservabilityInstance(options) {
@@ -303,11 +719,11 @@ function adaptiveLimiterLabels(req, stats, options) {
   });
 }
 function inferAdaptiveLimiterKey(req, stats) {
-  const policy = _chunk3LOYJFRRcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkVIFA4DPNcjs.getHttpRequestPolicy.call(void 0, req);
   if (policy.poolKey) return policy.poolKey;
   const host = requestHost(req);
   if (host) return host;
-  return _optionalChain([stats, 'access', _29 => _29.keys, 'optionalAccess', _30 => _30.length]) === 1 ? stats.keys[0] : void 0;
+  return _optionalChain([stats, 'access', _58 => _58.keys, 'optionalAccess', _59 => _59.length]) === 1 ? stats.keys[0] : void 0;
 }
 function setGauge(metrics, name, value, labels) {
   if (!metrics || value === void 0 || !Number.isFinite(value)) return;
@@ -330,6 +746,9 @@ function spanName(req, options) {
   }
   return `HTTP ${req.method}`;
 }
+function shouldEmitHttpSpanEvents(options) {
+  return options.spans !== false && options.spans.events !== false;
+}
 function spanStartAttributes(req, options) {
   const spanOptions = options.spans === false ? {} : options.spans.attributes;
   const custom = typeof spanOptions === "function" ? spanOptions(req) : _nullishCoalesce(spanOptions, () => ( {}));
@@ -361,9 +780,9 @@ function requestBaseLabels(req, options) {
     ...requestPolicyMetricLabels(req, options)
   });
 }
-function requestFinishLabels(req, outcome, status, options) {
+function requestFinishLabelsFromBase(baseLabels, outcome, status) {
   return {
-    ...requestBaseLabels(req, options),
+    ...baseLabels,
     outcome,
     status: _nullishCoalesce(status, () => ( "none"))
   };
@@ -382,7 +801,7 @@ function requestLogFields(req, options) {
 }
 function requestPolicyLogFields(req, options) {
   if (!options.policy.enabled) return void 0;
-  const policy = _chunk3LOYJFRRcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkVIFA4DPNcjs.getHttpRequestPolicy.call(void 0, req);
   const fields = {
     ...policy.preset ? { preset: policy.preset } : {},
     ...policy.lane ? { lane: policy.lane } : {},
@@ -395,7 +814,7 @@ function requestPolicyLogFields(req, options) {
 }
 function requestPolicySpanAttributes(req, options) {
   if (!options.policy.enabled) return {};
-  const policy = _chunk3LOYJFRRcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkVIFA4DPNcjs.getHttpRequestPolicy.call(void 0, req);
   return {
     ...compactSpanAttributes({
       "http.request.policy.lane": policy.lane,
@@ -409,7 +828,7 @@ function requestPolicySpanAttributes(req, options) {
 }
 function requestPolicyMetricLabels(req, options) {
   if (!options.policy.enabled || options.policy.labelKeys.length === 0) return {};
-  const policy = _chunk3LOYJFRRcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkVIFA4DPNcjs.getHttpRequestPolicy.call(void 0, req);
   const values = {
     preset: policy.preset,
     lane: policy.lane,
@@ -485,23 +904,23 @@ function httpErrorStatusText(error) {
   return error._tag === "FetchError" ? error.statusText : void 0;
 }
 function injectCurrentTraceContext(req) {
-  const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
-  const trace = _optionalChain([fiber, 'optionalAccess', _31 => _31.fiberContext, 'optionalAccess', _32 => _32.trace]);
-  if (!_optionalChain([trace, 'optionalAccess', _33 => _33.traceId]) || !_optionalChain([trace, 'optionalAccess', _34 => _34.spanId])) return req;
+  const fiber = _chunkSSQJKDN3cjs.getCurrentFiber.call(void 0, );
+  const trace = _optionalChain([fiber, 'optionalAccess', _60 => _60.fiberContext, 'optionalAccess', _61 => _61.trace]);
+  if (!_optionalChain([trace, 'optionalAccess', _62 => _62.traceId]) || !_optionalChain([trace, 'optionalAccess', _63 => _63.spanId])) return req;
   return {
     ...req,
-    headers: _chunkWBGRHGBPcjs.injectTraceContext.call(void 0, req.headers, trace)
+    headers: _chunkLXBU5E77cjs.injectTraceContext.call(void 0, req.headers, trace)
   };
 }
 function currentTraceExemplar(value, timestamp) {
-  const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
-  return _chunkWBGRHGBPcjs.exemplarFromTraceContext.call(void 0, _optionalChain([fiber, 'optionalAccess', _35 => _35.fiberContext, 'optionalAccess', _36 => _36.trace]), value, timestamp);
+  const fiber = _chunkSSQJKDN3cjs.getCurrentFiber.call(void 0, );
+  return _chunkLXBU5E77cjs.exemplarFromTraceContext.call(void 0, _optionalChain([fiber, 'optionalAccess', _64 => _64.fiberContext, 'optionalAccess', _65 => _65.trace]), value, timestamp);
 }
 function requestHost(req) {
   if (!isAbsoluteUrl(req.url)) return void 0;
   try {
     return new URL(req.url).host;
-  } catch (e) {
+  } catch (e2) {
     return void 0;
   }
 }
@@ -511,7 +930,7 @@ function urlScheme(url) {
   if (!isAbsoluteUrl(url)) return void 0;
   try {
     return new URL(url).protocol.replace(/:$/, "");
-  } catch (e2) {
+  } catch (e3) {
     return void 0;
   }
 }
@@ -522,7 +941,7 @@ function urlPath(url) {
   }
   try {
     return new URL(url).pathname;
-  } catch (e3) {
+  } catch (e4) {
     return void 0;
   }
 }
@@ -533,7 +952,7 @@ function sanitizeUrl(url) {
     parsed.search = "";
     parsed.hash = "";
     return parsed.toString();
-  } catch (e4) {
+  } catch (e5) {
     const [withoutHash] = url.split("#", 1);
     const [withoutQuery] = withoutHash.split("?", 1);
     return withoutQuery;
@@ -563,38 +982,38 @@ function compactLabels(labels) {
 
 // src/observability/adapters.ts
 function makeFetchRequestObservabilityContext(observability, request, input = {}) {
-  return _chunkWBGRHGBPcjs.makeRequestObservabilityContext.call(void 0, observability, {
+  return _chunkLXBU5E77cjs.makeRequestObservabilityContext.call(void 0, observability, {
     headers: request.headers,
     method: request.method,
-    target: _chunkWBGRHGBPcjs.sanitizeHttpTarget.call(void 0, request.url),
-    route: _nullishCoalesce(input.route, () => ( _chunkWBGRHGBPcjs.normalizeHttpRoute.call(void 0, urlPathname(request.url)))),
+    target: _chunkLXBU5E77cjs.sanitizeHttpTarget.call(void 0, request.url),
+    route: _nullishCoalesce(input.route, () => ( _chunkLXBU5E77cjs.normalizeHttpRoute.call(void 0, urlPathname(request.url)))),
     ...input
   });
 }
 function makeNodeRequestObservabilityContext(observability, request, input = {}) {
-  return _chunkWBGRHGBPcjs.makeRequestObservabilityContext.call(void 0, observability, {
+  return _chunkLXBU5E77cjs.makeRequestObservabilityContext.call(void 0, observability, {
     headers: request.headers,
     method: request.method,
-    target: _chunkWBGRHGBPcjs.sanitizeHttpTarget.call(void 0, request.url),
-    route: _nullishCoalesce(input.route, () => ( _chunkWBGRHGBPcjs.normalizeHttpRoute.call(void 0, request.url))),
+    target: _chunkLXBU5E77cjs.sanitizeHttpTarget.call(void 0, request.url),
+    route: _nullishCoalesce(input.route, () => ( _chunkLXBU5E77cjs.normalizeHttpRoute.call(void 0, request.url))),
     ...input
   });
 }
 function makeExpressRequestObservabilityContext(observability, request, input = {}) {
-  return _chunkWBGRHGBPcjs.makeRequestObservabilityContext.call(void 0, observability, {
+  return _chunkLXBU5E77cjs.makeRequestObservabilityContext.call(void 0, observability, {
     headers: request.headers,
     method: request.method,
-    target: _chunkWBGRHGBPcjs.sanitizeHttpTarget.call(void 0, _nullishCoalesce(request.originalUrl, () => ( request.url))),
-    route: _nullishCoalesce(_nullishCoalesce(input.route, () => ( _optionalChain([request, 'access', _37 => _37.route, 'optionalAccess', _38 => _38.path]))), () => ( _chunkWBGRHGBPcjs.normalizeHttpRoute.call(void 0, _nullishCoalesce(request.path, () => ( request.url))))),
+    target: _chunkLXBU5E77cjs.sanitizeHttpTarget.call(void 0, _nullishCoalesce(request.originalUrl, () => ( request.url))),
+    route: _nullishCoalesce(_nullishCoalesce(input.route, () => ( _optionalChain([request, 'access', _66 => _66.route, 'optionalAccess', _67 => _67.path]))), () => ( _chunkLXBU5E77cjs.normalizeHttpRoute.call(void 0, _nullishCoalesce(request.path, () => ( request.url))))),
     ...input
   });
 }
 function makeFastifyRequestObservabilityContext(observability, request, input = {}) {
-  return _chunkWBGRHGBPcjs.makeRequestObservabilityContext.call(void 0, observability, {
+  return _chunkLXBU5E77cjs.makeRequestObservabilityContext.call(void 0, observability, {
     headers: request.headers,
     method: request.method,
-    target: _chunkWBGRHGBPcjs.sanitizeHttpTarget.call(void 0, request.url),
-    route: _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(input.route, () => ( _optionalChain([request, 'access', _39 => _39.routeOptions, 'optionalAccess', _40 => _40.url]))), () => ( request.routerPath)), () => ( _chunkWBGRHGBPcjs.normalizeHttpRoute.call(void 0, request.url))),
+    target: _chunkLXBU5E77cjs.sanitizeHttpTarget.call(void 0, request.url),
+    route: _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(input.route, () => ( _optionalChain([request, 'access', _68 => _68.routeOptions, 'optionalAccess', _69 => _69.url]))), () => ( request.routerPath)), () => ( _chunkLXBU5E77cjs.normalizeHttpRoute.call(void 0, request.url))),
     ...input
   });
 }
@@ -608,14 +1027,14 @@ function urlPathname(url) {
   if (!url) return void 0;
   try {
     return new URL(url, "http://local").pathname;
-  } catch (e5) {
+  } catch (e6) {
     return url;
   }
 }
 
 // src/observability/config.ts
 function makeNoopObservability() {
-  return _chunkWBGRHGBPcjs.makeObservability.call(void 0, {
+  return _chunkLXBU5E77cjs.makeObservability.call(void 0, {
     metrics: false,
     logs: false,
     traces: false,
@@ -624,12 +1043,12 @@ function makeNoopObservability() {
 }
 function makeObservabilityPreset(preset, overrides = {}) {
   if (preset === "disabled") return makeNoopObservability();
-  return _chunkWBGRHGBPcjs.makeObservability.call(void 0, mergeObservabilityOptions(observabilityOptionsForPreset(preset), overrides));
+  return _chunkLXBU5E77cjs.makeObservability.call(void 0, mergeObservabilityOptions(observabilityOptionsForPreset(preset), overrides));
 }
 function makeObservabilityFromEnv(env = readProcessEnv(), overrides = {}) {
   const preset = env.BRASS_OBSERVABILITY === "disabled" ? "disabled" : parsePreset(_nullishCoalesce(env.BRASS_OBSERVABILITY_PRESET, () => ( env.NODE_ENV)));
   if (preset === "disabled") return makeNoopObservability();
-  return _chunkWBGRHGBPcjs.makeObservability.call(void 0, mergeObservabilityOptions(observabilityOptionsFromEnv(env, preset), overrides));
+  return _chunkLXBU5E77cjs.makeObservability.call(void 0, mergeObservabilityOptions(observabilityOptionsFromEnv(env, preset), overrides));
 }
 function observabilityOptionsForPreset(preset) {
   switch (preset) {
@@ -713,10 +1132,10 @@ function mergeObservabilityOptions(base, overrides) {
     otlp: {
       ..._nullishCoalesce(base.otlp, () => ( {})),
       ..._nullishCoalesce(overrides.otlp, () => ( {})),
-      retry: _nullishCoalesce(_optionalChain([overrides, 'access', _41 => _41.otlp, 'optionalAccess', _42 => _42.retry]), () => ( _optionalChain([base, 'access', _43 => _43.otlp, 'optionalAccess', _44 => _44.retry]))),
+      retry: _nullishCoalesce(_optionalChain([overrides, 'access', _70 => _70.otlp, 'optionalAccess', _71 => _71.retry]), () => ( _optionalChain([base, 'access', _72 => _72.otlp, 'optionalAccess', _73 => _73.retry]))),
       pipeline: {
-        ..._nullishCoalesce(_optionalChain([base, 'access', _45 => _45.otlp, 'optionalAccess', _46 => _46.pipeline]), () => ( {})),
-        ..._nullishCoalesce(_optionalChain([overrides, 'access', _47 => _47.otlp, 'optionalAccess', _48 => _48.pipeline]), () => ( {}))
+        ..._nullishCoalesce(_optionalChain([base, 'access', _74 => _74.otlp, 'optionalAccess', _75 => _75.pipeline]), () => ( {})),
+        ..._nullishCoalesce(_optionalChain([overrides, 'access', _76 => _76.otlp, 'optionalAccess', _77 => _77.pipeline]), () => ( {}))
       }
     }
   };
@@ -759,6 +1178,92 @@ function readProcessEnv() {
   return typeof process !== "undefined" ? process.env : {};
 }
 
+// src/observability/layer.ts
+var ObservabilityService = _chunk7TXQJFZXcjs.makeServiceTag.call(void 0, "Observability");
+function makeObservabilityLayer(config = {}, options = {}) {
+  const tag = _nullishCoalesce(options.tag, () => ( ObservabilityService));
+  return _chunk7TXQJFZXcjs.layerEffect.call(void 0, 
+    tag,
+    (context) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => _chunkLXBU5E77cjs.makeObservability.call(void 0, resolveObservabilityLayerConfig(config, context))),
+    shutdownObservability
+  );
+}
+function makeObservedRuntimeLayer(options = {}) {
+  const {
+    observabilityTag = ObservabilityService,
+    runtimeTag = _chunk5XADBMSUcjs.RuntimeService,
+    env = {},
+    ...runtimeOptions
+  } = options;
+  return _chunk7TXQJFZXcjs.layerEffect.call(void 0, 
+    runtimeTag,
+    (context) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+      const observability = context.unsafeGet(observabilityTag);
+      return new (0, _chunkSSQJKDN3cjs.Runtime)({
+        ...runtimeOptions,
+        env: mergeRuntimeEnv(resolveObservedRuntimeLayerEnv(env, context, observability), observability.env),
+        hooks: observability.hooks
+      });
+    })
+  );
+}
+function makeObservedHttpClientLayer(config = {}, options = {}) {
+  const observabilityTag = _nullishCoalesce(options.observabilityTag, () => ( ObservabilityService));
+  const httpTag = _nullishCoalesce(options.httpTag, () => ( _chunkVIFA4DPNcjs.HttpClientService));
+  return _chunk7TXQJFZXcjs.layerEffect.call(void 0, 
+    httpTag,
+    (context) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+      const observability = context.unsafeGet(observabilityTag);
+      const httpConfig = resolveObservedHttpClientLayerConfig(config, context, observability);
+      const httpObservability = resolveObservedHttpObservabilityOptions(
+        options.httpObservability,
+        context,
+        observability
+      );
+      return _chunkVIFA4DPNcjs.makeDefaultHttpClient.call(void 0, {
+        ...httpConfig,
+        middleware: [
+          ..._nullishCoalesce(httpConfig.middleware, () => ( [])),
+          withHttpObservability({
+            metrics: observability.metrics,
+            ...httpObservability
+          })
+        ]
+      });
+    }),
+    shutdownDefaultHttpClient
+  );
+}
+function resolveObservabilityLayerConfig(config, context) {
+  return typeof config === "function" ? config(context) : config;
+}
+function resolveObservedHttpClientLayerConfig(config, context, observability) {
+  return typeof config === "function" ? config(context, observability) : config;
+}
+function resolveObservedHttpObservabilityOptions(options, context, observability) {
+  return typeof options === "function" ? options(context, observability) : _nullishCoalesce(options, () => ( {}));
+}
+function resolveObservedRuntimeLayerEnv(env, context, observability) {
+  return typeof env === "function" ? env(context, observability) : env;
+}
+function mergeRuntimeEnv(env, observabilityEnv) {
+  return Object.assign({}, env, observabilityEnv);
+}
+function shutdownObservability(observability) {
+  return _chunkSSQJKDN3cjs.fromPromiseAbortable.call(void 0, 
+    () => observability.shutdown().then(() => void 0),
+    () => void 0,
+    { label: "observability.shutdown" }
+  );
+}
+function shutdownDefaultHttpClient(client) {
+  return client.shutdown();
+}
+
+
+
+
+
 
 
 
@@ -774,4 +1279,4 @@ function readProcessEnv() {
 
 
 
-exports.HTTP_OBSERVABILITY_CONTRACT = HTTP_OBSERVABILITY_CONTRACT; exports.withHttpObservability = withHttpObservability; exports.makeHttpObservabilityMiddleware = makeHttpObservabilityMiddleware; exports.makeFetchRequestObservabilityContext = makeFetchRequestObservabilityContext; exports.makeNodeRequestObservabilityContext = makeNodeRequestObservabilityContext; exports.makeExpressRequestObservabilityContext = makeExpressRequestObservabilityContext; exports.makeFastifyRequestObservabilityContext = makeFastifyRequestObservabilityContext; exports.withFetchRequestObservability = withFetchRequestObservability; exports.withNodeRequestObservability = withNodeRequestObservability; exports.makeNoopObservability = makeNoopObservability; exports.makeObservabilityPreset = makeObservabilityPreset; exports.makeObservabilityFromEnv = makeObservabilityFromEnv; exports.observabilityOptionsForPreset = observabilityOptionsForPreset; exports.observabilityOptionsFromEnv = observabilityOptionsFromEnv;
+exports.HTTP_OBSERVABILITY_CONTRACT = HTTP_OBSERVABILITY_CONTRACT; exports.withHttpObservability = withHttpObservability; exports.makeHttpObservabilityMiddleware = makeHttpObservabilityMiddleware; exports.makeFetchRequestObservabilityContext = makeFetchRequestObservabilityContext; exports.makeNodeRequestObservabilityContext = makeNodeRequestObservabilityContext; exports.makeExpressRequestObservabilityContext = makeExpressRequestObservabilityContext; exports.makeFastifyRequestObservabilityContext = makeFastifyRequestObservabilityContext; exports.withFetchRequestObservability = withFetchRequestObservability; exports.withNodeRequestObservability = withNodeRequestObservability; exports.makeNoopObservability = makeNoopObservability; exports.makeObservabilityPreset = makeObservabilityPreset; exports.makeObservabilityFromEnv = makeObservabilityFromEnv; exports.observabilityOptionsForPreset = observabilityOptionsForPreset; exports.observabilityOptionsFromEnv = observabilityOptionsFromEnv; exports.ObservabilityService = ObservabilityService; exports.makeObservabilityLayer = makeObservabilityLayer; exports.makeObservedRuntimeLayer = makeObservedRuntimeLayer; exports.makeObservedHttpClientLayer = makeObservedHttpClientLayer;