brass-runtime 1.16.0 → 1.17.0

package/dist/{chunk-JNFRRJYH.cjs → chunk-WBGRHGBP.cjs}

@@ -2,29 +2,29 @@
 
 
 
-var _chunkJX3LZQJHcjs = require('./chunk-JX3LZQJH.cjs');
+var _chunk52PPNNI4cjs = require('./chunk-52PPNNI4.cjs');
 
 
 
 
 
 
-var _chunkWQ5QNU5Rcjs = require('./chunk-WQ5QNU5R.cjs');
+var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
 
 
 
 
 
 
-var _chunkDJQ7OMMBcjs = require('./chunk-DJQ7OMMB.cjs');
+var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
 
 
 
-var _chunkSPUEME2Bcjs = require('./chunk-SPUEME2B.cjs');
+var _chunkCZIVE6NTcjs = require('./chunk-CZIVE6NT.cjs');
 
 // src/observability/health.ts
 function snapshotRuntimeHealth(options = {}) {
-  const checkedAtMs = _nullishCoalesce(_optionalChain([options, 'access', _ => _.clock, 'optionalCall', _2 => _2()]), () => ( Date.now()));
+  const checkedAtMs = _nullishCoalesce(_optionalChain([options, 'access', _2 => _2.clock, 'optionalCall', _3 => _3()]), () => ( Date.now()));
   const checks = runChecks(options.checks);
   const circuitBreakers = collectCircuitBreakers(options.circuitBreakers);
   const adaptiveLimiters = collectAdaptiveLimiters(options.adaptiveLimiters);
@@ -40,7 +40,7 @@ function snapshotRuntimeHealth(options = {}) {
   ]);
   return {
     status,
-    ready: status === "ok" || status === "degraded" && _optionalChain([options, 'access', _3 => _3.readiness, 'optionalAccess', _4 => _4.failOnDegraded]) !== true,
+    ready: status === "ok" || status === "degraded" && _optionalChain([options, 'access', _4 => _4.readiness, 'optionalAccess', _5 => _5.failOnDegraded]) !== true,
     checkedAt: new Date(checkedAtMs).toISOString(),
     ...fibers ? { fibers } : {},
     ...scopes ? { scopes } : {},
@@ -52,11 +52,11 @@ function snapshotRuntimeHealth(options = {}) {
   };
 }
 function makeRuntimeHealth(options = {}) {
-  return _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => snapshotRuntimeHealth(options));
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => snapshotRuntimeHealth(options));
 }
 var runtimeHealth = makeRuntimeHealth;
 function readiness(options = {}) {
-  return _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => snapshotRuntimeHealth(options).ready);
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => snapshotRuntimeHealth(options).ready);
 }
 function healthToHttpResponse(report) {
   return {
@@ -125,7 +125,7 @@ function scopeSummary(registry) {
 }
 function metricsSummary(metrics) {
   const snapshot = metrics.snapshot();
-  const gaugeValue = (name) => _optionalChain([snapshot, 'access', _5 => _5.gauges, 'access', _6 => _6.find, 'call', _7 => _7((gauge) => gauge.name === name), 'optionalAccess', _8 => _8.value]);
+  const gaugeValue = (name) => _optionalChain([snapshot, 'access', _6 => _6.gauges, 'access', _7 => _7.find, 'call', _8 => _8((gauge) => gauge.name === name), 'optionalAccess', _9 => _9.value]);
   return {
     counters: snapshot.counters.length,
     gauges: snapshot.gauges.length,
@@ -136,17 +136,17 @@ function metricsSummary(metrics) {
   };
 }
 function runtimeSummary(runtime) {
-  const stats = _optionalChain([runtime, 'access', _9 => _9.stats, 'optionalCall', _10 => _10()]);
-  const scheduler = _optionalChain([runtime, 'access', _11 => _11.scheduler, 'optionalAccess', _12 => _12.stats, 'optionalCall', _13 => _13()]);
+  const stats = _optionalChain([runtime, 'access', _10 => _10.stats, 'optionalCall', _11 => _11()]);
+  const scheduler = _optionalChain([runtime, 'access', _12 => _12.scheduler, 'optionalAccess', _13 => _13.stats, 'optionalCall', _14 => _14()]);
   return {
-    engine: _optionalChain([stats, 'optionalAccess', _14 => _14.engine]),
-    fiberStats: _optionalChain([stats, 'optionalAccess', _15 => _15.data]),
+    engine: _optionalChain([stats, 'optionalAccess', _15 => _15.engine]),
+    fiberStats: _optionalChain([stats, 'optionalAccess', _16 => _16.data]),
     scheduler
   };
 }
 function runtimeSchedulerDropped(runtime) {
-  const data = _optionalChain([runtime, 'optionalAccess', _16 => _16.scheduler, 'optionalAccess', _17 => _17.data]);
-  return typeof _optionalChain([data, 'optionalAccess', _18 => _18.droppedTasks]) === "number" ? data.droppedTasks : 0;
+  const data = _optionalChain([runtime, 'optionalAccess', _17 => _17.scheduler, 'optionalAccess', _18 => _18.data]);
+  return typeof _optionalChain([data, 'optionalAccess', _19 => _19.droppedTasks]) === "number" ? data.droppedTasks : 0;
 }
 function aggregateStatus(statuses) {
   if (statuses.includes("down")) return "down";
@@ -374,7 +374,7 @@ function readHeader(headers, name) {
   return void 0;
 }
 function isIterableHeaders(value) {
-  return typeof _optionalChain([value, 'optionalAccess', _19 => _19[Symbol.iterator]]) === "function";
+  return typeof _optionalChain([value, 'optionalAccess', _20 => _20[Symbol.iterator]]) === "function";
 }
 function hasHeader(headers, name) {
   const lower = name.toLowerCase();
@@ -440,14 +440,14 @@ function makePrometheusMetricsExporter(registry, options = {}) {
 function formatPrometheusMetrics(snapshot, options = {}) {
   const lines = [];
   const emittedHeaders = /* @__PURE__ */ new Set();
-  const now = Math.trunc(_nullishCoalesce(_optionalChain([options, 'access', _20 => _20.now, 'optionalCall', _21 => _21()]), () => ( Date.now())));
+  const now = Math.trunc(_nullishCoalesce(_optionalChain([options, 'access', _21 => _21.now, 'optionalCall', _22 => _22()]), () => ( Date.now())));
   const metricName = (name) => sanitizeMetricName(`${_nullishCoalesce(options.prefix, () => ( ""))}${name}`);
   const emitHeader = (name, type) => {
     const safeName = metricName(name);
     const key = `${safeName}:${type}`;
     if (emittedHeaders.has(key)) return;
     emittedHeaders.add(key);
-    if (_optionalChain([options, 'access', _22 => _22.help, 'optionalAccess', _23 => _23[name]])) lines.push(`# HELP ${safeName} ${escapeHelp(options.help[name])}`);
+    if (_optionalChain([options, 'access', _23 => _23.help, 'optionalAccess', _24 => _24[name]])) lines.push(`# HELP ${safeName} ${escapeHelp(options.help[name])}`);
     lines.push(`# TYPE ${safeName} ${type}`);
   };
   const emitSample = (name, labels, value, exemplar) => {
@@ -469,10 +469,10 @@ function formatPrometheusMetrics(snapshot, options = {}) {
     let cumulative = 0;
     for (let i = 0; i < buckets.boundaries.length; i++) {
       cumulative += _nullishCoalesce(buckets.counts[i], () => ( 0));
-      emitSample(`${histogram.name}_bucket`, { ...histogram.labels, le: String(buckets.boundaries[i]) }, cumulative, _optionalChain([buckets, 'access', _24 => _24.exemplars, 'optionalAccess', _25 => _25[i]]));
+      emitSample(`${histogram.name}_bucket`, { ...histogram.labels, le: String(buckets.boundaries[i]) }, cumulative, _optionalChain([buckets, 'access', _25 => _25.exemplars, 'optionalAccess', _26 => _26[i]]));
     }
     cumulative += _nullishCoalesce(buckets.counts[buckets.boundaries.length], () => ( 0));
-    emitSample(`${histogram.name}_bucket`, { ...histogram.labels, le: "+Inf" }, cumulative, _optionalChain([buckets, 'access', _26 => _26.exemplars, 'optionalAccess', _27 => _27[buckets.boundaries.length]]));
+    emitSample(`${histogram.name}_bucket`, { ...histogram.labels, le: "+Inf" }, cumulative, _optionalChain([buckets, 'access', _27 => _27.exemplars, 'optionalAccess', _28 => _28[buckets.boundaries.length]]));
     emitSample(`${histogram.name}_sum`, histogram.labels, buckets.sum);
     emitSample(`${histogram.name}_count`, histogram.labels, buckets.count);
   }
@@ -480,7 +480,7 @@ function formatPrometheusMetrics(snapshot, options = {}) {
 `;
 }
 function metricsSnapshotToOtlp(snapshot, options = {}) {
-  const timeUnixNano = unixNanoFromMs(_nullishCoalesce(_optionalChain([options, 'access', _28 => _28.now, 'optionalCall', _29 => _29()]), () => ( Date.now())));
+  const timeUnixNano = unixNanoFromMs(_nullishCoalesce(_optionalChain([options, 'access', _29 => _29.now, 'optionalCall', _30 => _30()]), () => ( Date.now())));
   const scope = { name: _nullishCoalesce(options.scopeName, () => ( "brass-runtime")) };
   if (options.scopeVersion) scope.version = options.scopeVersion;
   const metrics = [];
@@ -627,7 +627,7 @@ function recordRuntimeMetricEvent(ev, ctx, now, durationBuckets, state) {
   }
 }
 function exemplarFromTraceContext(trace, value, timestamp = Date.now(), labels) {
-  if (!_optionalChain([trace, 'optionalAccess', _30 => _30.traceId]) || !_optionalChain([trace, 'optionalAccess', _31 => _31.spanId])) return void 0;
+  if (!_optionalChain([trace, 'optionalAccess', _31 => _31.traceId]) || !_optionalChain([trace, 'optionalAccess', _32 => _32.spanId])) return void 0;
   return {
     value,
     timestamp,
@@ -682,7 +682,7 @@ async function postOtlpJson(options, body) {
     },
     body
   });
-  if (_optionalChain([response, 'optionalAccess', _32 => _32.ok]) === false) {
+  if (_optionalChain([response, 'optionalAccess', _33 => _33.ok]) === false) {
     let detail = "";
     try {
       detail = response.text ? `: ${await response.text()}` : "";
@@ -795,42 +795,42 @@ function makeOtlpHttpLogExporter(source, options) {
   };
 }
 function logEffect(level, message, fields = {}) {
-  return _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => {
-    const fiber = _chunkWQ5QNU5Rcjs.getCurrentFiber.call(void 0, );
-    const runtime = _optionalChain([fiber, 'optionalAccess', _33 => _33.runtime]);
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
+    const runtime = _optionalChain([fiber, 'optionalAccess', _34 => _34.runtime]);
     if (!runtime) return;
-    const inherited = _optionalChain([fiber, 'access', _34 => _34.fiberContext, 'optionalAccess', _35 => _35.log]) ? _chunkWQ5QNU5Rcjs.ctxToObject.call(void 0, fiber.fiberContext.log) : {};
+    const inherited = _optionalChain([fiber, 'access', _35 => _35.fiberContext, 'optionalAccess', _36 => _36.log]) ? _chunkGLE2WY7Zcjs.ctxToObject.call(void 0, fiber.fiberContext.log) : {};
     runtime.log(level, message, { ...inherited, ...fields });
   });
 }
 function withLogContext(patch, effect) {
-  return _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
     startLogContext(patch),
-    (state) => _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+    (state) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
       effect,
-      (error) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, endLogContext(state), () => _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error)),
-      (value) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, endLogContext(state), () => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, value))
+      (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, endLogContext(state), () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)),
+      (value) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, endLogContext(state), () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value))
     )
   );
 }
 function startLogContext(patch) {
-  return _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => {
-    const fiber = _chunkWQ5QNU5Rcjs.getCurrentFiber.call(void 0, );
-    if (!_optionalChain([fiber, 'optionalAccess', _36 => _36.fiberContext])) return void 0;
-    const previous = _nullishCoalesce(fiber.fiberContext.log, () => ( _chunkWQ5QNU5Rcjs.emptyContext));
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
+    if (!_optionalChain([fiber, 'optionalAccess', _37 => _37.fiberContext])) return void 0;
+    const previous = _nullishCoalesce(fiber.fiberContext.log, () => ( _chunkGLE2WY7Zcjs.emptyContext));
     const state = { fiber, previous, ended: false };
-    fiber.fiberContext = { ...fiber.fiberContext, log: _chunkWQ5QNU5Rcjs.ctxExtend.call(void 0, previous, patch) };
-    _optionalChain([fiber, 'access', _37 => _37.addFinalizer, 'optionalCall', _38 => _38(() => restoreLogContext(state))]);
+    fiber.fiberContext = { ...fiber.fiberContext, log: _chunkGLE2WY7Zcjs.ctxExtend.call(void 0, previous, patch) };
+    _optionalChain([fiber, 'access', _38 => _38.addFinalizer, 'optionalCall', _39 => _39(() => restoreLogContext(state))]);
     return state;
   });
 }
 function endLogContext(state) {
-  return _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => restoreLogContext(state));
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => restoreLogContext(state));
 }
 function restoreLogContext(state) {
   if (!state || state.ended) return;
   state.ended = true;
-  if (_optionalChain([state, 'access', _39 => _39.fiber, 'optionalAccess', _40 => _40.fiberContext])) {
+  if (_optionalChain([state, 'access', _40 => _40.fiber, 'optionalAccess', _41 => _41.fiberContext])) {
     state.fiber.fiberContext = { ...state.fiber.fiberContext, log: state.previous };
   }
 }
@@ -921,8 +921,8 @@ function resolveTraceSampling(config) {
   }
   return {
     sampler: makeTraceSampler(_nullishCoalesce(config, () => ( {}))),
-    respectRemoteSampled: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _41 => _41.respectRemoteSampled]), () => ( true)),
-    forceSampleOnError: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _42 => _42.forceSampleOnError]), () => ( false))
+    respectRemoteSampled: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _42 => _42.respectRemoteSampled]), () => ( true)),
+    forceSampleOnError: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _43 => _43.forceSampleOnError]), () => ( false))
   };
 }
 function shouldSampleWith(sampler, input) {
@@ -932,7 +932,7 @@ function shouldSampleWith(sampler, input) {
 }
 function samplingRuleMatches(rule, input) {
   if (rule.name && !matchText(rule.name, input.spanName)) return false;
-  if (rule.route && !matchText(rule.route, _optionalChain([input, 'access', _43 => _43.attributes, 'optionalAccess', _44 => _44["http.route"]]))) return false;
+  if (rule.route && !matchText(rule.route, _optionalChain([input, 'access', _44 => _44.attributes, 'optionalAccess', _45 => _45["http.route"]]))) return false;
   return true;
 }
 function matchText(pattern, value) {
@@ -957,12 +957,12 @@ function clampRatio(value) {
 // src/observability/traces.ts
 function withSpan(name, effect, attributesOrOptions) {
   const options = resolveSpanOptions(attributesOrOptions);
-  return _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
     startSpan(name, options),
-    (state) => _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+    (state) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
       effect,
-      (error) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, endSpan(state, "failure", error), () => _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error)),
-      (value) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, endSpan(state, "success"), () => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, value))
+      (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, endSpan(state, "failure", error), () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)),
+      (value) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, endSpan(state, "success"), () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value))
     )
   );
 }
@@ -975,30 +975,30 @@ function spanLink(trace, attributes) {
   };
 }
 function currentSpanLink(attributes) {
-  const fiber = _chunkWQ5QNU5Rcjs.getCurrentFiber.call(void 0, );
-  const trace = _optionalChain([fiber, 'optionalAccess', _45 => _45.fiberContext, 'optionalAccess', _46 => _46.trace]);
-  return _optionalChain([trace, 'optionalAccess', _47 => _47.traceId]) && _optionalChain([trace, 'optionalAccess', _48 => _48.spanId]) ? spanLink(trace, attributes) : void 0;
+  const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
+  const trace = _optionalChain([fiber, 'optionalAccess', _46 => _46.fiberContext, 'optionalAccess', _47 => _47.trace]);
+  return _optionalChain([trace, 'optionalAccess', _48 => _48.traceId]) && _optionalChain([trace, 'optionalAccess', _49 => _49.spanId]) ? spanLink(trace, attributes) : void 0;
 }
 function withBaggage(baggage, effect) {
-  return _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
     startBaggage(baggage),
-    (state) => _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+    (state) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
       effect,
-      (error) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, endBaggage(state), () => _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error)),
-      (value) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, endBaggage(state), () => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, value))
+      (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, endBaggage(state), () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)),
+      (value) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, endBaggage(state), () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value))
     )
   );
 }
 function currentBaggage() {
-  const fiber = _chunkWQ5QNU5Rcjs.getCurrentFiber.call(void 0, );
-  const baggage = _optionalChain([fiber, 'optionalAccess', _49 => _49.fiberContext, 'optionalAccess', _50 => _50.trace, 'optionalAccess', _51 => _51.baggage]);
+  const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
+  const baggage = _optionalChain([fiber, 'optionalAccess', _50 => _50.fiberContext, 'optionalAccess', _51 => _51.trace, 'optionalAccess', _52 => _52.baggage]);
   return baggage ? { ...baggage } : void 0;
 }
 function spanEvent(name, attributes = {}) {
-  return _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => {
-    const fiber = _chunkWQ5QNU5Rcjs.getCurrentFiber.call(void 0, );
-    const trace = _optionalChain([fiber, 'optionalAccess', _52 => _52.fiberContext, 'optionalAccess', _53 => _53.trace]);
-    if (!_optionalChain([fiber, 'optionalAccess', _54 => _54.runtime]) || !trace || trace.sampled === false) return;
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
+    const trace = _optionalChain([fiber, 'optionalAccess', _53 => _53.fiberContext, 'optionalAccess', _54 => _54.trace]);
+    if (!_optionalChain([fiber, 'optionalAccess', _55 => _55.runtime]) || !trace || trace.sampled === false) return;
     fiber.runtime.hooks.emit(
       { type: "span.event", name, attributes },
       spanContext(fiber, trace)
@@ -1029,26 +1029,26 @@ function makeOtlpHttpSpanExporter(source, options) {
   };
 }
 function startSpan(name, options) {
-  return _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => {
-    const fiber = _chunkWQ5QNU5Rcjs.getCurrentFiber.call(void 0, );
-    const runtime = _optionalChain([fiber, 'optionalAccess', _55 => _55.runtime]);
-    if (!_optionalChain([fiber, 'optionalAccess', _56 => _56.fiberContext]) || !runtime) return void 0;
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
+    const runtime = _optionalChain([fiber, 'optionalAccess', _56 => _56.runtime]);
+    if (!_optionalChain([fiber, 'optionalAccess', _57 => _57.fiberContext]) || !runtime) return void 0;
     const previousTrace = _nullishCoalesce(fiber.fiberContext.trace, () => ( null));
     const tracer = resolveTracer(runtime);
-    const traceId = _nullishCoalesce(_optionalChain([previousTrace, 'optionalAccess', _57 => _57.traceId]), () => ( tracer.newTraceId()));
+    const traceId = _nullishCoalesce(_optionalChain([previousTrace, 'optionalAccess', _58 => _58.traceId]), () => ( tracer.newTraceId()));
     const sampled = decideSampling(runtime, {
       traceId,
       spanName: name,
-      parentSampled: _optionalChain([previousTrace, 'optionalAccess', _58 => _58.sampled]),
+      parentSampled: _optionalChain([previousTrace, 'optionalAccess', _59 => _59.sampled]),
       attributes: options.attributes
     });
     const trace = {
       traceId,
       spanId: tracer.newSpanId(),
-      parentSpanId: _optionalChain([previousTrace, 'optionalAccess', _59 => _59.spanId]),
+      parentSpanId: _optionalChain([previousTrace, 'optionalAccess', _60 => _60.spanId]),
       sampled,
-      traceState: _optionalChain([previousTrace, 'optionalAccess', _60 => _60.traceState]),
-      ..._optionalChain([previousTrace, 'optionalAccess', _61 => _61.baggage]) ? { baggage: previousTrace.baggage } : {}
+      traceState: _optionalChain([previousTrace, 'optionalAccess', _61 => _61.traceState]),
+      ..._optionalChain([previousTrace, 'optionalAccess', _62 => _62.baggage]) ? { baggage: previousTrace.baggage } : {}
     };
     const state = {
       fiber,
@@ -1057,14 +1057,14 @@ function startSpan(name, options) {
       trace,
       name,
       options,
-      forceSampleOnError: _optionalChain([runtime, 'optionalAccess', _62 => _62.env, 'optionalAccess', _63 => _63.brass, 'optionalAccess', _64 => _64.forceSampleOnError]) === true,
+      forceSampleOnError: _optionalChain([runtime, 'optionalAccess', _63 => _63.env, 'optionalAccess', _64 => _64.brass, 'optionalAccess', _65 => _65.forceSampleOnError]) === true,
       startEmitted: sampled !== false,
       ended: false
     };
     fiber.fiberContext = { ...fiber.fiberContext, trace };
-    _optionalChain([fiber, 'access', _65 => _65.addFinalizer, 'optionalCall', _66 => _66((exit) => {
-      const status = _optionalChain([exit, 'optionalAccess', _67 => _67._tag]) === "Success" ? "success" : _optionalChain([exit, 'optionalAccess', _68 => _68.cause, 'optionalAccess', _69 => _69._tag]) === "Interrupt" ? "interrupted" : "failure";
-      finishSpan(state, status, _optionalChain([exit, 'optionalAccess', _70 => _70._tag]) === "Failure" ? exit.cause : void 0);
+    _optionalChain([fiber, 'access', _66 => _66.addFinalizer, 'optionalCall', _67 => _67((exit) => {
+      const status = _optionalChain([exit, 'optionalAccess', _68 => _68._tag]) === "Success" ? "success" : _optionalChain([exit, 'optionalAccess', _69 => _69.cause, 'optionalAccess', _70 => _70._tag]) === "Interrupt" ? "interrupted" : "failure";
+      finishSpan(state, status, _optionalChain([exit, 'optionalAccess', _71 => _71._tag]) === "Failure" ? exit.cause : void 0);
     })]);
     if (state.startEmitted) {
       runtime.hooks.emit(
@@ -1076,7 +1076,7 @@ function startSpan(name, options) {
   });
 }
 function endSpan(state, status, error) {
-  return _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => finishSpan(state, status, error));
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => finishSpan(state, status, error));
 }
 function finishSpan(state, status, error) {
   if (!state || state.ended) return;
@@ -1095,14 +1095,14 @@ function finishSpan(state, status, error) {
       spanContext(state.fiber, state.trace)
     );
   }
-  if (_optionalChain([state, 'access', _71 => _71.fiber, 'optionalAccess', _72 => _72.fiberContext])) {
+  if (_optionalChain([state, 'access', _72 => _72.fiber, 'optionalAccess', _73 => _73.fiberContext])) {
     state.fiber.fiberContext = { ...state.fiber.fiberContext, trace: state.previousTrace };
   }
 }
 function spanContext(fiber, trace) {
   return {
-    fiberId: _optionalChain([fiber, 'optionalAccess', _73 => _73.id]),
-    scopeId: _optionalChain([fiber, 'optionalAccess', _74 => _74.scopeId]),
+    fiberId: _optionalChain([fiber, 'optionalAccess', _74 => _74.id]),
+    scopeId: _optionalChain([fiber, 'optionalAccess', _75 => _75.scopeId]),
     traceId: trace.traceId,
     spanId: trace.spanId,
     parentSpanId: trace.parentSpanId,
@@ -1112,9 +1112,9 @@ function spanContext(fiber, trace) {
   };
 }
 function startBaggage(baggage) {
-  return _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => {
-    const fiber = _chunkWQ5QNU5Rcjs.getCurrentFiber.call(void 0, );
-    if (!_optionalChain([fiber, 'optionalAccess', _75 => _75.fiberContext])) return void 0;
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
+    if (!_optionalChain([fiber, 'optionalAccess', _76 => _76.fiberContext])) return void 0;
     const previousTrace = _nullishCoalesce(fiber.fiberContext.trace, () => ( null));
     if (!previousTrace) return void 0;
     const state = { fiber, previousTrace, ended: false };
@@ -1128,28 +1128,28 @@ function startBaggage(baggage) {
         }
       }
     };
-    _optionalChain([fiber, 'access', _76 => _76.addFinalizer, 'optionalCall', _77 => _77(() => restoreBaggage(state))]);
+    _optionalChain([fiber, 'access', _77 => _77.addFinalizer, 'optionalCall', _78 => _78(() => restoreBaggage(state))]);
     return state;
   });
 }
 function endBaggage(state) {
-  return _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => restoreBaggage(state));
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => restoreBaggage(state));
 }
 function restoreBaggage(state) {
   if (!state || state.ended) return;
   state.ended = true;
-  if (_optionalChain([state, 'access', _78 => _78.fiber, 'optionalAccess', _79 => _79.fiberContext])) {
+  if (_optionalChain([state, 'access', _79 => _79.fiber, 'optionalAccess', _80 => _80.fiberContext])) {
     state.fiber.fiberContext = { ...state.fiber.fiberContext, trace: state.previousTrace };
   }
 }
 function decideSampling(runtime, input) {
-  const brass = _optionalChain([runtime, 'optionalAccess', _80 => _80.env, 'optionalAccess', _81 => _81.brass]);
-  if (input.parentSampled === false && _optionalChain([brass, 'optionalAccess', _82 => _82.respectRemoteSampled]) !== false) return false;
-  return shouldSampleWith(_optionalChain([brass, 'optionalAccess', _83 => _83.sampler]), input);
+  const brass = _optionalChain([runtime, 'optionalAccess', _81 => _81.env, 'optionalAccess', _82 => _82.brass]);
+  if (input.parentSampled === false && _optionalChain([brass, 'optionalAccess', _83 => _83.respectRemoteSampled]) !== false) return false;
+  return shouldSampleWith(_optionalChain([brass, 'optionalAccess', _84 => _84.sampler]), input);
 }
 function resolveTracer(runtime) {
-  const tracer = _optionalChain([runtime, 'optionalAccess', _84 => _84.env, 'optionalAccess', _85 => _85.brass, 'optionalAccess', _86 => _86.tracer]);
-  if (_optionalChain([tracer, 'optionalAccess', _87 => _87.newTraceId]) && _optionalChain([tracer, 'optionalAccess', _88 => _88.newSpanId])) return tracer;
+  const tracer = _optionalChain([runtime, 'optionalAccess', _85 => _85.env, 'optionalAccess', _86 => _86.brass, 'optionalAccess', _87 => _87.tracer]);
+  if (_optionalChain([tracer, 'optionalAccess', _88 => _88.newTraceId]) && _optionalChain([tracer, 'optionalAccess', _89 => _89.newSpanId])) return tracer;
   return {
     newTraceId: () => randomRuntimeId("trace"),
     newSpanId: () => randomRuntimeId("span")
@@ -1211,7 +1211,7 @@ function normalizeSpanLink(link) {
 }
 function inferOtlpStatus(span) {
   const end = [...span.events].reverse().find((event) => event.name === "span.end" || event.name === "fiber.end");
-  const status = typeof _optionalChain([end, 'optionalAccess', _89 => _89.attrs]) === "object" && end.attrs != null ? end.attrs.status : void 0;
+  const status = typeof _optionalChain([end, 'optionalAccess', _90 => _90.attrs]) === "object" && end.attrs != null ? end.attrs.status : void 0;
   if (status === "failure" || status === "interrupted") {
     return { code: 2, message: status };
   }
@@ -1232,7 +1232,7 @@ function normalizeAttributes(attrs) {
 }
 function randomRuntimeId(prefix) {
   const cryptoLike = globalThis.crypto;
-  if (typeof _optionalChain([cryptoLike, 'optionalAccess', _90 => _90.randomUUID]) === "function") return cryptoLike.randomUUID();
+  if (typeof _optionalChain([cryptoLike, 'optionalAccess', _91 => _91.randomUUID]) === "function") return cryptoLike.randomUUID();
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 }
 
@@ -1248,15 +1248,15 @@ function makeExportPipeline(options) {
   const maxQueueSize = Math.max(0, Math.floor(_nullishCoalesce(options.maxQueueSize, () => ( DEFAULT_MAX_QUEUE_SIZE))));
   const timeoutMs = Math.max(0, Math.floor(_nullishCoalesce(options.timeoutMs, () => ( DEFAULT_TIMEOUT_MS))));
   const dropPolicy = _nullishCoalesce(options.dropPolicy, () => ( "drop-oldest"));
-  const queueGauge = _optionalChain([options, 'access', _91 => _91.metrics, 'optionalAccess', _92 => _92.gauge, 'call', _93 => _93("brass_export_queue_size", { signal })]);
+  const queueGauge = _optionalChain([options, 'access', _92 => _92.metrics, 'optionalAccess', _93 => _93.gauge, 'call', _94 => _94("brass_export_queue_size", { signal })]);
   let queue = [];
   let droppedTotal = 0;
-  const setQueueSize = () => _optionalChain([queueGauge, 'optionalAccess', _94 => _94.set, 'call', _95 => _95(queue.length)]);
+  const setQueueSize = () => _optionalChain([queueGauge, 'optionalAccess', _95 => _95.set, 'call', _96 => _96(queue.length)]);
   const dropItems = (items) => {
     if (items.length === 0) return;
     droppedTotal += items.length;
-    _optionalChain([options, 'access', _96 => _96.metrics, 'optionalAccess', _97 => _97.counter, 'call', _98 => _98("brass_export_dropped_total", { signal }), 'access', _99 => _99.increment, 'call', _100 => _100(items.length)]);
-    _optionalChain([options, 'access', _101 => _101.onDrop, 'optionalCall', _102 => _102(items)]);
+    _optionalChain([options, 'access', _97 => _97.metrics, 'optionalAccess', _98 => _98.counter, 'call', _99 => _99("brass_export_dropped_total", { signal }), 'access', _100 => _100.increment, 'call', _101 => _101(items.length)]);
+    _optionalChain([options, 'access', _102 => _102.onDrop, 'optionalCall', _103 => _103(items)]);
   };
   const enqueue = (items) => {
     if (items.length === 0 || maxQueueSize === 0) {
@@ -1268,7 +1268,7 @@ function makeExportPipeline(options) {
     const available = maxQueueSize - queue.length;
     if (incoming.length <= available) {
       queue.push(...incoming);
-      _optionalChain([options, 'access', _103 => _103.metrics, 'optionalAccess', _104 => _104.counter, 'call', _105 => _105("brass_export_enqueued_total", { signal }), 'access', _106 => _106.increment, 'call', _107 => _107(incoming.length)]);
+      _optionalChain([options, 'access', _104 => _104.metrics, 'optionalAccess', _105 => _105.counter, 'call', _106 => _106("brass_export_enqueued_total", { signal }), 'access', _107 => _107.increment, 'call', _108 => _108(incoming.length)]);
       setQueueSize();
       return incoming.length;
     }
@@ -1276,7 +1276,7 @@ function makeExportPipeline(options) {
       const accepted = incoming.slice(0, Math.max(0, available));
       const dropped2 = incoming.slice(accepted.length);
       queue.push(...accepted);
-      _optionalChain([options, 'access', _108 => _108.metrics, 'optionalAccess', _109 => _109.counter, 'call', _110 => _110("brass_export_enqueued_total", { signal }), 'access', _111 => _111.increment, 'call', _112 => _112(accepted.length)]);
+      _optionalChain([options, 'access', _109 => _109.metrics, 'optionalAccess', _110 => _110.counter, 'call', _111 => _111("brass_export_enqueued_total", { signal }), 'access', _112 => _112.increment, 'call', _113 => _113(accepted.length)]);
       dropItems(dropped2);
       setQueueSize();
       return accepted.length;
@@ -1287,7 +1287,7 @@ function makeExportPipeline(options) {
     const remainingDrop = dropCount - dropped.length;
     if (remainingDrop > 0) dropped.push(...incoming.splice(0, remainingDrop));
     queue.push(...incoming);
-    _optionalChain([options, 'access', _113 => _113.metrics, 'optionalAccess', _114 => _114.counter, 'call', _115 => _115("brass_export_enqueued_total", { signal }), 'access', _116 => _116.increment, 'call', _117 => _117(incoming.length)]);
+    _optionalChain([options, 'access', _114 => _114.metrics, 'optionalAccess', _115 => _115.counter, 'call', _116 => _116("brass_export_enqueued_total", { signal }), 'access', _117 => _117.increment, 'call', _118 => _118(incoming.length)]);
     dropItems(dropped);
     setQueueSize();
     return incoming.length;
@@ -1320,22 +1320,22 @@ function makeExportPipeline(options) {
         attempts += result.attempts;
         lastStatus = result.value.status;
         lastBody = result.value.body;
-        _optionalChain([options, 'access', _118 => _118.metrics, 'optionalAccess', _119 => _119.counter, 'call', _120 => _120("brass_export_batches_total", { signal, status: "success" }), 'access', _121 => _121.increment, 'call', _122 => _122()]);
-        _optionalChain([options, 'access', _123 => _123.metrics, 'optionalAccess', _124 => _124.counter, 'call', _125 => _125("brass_export_items_total", { signal, status: "success" }), 'access', _126 => _126.increment, 'call', _127 => _127(batch.length)]);
-        _optionalChain([options, 'access', _128 => _128.metrics, 'optionalAccess', _129 => _129.histogram, 'call', _130 => _130("brass_export_batch_duration_ms", void 0, { signal, status: "success" }), 'access', _131 => _131.observe, 'call', _132 => _132(clock() - batchStartedAt)]);
+        _optionalChain([options, 'access', _119 => _119.metrics, 'optionalAccess', _120 => _120.counter, 'call', _121 => _121("brass_export_batches_total", { signal, status: "success" }), 'access', _122 => _122.increment, 'call', _123 => _123()]);
+        _optionalChain([options, 'access', _124 => _124.metrics, 'optionalAccess', _125 => _125.counter, 'call', _126 => _126("brass_export_items_total", { signal, status: "success" }), 'access', _127 => _127.increment, 'call', _128 => _128(batch.length)]);
+        _optionalChain([options, 'access', _129 => _129.metrics, 'optionalAccess', _130 => _130.histogram, 'call', _131 => _131("brass_export_batch_duration_ms", void 0, { signal, status: "success" }), 'access', _132 => _132.observe, 'call', _133 => _133(clock() - batchStartedAt)]);
       } catch (error) {
         failed += batch.length;
         errors.push(error);
         queue = [...batch, ...queue];
-        _optionalChain([options, 'access', _133 => _133.metrics, 'optionalAccess', _134 => _134.counter, 'call', _135 => _135("brass_export_batches_total", { signal, status: "failure" }), 'access', _136 => _136.increment, 'call', _137 => _137()]);
-        _optionalChain([options, 'access', _138 => _138.metrics, 'optionalAccess', _139 => _139.counter, 'call', _140 => _140("brass_export_items_total", { signal, status: "failure" }), 'access', _141 => _141.increment, 'call', _142 => _142(batch.length)]);
-        _optionalChain([options, 'access', _143 => _143.metrics, 'optionalAccess', _144 => _144.histogram, 'call', _145 => _145("brass_export_batch_duration_ms", void 0, { signal, status: "failure" }), 'access', _146 => _146.observe, 'call', _147 => _147(clock() - batchStartedAt)]);
+        _optionalChain([options, 'access', _134 => _134.metrics, 'optionalAccess', _135 => _135.counter, 'call', _136 => _136("brass_export_batches_total", { signal, status: "failure" }), 'access', _137 => _137.increment, 'call', _138 => _138()]);
+        _optionalChain([options, 'access', _139 => _139.metrics, 'optionalAccess', _140 => _140.counter, 'call', _141 => _141("brass_export_items_total", { signal, status: "failure" }), 'access', _142 => _142.increment, 'call', _143 => _143(batch.length)]);
+        _optionalChain([options, 'access', _144 => _144.metrics, 'optionalAccess', _145 => _145.histogram, 'call', _146 => _146("brass_export_batch_duration_ms", void 0, { signal, status: "failure" }), 'access', _147 => _147.observe, 'call', _148 => _148(clock() - batchStartedAt)]);
         break;
       } finally {
         setQueueSize();
       }
     }
-    _optionalChain([options, 'access', _148 => _148.metrics, 'optionalAccess', _149 => _149.histogram, 'call', _150 => _150("brass_export_flush_duration_ms", void 0, { signal }), 'access', _151 => _151.observe, 'call', _152 => _152(clock() - startedAt)]);
+    _optionalChain([options, 'access', _149 => _149.metrics, 'optionalAccess', _150 => _150.histogram, 'call', _151 => _151("brass_export_flush_duration_ms", void 0, { signal }), 'access', _152 => _152.observe, 'call', _153 => _153(clock() - startedAt)]);
     return {
       exported,
       dropped: droppedTotal,
@@ -1356,11 +1356,11 @@ function makeExportPipeline(options) {
   };
 }
 async function exportWithRetry(operation, options) {
-  const attempts = Math.max(1, Math.floor(_nullishCoalesce(_optionalChain([options, 'access', _153 => _153.retry, 'optionalAccess', _154 => _154.attempts]), () => ( 1))));
-  const initialDelayMs = Math.max(0, _nullishCoalesce(_optionalChain([options, 'access', _155 => _155.retry, 'optionalAccess', _156 => _156.initialDelayMs]), () => ( 100)));
-  const maxDelayMs = Math.max(initialDelayMs, _nullishCoalesce(_optionalChain([options, 'access', _157 => _157.retry, 'optionalAccess', _158 => _158.maxDelayMs]), () => ( 2e3)));
-  const jitterRatio = Math.max(0, Math.min(1, _nullishCoalesce(_optionalChain([options, 'access', _159 => _159.retry, 'optionalAccess', _160 => _160.jitterRatio]), () => ( 0.2))));
-  const sleep = _nullishCoalesce(_optionalChain([options, 'access', _161 => _161.retry, 'optionalAccess', _162 => _162.sleep]), () => ( defaultSleep));
+  const attempts = Math.max(1, Math.floor(_nullishCoalesce(_optionalChain([options, 'access', _154 => _154.retry, 'optionalAccess', _155 => _155.attempts]), () => ( 1))));
+  const initialDelayMs = Math.max(0, _nullishCoalesce(_optionalChain([options, 'access', _156 => _156.retry, 'optionalAccess', _157 => _157.initialDelayMs]), () => ( 100)));
+  const maxDelayMs = Math.max(initialDelayMs, _nullishCoalesce(_optionalChain([options, 'access', _158 => _158.retry, 'optionalAccess', _159 => _159.maxDelayMs]), () => ( 2e3)));
+  const jitterRatio = Math.max(0, Math.min(1, _nullishCoalesce(_optionalChain([options, 'access', _160 => _160.retry, 'optionalAccess', _161 => _161.jitterRatio]), () => ( 0.2))));
+  const sleep = _nullishCoalesce(_optionalChain([options, 'access', _162 => _162.retry, 'optionalAccess', _163 => _163.sleep]), () => ( defaultSleep));
   let lastError;
   for (let attempt = 1; attempt <= attempts; attempt++) {
     try {
@@ -1368,7 +1368,7 @@ async function exportWithRetry(operation, options) {
     } catch (error) {
       lastError = error;
       if (attempt >= attempts) break;
-      _optionalChain([options, 'access', _163 => _163.metrics, 'optionalAccess', _164 => _164.counter, 'call', _165 => _165("brass_export_retries_total", { signal: options.signal }), 'access', _166 => _166.increment, 'call', _167 => _167()]);
+      _optionalChain([options, 'access', _164 => _164.metrics, 'optionalAccess', _165 => _165.counter, 'call', _166 => _166("brass_export_retries_total", { signal: options.signal }), 'access', _167 => _167.increment, 'call', _168 => _168()]);
       await sleep(jitteredDelay(initialDelayMs, maxDelayMs, jitterRatio, attempt));
     }
   }
@@ -1382,7 +1382,7 @@ async function withTimeout(operation, timeoutMs) {
       operation(),
       new Promise((_resolve, reject) => {
         handle = setTimeout(() => reject(new Error(`Observability export timed out after ${timeoutMs}ms`)), timeoutMs);
-        _optionalChain([handle, 'access', _168 => _168.unref, 'optionalCall', _169 => _169()]);
+        _optionalChain([handle, 'access', _169 => _169.unref, 'optionalCall', _170 => _170()]);
       })
     ]);
   } finally {
@@ -1398,7 +1398,7 @@ function jitteredDelay(initialDelayMs, maxDelayMs, jitterRatio, attempt) {
 function defaultSleep(ms) {
   return new Promise((resolve) => {
     const handle = setTimeout(resolve, ms);
-    _optionalChain([handle, 'access', _170 => _170.unref, 'optionalCall', _171 => _171()]);
+    _optionalChain([handle, 'access', _171 => _171.unref, 'optionalCall', _172 => _172()]);
   });
 }
 
@@ -1455,53 +1455,54 @@ function sanitizeHttpTarget(url) {
 }
 
 // src/observability/configValidation.ts
-var fn = _chunkSPUEME2Bcjs.Schema.custom((value) => typeof value === "function", "function");
-var object = _chunkSPUEME2Bcjs.Schema.custom(
+var fn = _chunkCZIVE6NTcjs.Schema.custom((value) => typeof value === "function", "function");
+var object = _chunkCZIVE6NTcjs.Schema.custom(
   (value) => typeof value === "object" && value !== null && !Array.isArray(value),
   "object"
 );
-var falseOrObject = _chunkSPUEME2Bcjs.Schema.union([_chunkSPUEME2Bcjs.Schema.literal(false), object]);
-var ratio = _chunkSPUEME2Bcjs.Schema.number({ min: 0, max: 1 });
-var retryOptions = _chunkSPUEME2Bcjs.Schema.object({
-  attempts: _chunkSPUEME2Bcjs.Schema.number({ min: 0, int: true }).optional(),
-  initialDelayMs: _chunkSPUEME2Bcjs.Schema.number({ min: 0, int: true }).optional(),
-  maxDelayMs: _chunkSPUEME2Bcjs.Schema.number({ min: 0, int: true }).optional(),
-  jitterRatio: _chunkSPUEME2Bcjs.Schema.number({ min: 0, max: 1 }).optional(),
+var falseOrObject = _chunkCZIVE6NTcjs.Schema.union([_chunkCZIVE6NTcjs.Schema.literal(false), object]);
+var ratio = _chunkCZIVE6NTcjs.Schema.number({ min: 0, max: 1 });
+var logLevel = _chunkCZIVE6NTcjs.Schema.enum(["debug", "info", "warn", "error"]);
+var retryOptions = _chunkCZIVE6NTcjs.Schema.object({
+  attempts: _chunkCZIVE6NTcjs.Schema.number({ min: 0, int: true }).optional(),
+  initialDelayMs: _chunkCZIVE6NTcjs.Schema.number({ min: 0, int: true }).optional(),
+  maxDelayMs: _chunkCZIVE6NTcjs.Schema.number({ min: 0, int: true }).optional(),
+  jitterRatio: _chunkCZIVE6NTcjs.Schema.number({ min: 0, max: 1 }).optional(),
   sleep: fn.optional()
 }, { unknownKeys: "passthrough" });
-var pipelineOptions = _chunkSPUEME2Bcjs.Schema.object({
-  maxQueueSize: _chunkSPUEME2Bcjs.Schema.number({ min: 0, int: true }).optional(),
-  batchSize: _chunkSPUEME2Bcjs.Schema.number({ min: 1, int: true }).optional(),
-  timeoutMs: _chunkSPUEME2Bcjs.Schema.number({ min: 0, int: true }).optional(),
+var pipelineOptions = _chunkCZIVE6NTcjs.Schema.object({
+  maxQueueSize: _chunkCZIVE6NTcjs.Schema.number({ min: 0, int: true }).optional(),
+  batchSize: _chunkCZIVE6NTcjs.Schema.number({ min: 1, int: true }).optional(),
+  timeoutMs: _chunkCZIVE6NTcjs.Schema.number({ min: 0, int: true }).optional(),
   retry: retryOptions.optional(),
-  dropPolicy: _chunkSPUEME2Bcjs.Schema.enum(["drop-oldest", "drop-newest"]).optional(),
-  shutdownTimeoutMs: _chunkSPUEME2Bcjs.Schema.number({ min: 0, int: true }).optional()
+  dropPolicy: _chunkCZIVE6NTcjs.Schema.enum(["drop-oldest", "drop-newest"]).optional(),
+  shutdownTimeoutMs: _chunkCZIVE6NTcjs.Schema.number({ min: 0, int: true }).optional()
 }, { unknownKeys: "passthrough" });
-var otlpOptions = _chunkSPUEME2Bcjs.Schema.object({
-  metricsUrl: _chunkSPUEME2Bcjs.Schema.string().optional(),
-  tracesUrl: _chunkSPUEME2Bcjs.Schema.string().optional(),
-  logsUrl: _chunkSPUEME2Bcjs.Schema.string().optional(),
-  headers: _chunkSPUEME2Bcjs.Schema.record(_chunkSPUEME2Bcjs.Schema.string()).optional(),
+var otlpOptions = _chunkCZIVE6NTcjs.Schema.object({
+  metricsUrl: _chunkCZIVE6NTcjs.Schema.string().optional(),
+  tracesUrl: _chunkCZIVE6NTcjs.Schema.string().optional(),
+  logsUrl: _chunkCZIVE6NTcjs.Schema.string().optional(),
+  headers: _chunkCZIVE6NTcjs.Schema.record(_chunkCZIVE6NTcjs.Schema.string()).optional(),
   fetch: fn.optional(),
-  timeoutMs: _chunkSPUEME2Bcjs.Schema.number({ min: 1, int: true }).optional(),
+  timeoutMs: _chunkCZIVE6NTcjs.Schema.number({ min: 1, int: true }).optional(),
   retry: retryOptions.optional(),
   pipeline: pipelineOptions.optional()
 }, { unknownKeys: "passthrough" });
-var samplingOptions = _chunkSPUEME2Bcjs.Schema.union([
-  _chunkSPUEME2Bcjs.Schema.literal(false),
+var samplingOptions = _chunkCZIVE6NTcjs.Schema.union([
+  _chunkCZIVE6NTcjs.Schema.literal(false),
   ratio,
   fn,
-  _chunkSPUEME2Bcjs.Schema.object({
+  _chunkCZIVE6NTcjs.Schema.object({
     ratio: ratio.optional(),
-    rules: _chunkSPUEME2Bcjs.Schema.array(object).optional(),
-    sampler: _chunkSPUEME2Bcjs.Schema.union([fn, object]).optional(),
-    respectRemoteSampled: _chunkSPUEME2Bcjs.Schema.boolean().optional(),
-    forceSampleOnError: _chunkSPUEME2Bcjs.Schema.boolean().optional()
+    rules: _chunkCZIVE6NTcjs.Schema.array(object).optional(),
+    sampler: _chunkCZIVE6NTcjs.Schema.union([fn, object]).optional(),
+    respectRemoteSampled: _chunkCZIVE6NTcjs.Schema.boolean().optional(),
+    forceSampleOnError: _chunkCZIVE6NTcjs.Schema.boolean().optional()
   }, { unknownKeys: "passthrough" })
 ]);
-var observabilityOptions = _chunkSPUEME2Bcjs.Schema.object({
-  serviceName: _chunkSPUEME2Bcjs.Schema.string({ minLength: 1 }).optional(),
-  serviceVersion: _chunkSPUEME2Bcjs.Schema.string({ minLength: 1 }).optional(),
+var observabilityOptions = _chunkCZIVE6NTcjs.Schema.object({
+  serviceName: _chunkCZIVE6NTcjs.Schema.string({ minLength: 1 }).optional(),
+  serviceVersion: _chunkCZIVE6NTcjs.Schema.string({ minLength: 1 }).optional(),
   resource: object.optional(),
   eventBus: object.optional(),
   metrics: falseOrObject.optional(),
@@ -1509,34 +1510,101 @@ var observabilityOptions = _chunkSPUEME2Bcjs.Schema.object({
   traces: falseOrObject.optional(),
   sampling: samplingOptions.optional(),
   redaction: falseOrObject.optional(),
-  cardinality: _chunkSPUEME2Bcjs.Schema.union([
-    _chunkSPUEME2Bcjs.Schema.literal(false),
-    _chunkSPUEME2Bcjs.Schema.object({
-      maxValuesPerLabel: _chunkSPUEME2Bcjs.Schema.number({ min: 1, int: true }).optional(),
-      overflowValue: _chunkSPUEME2Bcjs.Schema.string({ minLength: 1 }).optional()
+  cardinality: _chunkCZIVE6NTcjs.Schema.union([
+    _chunkCZIVE6NTcjs.Schema.literal(false),
+    _chunkCZIVE6NTcjs.Schema.object({
+      maxValuesPerLabel: _chunkCZIVE6NTcjs.Schema.number({ min: 1, int: true }).optional(),
+      overflowValue: _chunkCZIVE6NTcjs.Schema.string({ minLength: 1 }).optional()
     }, { unknownKeys: "passthrough" })
   ]).optional(),
   otlp: otlpOptions.optional(),
-  flushIntervalMs: _chunkSPUEME2Bcjs.Schema.number({ min: 1, int: true }).optional(),
-  autoStart: _chunkSPUEME2Bcjs.Schema.boolean().optional(),
+  flushIntervalMs: _chunkCZIVE6NTcjs.Schema.number({ min: 1, int: true }).optional(),
+  autoStart: _chunkCZIVE6NTcjs.Schema.boolean().optional(),
   traceSeed: object.optional(),
   childName: fn.optional(),
   onFlushError: fn.optional()
 }, { unknownKeys: "passthrough" });
+var httpObservabilityOptions = _chunkCZIVE6NTcjs.Schema.object({
+  metrics: falseOrObject.optional(),
+  logs: _chunkCZIVE6NTcjs.Schema.union([
+    _chunkCZIVE6NTcjs.Schema.literal(false),
+    _chunkCZIVE6NTcjs.Schema.object({
+      requestLevel: _chunkCZIVE6NTcjs.Schema.union([logLevel, _chunkCZIVE6NTcjs.Schema.literal(false)]).optional(),
+      responseLevel: _chunkCZIVE6NTcjs.Schema.union([logLevel, _chunkCZIVE6NTcjs.Schema.literal(false)]).optional(),
+      errorLevel: _chunkCZIVE6NTcjs.Schema.union([logLevel, _chunkCZIVE6NTcjs.Schema.literal(false)]).optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  spans: _chunkCZIVE6NTcjs.Schema.union([
+    _chunkCZIVE6NTcjs.Schema.literal(false),
+    _chunkCZIVE6NTcjs.Schema.object({
+      name: _chunkCZIVE6NTcjs.Schema.union([_chunkCZIVE6NTcjs.Schema.string({ minLength: 1 }), fn]).optional(),
+      attributes: _chunkCZIVE6NTcjs.Schema.union([object, fn]).optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  adaptiveLimiter: _chunkCZIVE6NTcjs.Schema.union([
+    _chunkCZIVE6NTcjs.Schema.boolean(),
+    _chunkCZIVE6NTcjs.Schema.object({
+      enabled: _chunkCZIVE6NTcjs.Schema.boolean().optional(),
+      includeKeyLabel: _chunkCZIVE6NTcjs.Schema.boolean().optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  policy: _chunkCZIVE6NTcjs.Schema.union([
+    _chunkCZIVE6NTcjs.Schema.boolean(),
+    _chunkCZIVE6NTcjs.Schema.object({
+      enabled: _chunkCZIVE6NTcjs.Schema.boolean().optional(),
+      labelKeys: _chunkCZIVE6NTcjs.Schema.array(_chunkCZIVE6NTcjs.Schema.enum(["preset", "lane", "poolKey", "dedupKey", "priority", "retry"])).optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  injectTraceHeaders: _chunkCZIVE6NTcjs.Schema.boolean().optional(),
+  includeHostLabel: _chunkCZIVE6NTcjs.Schema.boolean().optional(),
+  route: _chunkCZIVE6NTcjs.Schema.union([_chunkCZIVE6NTcjs.Schema.string({ minLength: 1 }), fn]).optional(),
+  clock: fn.optional(),
+  durationBuckets: _chunkCZIVE6NTcjs.Schema.array(_chunkCZIVE6NTcjs.Schema.number({ min: 0 }).refine((n) => n > 0, "duration bucket must be > 0")).optional()
+}, { unknownKeys: "passthrough" });
 function validateObservabilityOptions(options) {
-  _chunkSPUEME2Bcjs.parseConfig.call(void 0, "ObservabilityOptions", observabilityOptions, options);
+  _chunkCZIVE6NTcjs.parseConfig.call(void 0, "ObservabilityOptions", observabilityOptions, options);
+}
+function validateHttpObservabilityOptions(options) {
+  _chunkCZIVE6NTcjs.parseConfig.call(void 0, "HttpObservabilityOptions", httpObservabilityOptions, options);
 }
 
 // src/observability/setup.ts
+var DEFAULT_OTLP_SIGNALS = ["metrics", "traces", "logs"];
+function makeOtlpOptions(input) {
+  const endpoint = normalizeOtlpEndpoint(input.endpoint);
+  const signals = _nullishCoalesce(input.signals, () => ( DEFAULT_OTLP_SIGNALS));
+  return {
+    ...signals.includes("metrics") ? { metricsUrl: `${endpoint}/v1/metrics` } : {},
+    ...signals.includes("traces") ? { tracesUrl: `${endpoint}/v1/traces` } : {},
+    ...signals.includes("logs") ? { logsUrl: `${endpoint}/v1/logs` } : {},
+    ...input.headers ? { headers: input.headers } : {},
+    ...input.fetch ? { fetch: input.fetch } : {},
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
+    ...input.retry ? { retry: input.retry } : {},
+    ...input.pipeline ? { pipeline: input.pipeline } : {}
+  };
+}
+function normalizeOtlpEndpoint(endpoint) {
+  const trimmed = endpoint.trim();
+  let end = trimmed.length;
+  while (end > 0 && trimmed.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  const normalized = trimmed.slice(0, end);
+  if (!normalized) {
+    throw new Error("makeOtlpOptions endpoint must not be empty");
+  }
+  return normalized;
+}
 function makeObservability(options = {}) {
   validateObservabilityOptions(options);
   const serviceName = _nullishCoalesce(options.serviceName, () => ( "brass-runtime"));
-  const eventBus = _nullishCoalesce(options.eventBus, () => ( new (0, _chunkJX3LZQJHcjs.EventBus)()));
-  const rawMetrics = _chunkJX3LZQJHcjs.makeMetrics.call(void 0, );
+  const eventBus = _nullishCoalesce(options.eventBus, () => ( new (0, _chunk52PPNNI4cjs.EventBus)()));
+  const rawMetrics = _chunk52PPNNI4cjs.makeMetrics.call(void 0, );
   const metrics = options.cardinality === false ? rawMetrics : makeCardinalityLimitedMetrics(rawMetrics, _nullishCoalesce(options.cardinality, () => ( {})));
   const redactor = makeObservabilityRedactor(options.redaction);
   const traceOptions = options.traces && typeof options.traces === "object" ? options.traces : {};
-  const tracer = new (0, _chunkJX3LZQJHcjs.InMemoryTracer)({
+  const tracer = new (0, _chunk52PPNNI4cjs.InMemoryTracer)({
     maxFinishedSpans: _nullishCoalesce(traceOptions.maxFinishedSpans, () => ( 1e4)),
     maxSpanAgeMs: _nullishCoalesce(traceOptions.maxSpanAgeMs, () => ( 10 * 6e4)),
     clock: traceOptions.clock,
@@ -1556,7 +1624,7 @@ function makeObservability(options = {}) {
       childName: options.childName
     }
   });
-  const env = makeEnv(options.traceSeed, _optionalChain([options, 'access', _172 => _172.traceSeed, 'optionalAccess', _173 => _173.baggage]));
+  const env = makeEnv(options.traceSeed, _optionalChain([options, 'access', _173 => _173.traceSeed, 'optionalAccess', _174 => _174.baggage]));
   const envForRequest = (input) => makeEnv(_nullishCoalesce(resolveRequestTraceSeed(input), () => ( options.traceSeed)), resolveRequestBaggage(input));
   const resource = {
     "service.name": serviceName,
@@ -1567,12 +1635,12 @@ function makeObservability(options = {}) {
     const { prometheus: _prometheus, ...metricsOptions } = _nullishCoalesce(options.metrics, () => ( {}));
     eventBus.subscribeHooks(makeRuntimeMetricsSink(metrics, metricsOptions));
   }
-  const logPipeline = options.logs !== false && _optionalChain([options, 'access', _174 => _174.otlp, 'optionalAccess', _175 => _175.logsUrl]) ? makeExportPipeline({
+  const logPipeline = options.logs !== false && _optionalChain([options, 'access', _175 => _175.otlp, 'optionalAccess', _176 => _176.logsUrl]) ? makeExportPipeline({
     signal: "logs",
     metrics,
     ..._nullishCoalesce(options.otlp.pipeline, () => ( {})),
-    timeoutMs: _nullishCoalesce(options.otlp.timeoutMs, () => ( _optionalChain([options, 'access', _176 => _176.otlp, 'access', _177 => _177.pipeline, 'optionalAccess', _178 => _178.timeoutMs]))),
-    retry: _nullishCoalesce(options.otlp.retry, () => ( _optionalChain([options, 'access', _179 => _179.otlp, 'access', _180 => _180.pipeline, 'optionalAccess', _181 => _181.retry]))),
+    timeoutMs: _nullishCoalesce(options.otlp.timeoutMs, () => ( _optionalChain([options, 'access', _177 => _177.otlp, 'access', _178 => _178.pipeline, 'optionalAccess', _179 => _179.timeoutMs]))),
+    retry: _nullishCoalesce(options.otlp.retry, () => ( _optionalChain([options, 'access', _180 => _180.otlp, 'access', _181 => _181.pipeline, 'optionalAccess', _182 => _182.retry]))),
     exportBatch: async (records) => {
       const body = JSON.stringify(structuredLogsToOtlp(records, {
         resource,
@@ -1596,15 +1664,15 @@ function makeObservability(options = {}) {
       write: (record) => {
         if (configuredWrite) configuredWrite(record);
         else defaultStructuredLogWriter(record);
-        _optionalChain([logPipeline, 'optionalAccess', _182 => _182.enqueue, 'call', _183 => _183([record])]);
+        _optionalChain([logPipeline, 'optionalAccess', _183 => _183.enqueue, 'call', _184 => _184([record])]);
       }
     }));
   }
   if (options.traces !== false) {
     eventBus.subscribeHooks(tracer);
   }
-  const prometheus = makePrometheusMetricsExporter(metrics, options.metrics !== false ? _optionalChain([options, 'access', _184 => _184.metrics, 'optionalAccess', _185 => _185.prometheus]) : void 0);
-  const otlpMetrics = _optionalChain([options, 'access', _186 => _186.otlp, 'optionalAccess', _187 => _187.metricsUrl]) ? makeOtlpHttpMetricsExporter(metrics, {
+  const prometheus = makePrometheusMetricsExporter(metrics, options.metrics !== false ? _optionalChain([options, 'access', _185 => _185.metrics, 'optionalAccess', _186 => _186.prometheus]) : void 0);
+  const otlpMetrics = _optionalChain([options, 'access', _187 => _187.otlp, 'optionalAccess', _188 => _188.metricsUrl]) ? makeOtlpHttpMetricsExporter(metrics, {
     url: options.otlp.metricsUrl,
     headers: options.otlp.headers,
     fetch: options.otlp.fetch,
@@ -1615,11 +1683,11 @@ function makeObservability(options = {}) {
   const otlpMetricsExporter = otlpMetrics ? {
     export: async () => {
       const result = await exportWithRetry(
-        () => withTimeout(() => otlpMetrics.export(), _nullishCoalesce(_optionalChain([options, 'access', _188 => _188.otlp, 'optionalAccess', _189 => _189.timeoutMs]), () => ( 1e4))),
+        () => withTimeout(() => otlpMetrics.export(), _nullishCoalesce(_optionalChain([options, 'access', _189 => _189.otlp, 'optionalAccess', _190 => _190.timeoutMs]), () => ( 1e4))),
         {
           signal: "metrics",
           metrics,
-          retry: _optionalChain([options, 'access', _190 => _190.otlp, 'optionalAccess', _191 => _191.retry])
+          retry: _optionalChain([options, 'access', _191 => _191.otlp, 'optionalAccess', _192 => _192.retry])
         }
       );
       return result.value;
@@ -1628,12 +1696,12 @@ function makeObservability(options = {}) {
   const exportedSpanIds = /* @__PURE__ */ new Set();
   const queuedSpanIds = /* @__PURE__ */ new Set();
   const pendingSpans = () => tracer.exportFinished().filter((span) => !exportedSpanIds.has(span.spanId) && !queuedSpanIds.has(span.spanId));
-  const tracePipeline = _optionalChain([options, 'access', _192 => _192.otlp, 'optionalAccess', _193 => _193.tracesUrl]) ? makeExportPipeline({
+  const tracePipeline = _optionalChain([options, 'access', _193 => _193.otlp, 'optionalAccess', _194 => _194.tracesUrl]) ? makeExportPipeline({
     signal: "traces",
     metrics,
     ..._nullishCoalesce(options.otlp.pipeline, () => ( {})),
-    timeoutMs: _nullishCoalesce(options.otlp.timeoutMs, () => ( _optionalChain([options, 'access', _194 => _194.otlp, 'access', _195 => _195.pipeline, 'optionalAccess', _196 => _196.timeoutMs]))),
-    retry: _nullishCoalesce(options.otlp.retry, () => ( _optionalChain([options, 'access', _197 => _197.otlp, 'access', _198 => _198.pipeline, 'optionalAccess', _199 => _199.retry]))),
+    timeoutMs: _nullishCoalesce(options.otlp.timeoutMs, () => ( _optionalChain([options, 'access', _195 => _195.otlp, 'access', _196 => _196.pipeline, 'optionalAccess', _197 => _197.timeoutMs]))),
+    retry: _nullishCoalesce(options.otlp.retry, () => ( _optionalChain([options, 'access', _198 => _198.otlp, 'access', _199 => _199.pipeline, 'optionalAccess', _200 => _200.retry]))),
     exportBatch: async (spans) => {
       const body = JSON.stringify(spansToOtlp(spans, {
         resource,
@@ -1664,7 +1732,7 @@ function makeObservability(options = {}) {
       for (const spanId of spanIds) exportedSpanIds.delete(spanId);
     }
   }) : void 0;
-  const otlpTraces = _optionalChain([options, 'access', _200 => _200.otlp, 'optionalAccess', _201 => _201.tracesUrl]) ? {
+  const otlpTraces = _optionalChain([options, 'access', _201 => _201.otlp, 'optionalAccess', _202 => _202.tracesUrl]) ? {
     pipeline: tracePipeline,
     export: async () => {
       const spans = pendingSpans();
@@ -1709,7 +1777,7 @@ function makeObservability(options = {}) {
         metricsResult = await otlpMetricsExporter.export();
       } catch (error) {
         errors.push({ signal: "metrics", error });
-        _optionalChain([options, 'access', _202 => _202.onFlushError, 'optionalCall', _203 => _203(error, "metrics")]);
+        _optionalChain([options, 'access', _203 => _203.onFlushError, 'optionalCall', _204 => _204(error, "metrics")]);
       }
     }
     if (otlpTraces) {
@@ -1717,7 +1785,7 @@ function makeObservability(options = {}) {
         tracesResult = await otlpTraces.export();
       } catch (error) {
         errors.push({ signal: "traces", error });
-        _optionalChain([options, 'access', _204 => _204.onFlushError, 'optionalCall', _205 => _205(error, "traces")]);
+        _optionalChain([options, 'access', _205 => _205.onFlushError, 'optionalCall', _206 => _206(error, "traces")]);
       }
     }
     if (otlpLogs) {
@@ -1725,7 +1793,7 @@ function makeObservability(options = {}) {
         logsResult = await otlpLogs.export();
       } catch (error) {
         errors.push({ signal: "logs", error });
-        _optionalChain([options, 'access', _206 => _206.onFlushError, 'optionalCall', _207 => _207(error, "logs")]);
+        _optionalChain([options, 'access', _207 => _207.onFlushError, 'optionalCall', _208 => _208(error, "logs")]);
       }
     }
     return { metrics: metricsResult, traces: tracesResult, logs: logsResult, errors };
@@ -1746,7 +1814,7 @@ function makeObservability(options = {}) {
     interval = setInterval(() => {
       void flush();
     }, options.flushIntervalMs);
-    _optionalChain([interval, 'access', _208 => _208.unref, 'optionalCall', _209 => _209()]);
+    _optionalChain([interval, 'access', _209 => _209.unref, 'optionalCall', _210 => _210()]);
   };
   const stop = () => {
     if (!interval) return;
@@ -1760,10 +1828,10 @@ function makeObservability(options = {}) {
     let traces = result.traces;
     let logs = result.logs;
     if (tracePipeline && tracePipeline.stats().queueSize > 0) {
-      const drain = await tracePipeline.shutdown(_optionalChain([options, 'access', _210 => _210.otlp, 'optionalAccess', _211 => _211.pipeline, 'optionalAccess', _212 => _212.shutdownTimeoutMs]));
+      const drain = await tracePipeline.shutdown(_optionalChain([options, 'access', _211 => _211.otlp, 'optionalAccess', _212 => _212.pipeline, 'optionalAccess', _213 => _213.shutdownTimeoutMs]));
       for (const error of drain.errors) {
         drainErrors.push({ signal: "traces", error });
-        _optionalChain([options, 'access', _213 => _213.onFlushError, 'optionalCall', _214 => _214(error, "traces")]);
+        _optionalChain([options, 'access', _214 => _214.onFlushError, 'optionalCall', _215 => _215(error, "traces")]);
       }
       traces = _nullishCoalesce(traces, () => ( {
         status: drain.status,
@@ -1772,10 +1840,10 @@ function makeObservability(options = {}) {
       }));
     }
     if (logPipeline && logPipeline.stats().queueSize > 0) {
-      const drain = await logPipeline.shutdown(_optionalChain([options, 'access', _215 => _215.otlp, 'optionalAccess', _216 => _216.pipeline, 'optionalAccess', _217 => _217.shutdownTimeoutMs]));
+      const drain = await logPipeline.shutdown(_optionalChain([options, 'access', _216 => _216.otlp, 'optionalAccess', _217 => _217.pipeline, 'optionalAccess', _218 => _218.shutdownTimeoutMs]));
       for (const error of drain.errors) {
         drainErrors.push({ signal: "logs", error });
-        _optionalChain([options, 'access', _218 => _218.onFlushError, 'optionalCall', _219 => _219(error, "logs")]);
+        _optionalChain([options, 'access', _219 => _219.onFlushError, 'optionalCall', _220 => _220(error, "logs")]);
       }
       logs = _nullishCoalesce(logs, () => ( {
         status: drain.status,
@@ -1848,7 +1916,7 @@ function resolveRequestBaggage(input) {
   const maybeRequest = input;
   if (typeof maybeRequest.baggage === "string") return parseBaggage(maybeRequest.baggage);
   if (maybeRequest.baggage) return maybeRequest.baggage;
-  if (_optionalChain([maybeRequest, 'access', _220 => _220.trace, 'optionalAccess', _221 => _221.baggage])) return maybeRequest.trace.baggage;
+  if (_optionalChain([maybeRequest, 'access', _221 => _221.trace, 'optionalAccess', _222 => _222.baggage])) return maybeRequest.trace.baggage;
   if (maybeRequest.headers) return extractBaggage(maybeRequest.headers);
   return extractBaggage(input);
 }
@@ -1861,14 +1929,15 @@ function makeRuntimeTraceIdGenerator() {
     newSpanId: () => randomHexId(16)
   };
 }
+var HEX_BYTE = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, "0"));
 function randomHexId(length) {
   const cryptoLike = globalThis.crypto;
-  if (typeof _optionalChain([cryptoLike, 'optionalAccess', _222 => _222.getRandomValues]) === "function") {
+  if (typeof _optionalChain([cryptoLike, 'optionalAccess', _223 => _223.getRandomValues]) === "function") {
     const bytes = new Uint8Array(Math.ceil(length / 2));
     cryptoLike.getRandomValues(bytes);
-    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, length);
+    return bytesToHex(bytes, length);
   }
-  if (typeof _optionalChain([cryptoLike, 'optionalAccess', _223 => _223.randomUUID]) === "function") {
+  if (typeof _optionalChain([cryptoLike, 'optionalAccess', _224 => _224.randomUUID]) === "function") {
     const hex = cryptoLike.randomUUID().replace(/-/g, "");
     if (hex.length >= length) return hex.slice(0, length);
   }
@@ -1878,6 +1947,13 @@ function randomHexId(length) {
   }
   return out.slice(0, length);
 }
+function bytesToHex(bytes, length) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    out += HEX_BYTE[bytes[i]];
+  }
+  return out.length === length ? out : out.slice(0, length);
+}
 
 // src/observability/request.ts
 function makeRequestObservabilityContext(observability, input = {}) {
@@ -1885,7 +1961,7 @@ function makeRequestObservabilityContext(observability, input = {}) {
   const env = observability.envForRequest(input);
   const attributes = requestSpanAttributes(input);
   const defaultSpanName = _nullishCoalesce(input.spanName, () => ( (input.method && input.route ? `${input.method} ${input.route}` : _nullishCoalesce(input.route, () => ( "request")))));
-  const makeRuntime = (extraEnv, options = {}) => new (0, _chunkWQ5QNU5Rcjs.Runtime)({
+  const makeRuntime = (extraEnv, options = {}) => new (0, _chunkGLE2WY7Zcjs.Runtime)({
     ...options,
     env: mergeEnv(extraEnv, env),
     hooks: observability.hooks
@@ -1943,23 +2019,23 @@ async function runObservedHttpServerEffect(observability, input, effect, options
   );
 }
 function withServerSpanEvents(effect, options) {
-  return _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
     effect,
-    (error) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+    (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
       spanEvent("http.server.error", {
         "http.response.status_code": 500,
         "error.type": error instanceof Error ? error.name : typeof error
       }),
-      () => _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error)
+      () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)
     ),
     (value) => {
-      const statusCode = _nullishCoalesce(_optionalChain([options, 'access', _224 => _224.statusCode, 'optionalCall', _225 => _225(value)]), () => ( 200));
-      return _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+      const statusCode = _nullishCoalesce(_optionalChain([options, 'access', _225 => _225.statusCode, 'optionalCall', _226 => _226(value)]), () => ( 200));
+      return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
         spanEvent("http.server.response", {
           "http.response.status_code": statusCode,
           "http.outcome": statusCode >= 500 ? "error" : "success"
         }),
-        () => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, value)
+        () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value)
       );
     }
   );
@@ -1969,8 +2045,8 @@ async function observeHttpServerRequest(observability, input, handler, options =
   const ctx = makeRequestObservabilityContext(observability, input);
   const startedAt = resolved.clock();
   const baseLabels = requestBaseLabels(input, resolved);
-  const inFlight = _optionalChain([resolved, 'access', _226 => _226.metrics, 'optionalAccess', _227 => _227.gauge, 'call', _228 => _228("brass_http_server_in_flight", baseLabels)]);
-  _optionalChain([inFlight, 'optionalAccess', _229 => _229.increment, 'call', _230 => _230()]);
+  const inFlight = _optionalChain([resolved, 'access', _227 => _227.metrics, 'optionalAccess', _228 => _228.gauge, 'call', _229 => _229("brass_http_server_in_flight", baseLabels)]);
+  _optionalChain([inFlight, 'optionalAccess', _230 => _230.increment, 'call', _231 => _231()]);
   try {
     await ctx.run(logHttpServerRequest(input, resolved));
     const value = await handler(ctx);
@@ -2004,8 +2080,8 @@ function finishServerObservation(startedAt, input, trace, statusCode, outcome, o
     outcome: statusCode >= 500 ? "error" : outcome,
     status: String(statusCode)
   };
-  _optionalChain([options, 'access', _231 => _231.metrics, 'optionalAccess', _232 => _232.counter, 'call', _233 => _233("brass_http_server_requests_total", labels), 'access', _234 => _234.increment, 'call', _235 => _235()]);
-  _optionalChain([options, 'access', _236 => _236.metrics, 'optionalAccess', _237 => _237.histogram, 'call', _238 => _238("brass_http_server_duration_ms", [..._nullishCoalesce(options.durationBuckets, () => ( DEFAULT_DURATION_BUCKETS2))], labels), 'access', _239 => _239.observe, 'call', _240 => _240(
+  _optionalChain([options, 'access', _232 => _232.metrics, 'optionalAccess', _233 => _233.counter, 'call', _234 => _234("brass_http_server_requests_total", labels), 'access', _235 => _235.increment, 'call', _236 => _236()]);
+  _optionalChain([options, 'access', _237 => _237.metrics, 'optionalAccess', _238 => _238.histogram, 'call', _239 => _239("brass_http_server_duration_ms", [..._nullishCoalesce(options.durationBuckets, () => ( DEFAULT_DURATION_BUCKETS2))], labels), 'access', _240 => _240.observe, 'call', _241 => _241(
     durationMs,
     exemplarFromTraceContext(trace, durationMs, startedAt + durationMs)
   )]);
@@ -2039,7 +2115,7 @@ function logHttpServerError(input, error, durationMs, options) {
   });
 }
 function logNoop() {
-  return _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, void 0);
+  return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0);
 }
 function serverSpanName(input, options) {
   if (options.spans && options.spans.name) {
@@ -2048,7 +2124,7 @@ function serverSpanName(input, options) {
   return input.method && input.route ? `${input.method} ${input.route}` : _nullishCoalesce(input.route, () => ( "request"));
 }
 function serverSpanAttributes(input, options) {
-  const spanOptions = options.spans === false ? {} : _optionalChain([options, 'access', _241 => _241.spans, 'optionalAccess', _242 => _242.attributes]);
+  const spanOptions = options.spans === false ? {} : _optionalChain([options, 'access', _242 => _242.spans, 'optionalAccess', _243 => _243.attributes]);
   const custom = typeof spanOptions === "function" ? spanOptions(input) : _nullishCoalesce(spanOptions, () => ( {}));
   return {
     "span.kind": "server",
@@ -2140,4 +2216,6 @@ function compactLabels(labels) {
 
 
 
-exports.snapshotRuntimeHealth = snapshotRuntimeHealth; exports.makeRuntimeHealth = makeRuntimeHealth; exports.runtimeHealth = runtimeHealth; exports.readiness = readiness; exports.healthToHttpResponse = healthToHttpResponse; exports.makeObservabilityRedactor = makeObservabilityRedactor; exports.parseTraceparent = parseTraceparent; exports.formatTraceparent = formatTraceparent; exports.extractTraceContext = extractTraceContext; exports.injectTraceContext = injectTraceContext; exports.parseBaggage = parseBaggage; exports.formatBaggage = formatBaggage; exports.extractBaggage = extractBaggage; exports.injectBaggage = injectBaggage; exports.normalizeTraceId = normalizeTraceId; exports.normalizeSpanId = normalizeSpanId; exports.PROMETHEUS_CONTENT_TYPE = PROMETHEUS_CONTENT_TYPE; exports.OTLP_JSON_CONTENT_TYPE = OTLP_JSON_CONTENT_TYPE; exports.makePrometheusMetricsExporter = makePrometheusMetricsExporter; exports.formatPrometheusMetrics = formatPrometheusMetrics; exports.metricsSnapshotToOtlp = metricsSnapshotToOtlp; exports.makeOtlpHttpMetricsExporter = makeOtlpHttpMetricsExporter; exports.makeRuntimeMetricsSink = makeRuntimeMetricsSink; exports.exemplarFromTraceContext = exemplarFromTraceContext; exports.toOtlpAttributes = toOtlpAttributes; exports.otlpAnyValue = otlpAnyValue; exports.postOtlpJson = postOtlpJson; exports.unixNanoFromMs = unixNanoFromMs; exports.makeStructuredLogSink = makeStructuredLogSink; exports.formatStructuredLog = formatStructuredLog; exports.structuredLogsToOtlp = structuredLogsToOtlp; exports.makeOtlpHttpLogExporter = makeOtlpHttpLogExporter; exports.logEffect = logEffect; exports.withLogContext = withLogContext; exports.defaultStructuredLogWriter = defaultStructuredLogWriter; exports.alwaysOnSampler = alwaysOnSampler; exports.alwaysOffSampler = alwaysOffSampler; exports.ratioSampler = ratioSampler; exports.makeTraceSampler = makeTraceSampler; exports.resolveTraceSampling = resolveTraceSampling; exports.shouldSampleWith = shouldSampleWith; exports.withSpan = withSpan; exports.spanLink = spanLink; exports.currentSpanLink = currentSpanLink; exports.withBaggage = withBaggage; exports.currentBaggage = currentBaggage; exports.spanEvent = spanEvent; exports.spansToOtlp = spansToOtlp; exports.makeOtlpHttpSpanExporter = makeOtlpHttpSpanExporter; exports.makeExportPipeline = makeExportPipeline; exports.exportWithRetry = exportWithRetry; exports.withTimeout = withTimeout; exports.makeCardinalityLimitedMetrics = makeCardinalityLimitedMetrics; exports.normalizeHttpRoute = normalizeHttpRoute; exports.sanitizeHttpTarget = sanitizeHttpTarget; exports.makeObservability = makeObservability; exports.resolveRequestTraceSeed = resolveRequestTraceSeed; exports.resolveRequestBaggage = resolveRequestBaggage; exports.makeRequestObservabilityContext = makeRequestObservabilityContext; exports.runObservedHttpServerEffect = runObservedHttpServerEffect; exports.observeHttpServerRequest = observeHttpServerRequest;
+
+
+exports.snapshotRuntimeHealth = snapshotRuntimeHealth; exports.makeRuntimeHealth = makeRuntimeHealth; exports.runtimeHealth = runtimeHealth; exports.readiness = readiness; exports.healthToHttpResponse = healthToHttpResponse; exports.makeObservabilityRedactor = makeObservabilityRedactor; exports.parseTraceparent = parseTraceparent; exports.formatTraceparent = formatTraceparent; exports.extractTraceContext = extractTraceContext; exports.injectTraceContext = injectTraceContext; exports.parseBaggage = parseBaggage; exports.formatBaggage = formatBaggage; exports.extractBaggage = extractBaggage; exports.injectBaggage = injectBaggage; exports.normalizeTraceId = normalizeTraceId; exports.normalizeSpanId = normalizeSpanId; exports.PROMETHEUS_CONTENT_TYPE = PROMETHEUS_CONTENT_TYPE; exports.OTLP_JSON_CONTENT_TYPE = OTLP_JSON_CONTENT_TYPE; exports.makePrometheusMetricsExporter = makePrometheusMetricsExporter; exports.formatPrometheusMetrics = formatPrometheusMetrics; exports.metricsSnapshotToOtlp = metricsSnapshotToOtlp; exports.makeOtlpHttpMetricsExporter = makeOtlpHttpMetricsExporter; exports.makeRuntimeMetricsSink = makeRuntimeMetricsSink; exports.exemplarFromTraceContext = exemplarFromTraceContext; exports.toOtlpAttributes = toOtlpAttributes; exports.otlpAnyValue = otlpAnyValue; exports.postOtlpJson = postOtlpJson; exports.unixNanoFromMs = unixNanoFromMs; exports.makeStructuredLogSink = makeStructuredLogSink; exports.formatStructuredLog = formatStructuredLog; exports.structuredLogsToOtlp = structuredLogsToOtlp; exports.makeOtlpHttpLogExporter = makeOtlpHttpLogExporter; exports.logEffect = logEffect; exports.withLogContext = withLogContext; exports.defaultStructuredLogWriter = defaultStructuredLogWriter; exports.alwaysOnSampler = alwaysOnSampler; exports.alwaysOffSampler = alwaysOffSampler; exports.ratioSampler = ratioSampler; exports.makeTraceSampler = makeTraceSampler; exports.resolveTraceSampling = resolveTraceSampling; exports.shouldSampleWith = shouldSampleWith; exports.withSpan = withSpan; exports.spanLink = spanLink; exports.currentSpanLink = currentSpanLink; exports.withBaggage = withBaggage; exports.currentBaggage = currentBaggage; exports.spanEvent = spanEvent; exports.spansToOtlp = spansToOtlp; exports.makeOtlpHttpSpanExporter = makeOtlpHttpSpanExporter; exports.makeExportPipeline = makeExportPipeline; exports.exportWithRetry = exportWithRetry; exports.withTimeout = withTimeout; exports.makeCardinalityLimitedMetrics = makeCardinalityLimitedMetrics; exports.normalizeHttpRoute = normalizeHttpRoute; exports.sanitizeHttpTarget = sanitizeHttpTarget; exports.validateHttpObservabilityOptions = validateHttpObservabilityOptions; exports.makeOtlpOptions = makeOtlpOptions; exports.makeObservability = makeObservability; exports.resolveRequestTraceSeed = resolveRequestTraceSeed; exports.resolveRequestBaggage = resolveRequestBaggage; exports.makeRequestObservabilityContext = makeRequestObservabilityContext; exports.runObservedHttpServerEffect = runObservedHttpServerEffect; exports.observeHttpServerRequest = observeHttpServerRequest;