brass-runtime 1.15.0 → 1.16.1

package/dist/chunk-ENKODRU3.cjs

@@ -0,0 +1,2193 @@
+"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 _chunk52PPNNI4cjs = require('./chunk-52PPNNI4.cjs');
+
+
+
+
+
+
+var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
+
+
+
+
+
+
+var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
+
+
+
+var _chunkCZIVE6NTcjs = require('./chunk-CZIVE6NT.cjs');
+
+// src/observability/health.ts
+function snapshotRuntimeHealth(options = {}) {
+  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);
+  const fibers = options.registry ? fiberSummary(options.registry) : void 0;
+  const scopes = options.registry ? scopeSummary(options.registry) : void 0;
+  const metrics = options.metrics ? metricsSummary(options.metrics) : void 0;
+  const runtime = options.runtime ? runtimeSummary(options.runtime) : void 0;
+  const status = aggregateStatus([
+    ...Object.values(checks).map((check) => check.status),
+    ...Object.values(circuitBreakers).map((breaker) => breaker.status),
+    ...Object.values(adaptiveLimiters).map((limiter) => limiter.status),
+    ...runtimeSchedulerDropped(runtime) > 0 ? ["degraded"] : []
+  ]);
+  return {
+    status,
+    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 } : {},
+    ...runtime ? { runtime } : {},
+    ...metrics ? { metrics } : {},
+    circuitBreakers,
+    adaptiveLimiters,
+    checks
+  };
+}
+function makeRuntimeHealth(options = {}) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => snapshotRuntimeHealth(options));
+}
+var runtimeHealth = makeRuntimeHealth;
+function readiness(options = {}) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => snapshotRuntimeHealth(options).ready);
+}
+function healthToHttpResponse(report) {
+  return {
+    status: report.ready ? 200 : 503,
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(report)
+  };
+}
+function runChecks(checks) {
+  const out = {};
+  for (const [name, check] of Object.entries(_nullishCoalesce(checks, () => ( {})))) {
+    try {
+      out[name] = normalizeHealthCheckResult(check());
+    } catch (error) {
+      out[name] = {
+        status: "down",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  return out;
+}
+function collectCircuitBreakers(breakers) {
+  const out = {};
+  for (const [name, breaker] of Object.entries(_nullishCoalesce(breakers, () => ( {})))) {
+    const stats = breaker.stats();
+    out[name] = {
+      ...stats,
+      status: stats.state === "open" ? "down" : stats.state === "half-open" ? "degraded" : "ok"
+    };
+  }
+  return out;
+}
+function collectAdaptiveLimiters(limiters) {
+  const out = {};
+  for (const [name, limiter] of Object.entries(_nullishCoalesce(limiters, () => ( {})))) {
+    const stats = limiter.stats();
+    out[name] = {
+      ...stats,
+      status: adaptiveLimiterStatus(stats)
+    };
+  }
+  return out;
+}
+function adaptiveLimiterStatus(stats) {
+  const rejectionRate = _nullishCoalesce(stats.rejectionRate, () => ( 0));
+  const errorRate = _nullishCoalesce(stats.errorRate, () => ( 0));
+  if (rejectionRate >= 0.5) return "down";
+  if (rejectionRate > 0 || stats.queueDepth > stats.limit || errorRate >= 0.25) return "degraded";
+  return "ok";
+}
+function fiberSummary(registry) {
+  const fibers = Array.from(registry.fibers.values());
+  return {
+    active: fibers.filter((fiber) => fiber.status === "Running").length,
+    suspended: fibers.filter((fiber) => fiber.runState === "Suspended").length,
+    done: fibers.filter((fiber) => fiber.runState === "Done").length
+  };
+}
+function scopeSummary(registry) {
+  const scopes = Array.from(registry.scopes.values());
+  return {
+    open: scopes.filter((scope) => scope.closedAt === void 0).length,
+    closed: scopes.filter((scope) => scope.closedAt !== void 0).length
+  };
+}
+function metricsSummary(metrics) {
+  const snapshot = metrics.snapshot();
+  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,
+    histograms: snapshot.histograms.length,
+    activeFibers: gaugeValue("brass_runtime_fibers_active"),
+    activeScopes: gaugeValue("brass_runtime_scopes_active"),
+    activeSpans: gaugeValue("brass_runtime_spans_active")
+  };
+}
+function runtimeSummary(runtime) {
+  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', _15 => _15.engine]),
+    fiberStats: _optionalChain([stats, 'optionalAccess', _16 => _16.data]),
+    scheduler
+  };
+}
+function runtimeSchedulerDropped(runtime) {
+  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";
+  if (statuses.includes("degraded")) return "degraded";
+  return "ok";
+}
+function normalizeHealthCheckResult(result) {
+  return {
+    status: result.status,
+    ...result.message ? { message: result.message } : {},
+    ...result.details ? { details: result.details } : {}
+  };
+}
+
+// src/observability/redaction.ts
+var DEFAULT_REPLACEMENT = "[REDACTED]";
+var DEFAULT_MAX_DEPTH = 6;
+var DEFAULT_MAX_STRING_LENGTH = 8192;
+var DEFAULT_KEY_PATTERNS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "access_token",
+  "refresh_token",
+  "api_key",
+  "apikey",
+  "private_key",
+  /credential/i
+];
+var DEFAULT_HEADER_PATTERNS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "proxy-authorization"
+];
+function makeObservabilityRedactor(config) {
+  if (isRedactor(config)) return config;
+  const options = config === false ? { keys: [], headers: [], redactUrlQuery: false } : _nullishCoalesce(config, () => ( {}));
+  const replacement = _nullishCoalesce(options.replacement, () => ( DEFAULT_REPLACEMENT));
+  const keys = _nullishCoalesce(options.keys, () => ( DEFAULT_KEY_PATTERNS));
+  const headers = _nullishCoalesce(options.headers, () => ( DEFAULT_HEADER_PATTERNS));
+  const maxDepth = Math.max(1, Math.floor(_nullishCoalesce(options.maxDepth, () => ( DEFAULT_MAX_DEPTH))));
+  const maxStringLength = Math.max(0, Math.floor(_nullishCoalesce(options.maxStringLength, () => ( DEFAULT_MAX_STRING_LENGTH))));
+  const redactUrlQuery = _nullishCoalesce(options.redactUrlQuery, () => ( true));
+  const redactByKey = (key, value, depth) => {
+    if (matchesAny(key, keys)) return replacement;
+    return redactValue(value, depth);
+  };
+  const redactValue = (value, depth) => {
+    if (value == null || typeof value === "number" || typeof value === "boolean") return value;
+    if (typeof value === "string") return maxStringLength > 0 && value.length > maxStringLength ? `${value.slice(0, maxStringLength)}...` : value;
+    if (depth >= maxDepth) return "[MaxDepth]";
+    if (Array.isArray(value)) return value.map((item) => redactValue(item, depth + 1));
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: value.message
+      };
+    }
+    if (typeof value === "object") {
+      const out = {};
+      for (const [key, item] of Object.entries(value)) {
+        out[key] = redactByKey(key, item, depth + 1);
+      }
+      return out;
+    }
+    return String(value);
+  };
+  return {
+    value: (value) => redactValue(value, 0),
+    fields: (fields) => redactRecord(fields, redactByKey),
+    attributes: (fields) => redactRecord(fields, redactByKey),
+    headers: (input) => {
+      const out = {};
+      for (const [key, value] of Object.entries(input)) {
+        out[key] = matchesAny(key, headers) ? replacement : value;
+      }
+      return out;
+    },
+    url: (url) => redactUrl(url, redactUrlQuery)
+  };
+}
+function redactRecord(fields, redactByKey) {
+  const out = {};
+  for (const [key, value] of Object.entries(fields)) {
+    out[key] = redactByKey(key, value, 0);
+  }
+  return out;
+}
+function redactUrl(url, redactQuery) {
+  if (!redactQuery) return url;
+  try {
+    const parsed = new URL(url);
+    if (parsed.search) parsed.search = "?[REDACTED]";
+    return parsed.toString();
+  } catch (e) {
+    const queryIndex = url.indexOf("?");
+    if (queryIndex < 0) return url;
+    return `${url.slice(0, queryIndex)}?[REDACTED]`;
+  }
+}
+function matchesAny(key, patterns) {
+  const lower = key.toLowerCase();
+  return patterns.some(
+    (pattern) => typeof pattern === "string" ? lower === pattern.toLowerCase() : pattern.test(key)
+  );
+}
+function isRedactor(value) {
+  return typeof value === "object" && value !== null && typeof value.fields === "function" && typeof value.attributes === "function";
+}
+
+// src/observability/traceContext.ts
+var TRACEPARENT_HEADER = "traceparent";
+var TRACESTATE_HEADER = "tracestate";
+var BAGGAGE_HEADER = "baggage";
+var HEX = /^[0-9a-f]+$/;
+var BAGGAGE_KEY = /^[!#$%&'*+\-.^_`|~0-9a-zA-Z]+$/;
+function parseTraceparent(value) {
+  if (!value) return void 0;
+  const parts = value.trim().split("-");
+  if (parts.length < 4) return void 0;
+  const [version, traceIdRaw, spanIdRaw, flagsRaw] = parts;
+  if (!isFixedHex(version, 2) || version.toLowerCase() === "ff") return void 0;
+  if (version.toLowerCase() === "00" && parts.length !== 4) return void 0;
+  if (!isFixedHex(traceIdRaw, 32) || isAllZero(traceIdRaw)) return void 0;
+  if (!isFixedHex(spanIdRaw, 16) || isAllZero(spanIdRaw)) return void 0;
+  if (!isFixedHex(flagsRaw, 2)) return void 0;
+  const flags = Number.parseInt(flagsRaw, 16);
+  return {
+    traceId: traceIdRaw.toLowerCase(),
+    spanId: spanIdRaw.toLowerCase(),
+    sampled: (flags & 1) === 1
+  };
+}
+function formatTraceparent(trace) {
+  return `00-${normalizeTraceId(trace.traceId)}-${normalizeSpanId(trace.spanId)}-${trace.sampled === false ? "00" : "01"}`;
+}
+function extractTraceContext(headers) {
+  const parsed = parseTraceparent(readHeader(headers, TRACEPARENT_HEADER));
+  if (!parsed) return void 0;
+  const traceState = readHeader(headers, TRACESTATE_HEADER);
+  const baggage = extractBaggage(headers);
+  return {
+    ...parsed,
+    ...traceState ? { traceState } : {},
+    ...baggage ? { baggage } : {}
+  };
+}
+function injectTraceContext(headers, trace, options = {}) {
+  const out = { ..._nullishCoalesce(headers, () => ( {})) };
+  const hasTraceparent = hasHeader(out, TRACEPARENT_HEADER);
+  const shouldInjectTraceContext = options.overwrite || !hasTraceparent;
+  if (!shouldInjectTraceContext) return out;
+  if (shouldInjectTraceContext) {
+    setHeader(out, TRACEPARENT_HEADER, formatTraceparent(trace));
+  }
+  if (trace.traceState && (options.overwrite || !hasHeader(out, TRACESTATE_HEADER))) {
+    setHeader(out, TRACESTATE_HEADER, trace.traceState);
+  }
+  if (trace.baggage && Object.keys(trace.baggage).length > 0 && (options.overwrite || !hasHeader(out, BAGGAGE_HEADER))) {
+    setHeader(out, BAGGAGE_HEADER, formatBaggage(trace.baggage));
+  }
+  return out;
+}
+function parseBaggage(value) {
+  if (!value) return void 0;
+  const entries = {};
+  for (const rawMember of value.split(",")) {
+    const member = rawMember.trim();
+    if (!member) continue;
+    const [pair] = member.split(";", 1);
+    const eq = pair.indexOf("=");
+    if (eq <= 0) continue;
+    const key = pair.slice(0, eq).trim();
+    const rawValue = pair.slice(eq + 1).trim();
+    if (!BAGGAGE_KEY.test(key)) continue;
+    entries[key] = decodeBaggageValue(rawValue);
+  }
+  return Object.keys(entries).length > 0 ? entries : void 0;
+}
+function formatBaggage(baggage) {
+  if (!baggage) return "";
+  return Object.entries(baggage).filter(([key, value]) => BAGGAGE_KEY.test(key) && value !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}=${encodeBaggageValue(value)}`).join(",");
+}
+function extractBaggage(headers) {
+  return parseBaggage(readHeader(headers, BAGGAGE_HEADER));
+}
+function injectBaggage(headers, baggage, options = {}) {
+  const out = { ..._nullishCoalesce(headers, () => ( {})) };
+  if (!baggage || Object.keys(baggage).length === 0) return out;
+  if (!options.overwrite && hasHeader(out, BAGGAGE_HEADER)) return out;
+  setHeader(out, BAGGAGE_HEADER, formatBaggage(baggage));
+  return out;
+}
+function normalizeTraceId(id) {
+  return normalizeHexId(id, 32);
+}
+function normalizeSpanId(id) {
+  return normalizeHexId(id, 16);
+}
+function readHeader(headers, name) {
+  if (!headers) return void 0;
+  const getter = headers.get;
+  if (typeof getter === "function") {
+    return _nullishCoalesce(getter.call(headers, name), () => ( void 0));
+  }
+  if (isIterableHeaders(headers)) {
+    for (const [key, value] of headers) {
+      if (key.toLowerCase() === name) return value;
+    }
+    return void 0;
+  }
+  const record = headers;
+  for (const [key, value] of Object.entries(record)) {
+    if (key.toLowerCase() !== name) continue;
+    if (typeof value === "string") return value;
+    if (Array.isArray(value)) return value[0];
+    return void 0;
+  }
+  return void 0;
+}
+function isIterableHeaders(value) {
+  return typeof _optionalChain([value, 'optionalAccess', _20 => _20[Symbol.iterator]]) === "function";
+}
+function hasHeader(headers, name) {
+  const lower = name.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === lower);
+}
+function setHeader(headers, name, value) {
+  const lower = name.toLowerCase();
+  const existing = Object.keys(headers).find((key) => key.toLowerCase() === lower);
+  headers[_nullishCoalesce(existing, () => ( name))] = value;
+}
+function isFixedHex(value, length) {
+  return typeof value === "string" && value.length === length && HEX.test(value.toLowerCase());
+}
+function isAllZero(value) {
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] !== "0") return false;
+  }
+  return true;
+}
+function normalizeHexId(id, length) {
+  const hex = String(id).toLowerCase().replace(/[^0-9a-f]/g, "");
+  if (hex.length >= length) return avoidAllZero(hex.slice(0, length));
+  if (hex.length > 0) return avoidAllZero(hex.padStart(length, "0"));
+  return stableHex(String(id), length);
+}
+function decodeBaggageValue(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch (e2) {
+    return value;
+  }
+}
+function encodeBaggageValue(value) {
+  return encodeURIComponent(String(value));
+}
+function avoidAllZero(hex) {
+  return isAllZero(hex) ? `${hex.slice(0, -1)}1` : hex;
+}
+function stableHex(input, length) {
+  let hash = 2166136261;
+  let out = "";
+  while (out.length < length) {
+    for (let i = 0; i < input.length; i++) {
+      hash ^= input.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    out += (hash >>> 0).toString(16).padStart(8, "0");
+    input = `${input}:${out.length}`;
+  }
+  return avoidAllZero(out.slice(0, length));
+}
+
+// src/observability/metrics.ts
+var PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
+var OTLP_JSON_CONTENT_TYPE = "application/json";
+var DEFAULT_DURATION_BUCKETS = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4];
+function makePrometheusMetricsExporter(registry, options = {}) {
+  return {
+    contentType: PROMETHEUS_CONTENT_TYPE,
+    export: () => formatPrometheusMetrics(registry.snapshot(), options)
+  };
+}
+function formatPrometheusMetrics(snapshot, options = {}) {
+  const lines = [];
+  const emittedHeaders = /* @__PURE__ */ new Set();
+  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', _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) => {
+    const exemplarSuffix = options.includeExemplars && exemplar ? formatExemplar(exemplar) : "";
+    const suffix = exemplarSuffix || !options.includeTimestamp ? exemplarSuffix : ` ${now}`;
+    lines.push(`${metricName(name)}${formatLabels(labels)} ${formatNumber(value)}${suffix}`);
+  };
+  for (const counter of snapshot.counters) {
+    emitHeader(counter.name, "counter");
+    emitSample(counter.name, counter.labels, counter.value);
+  }
+  for (const gauge of snapshot.gauges) {
+    emitHeader(gauge.name, "gauge");
+    emitSample(gauge.name, gauge.labels, gauge.value);
+  }
+  for (const histogram of snapshot.histograms) {
+    emitHeader(histogram.name, "histogram");
+    const buckets = histogram.buckets;
+    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', _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', _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);
+  }
+  return lines.length === 0 ? "" : `${lines.join("\n")}
+`;
+}
+function metricsSnapshotToOtlp(snapshot, options = {}) {
+  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 = [];
+  for (const counter of snapshot.counters) {
+    metrics.push({
+      name: counter.name,
+      sum: {
+        aggregationTemporality: 2,
+        isMonotonic: true,
+        dataPoints: [numberDataPoint(counter.labels, counter.value, timeUnixNano)]
+      }
+    });
+  }
+  for (const gauge of snapshot.gauges) {
+    metrics.push({
+      name: gauge.name,
+      gauge: {
+        dataPoints: [numberDataPoint(gauge.labels, gauge.value, timeUnixNano)]
+      }
+    });
+  }
+  for (const histogram of snapshot.histograms) {
+    const buckets = histogram.buckets;
+    metrics.push({
+      name: histogram.name,
+      histogram: {
+        aggregationTemporality: 2,
+        dataPoints: [{
+          attributes: toOtlpAttributes(histogram.labels),
+          timeUnixNano,
+          count: String(buckets.count),
+          sum: finiteOrZero(buckets.sum),
+          min: finiteOrZero(buckets.min),
+          max: finiteOrZero(buckets.max),
+          explicitBounds: buckets.boundaries,
+          bucketCounts: buckets.counts.map((count) => String(count)),
+          ...buckets.exemplars ? { exemplars: buckets.exemplars.filter(isMetricExemplar).map(exemplarToOtlp) } : {}
+        }]
+      }
+    });
+  }
+  return {
+    resourceMetrics: [{
+      resource: { attributes: toOtlpAttributes(_nullishCoalesce(options.resource, () => ( {}))) },
+      scopeMetrics: [{ scope, metrics }]
+    }]
+  };
+}
+function makeOtlpHttpMetricsExporter(registry, options) {
+  return {
+    export: async () => {
+      const body = JSON.stringify(metricsSnapshotToOtlp(registry.snapshot(), options));
+      const response = await postOtlpJson(options, body);
+      return { status: response.status, body };
+    }
+  };
+}
+function makeRuntimeMetricsSink(metrics, options = {}) {
+  const clock = _nullishCoalesce(options.clock, () => ( Date.now));
+  const durationBuckets = [..._nullishCoalesce(options.durationBuckets, () => ( DEFAULT_DURATION_BUCKETS))];
+  const includeEventTotals = _nullishCoalesce(options.includeEventTotals, () => ( true));
+  const includeSpanNameLabel = _nullishCoalesce(options.includeSpanNameLabel, () => ( false));
+  const fiberStarts = /* @__PURE__ */ new Map();
+  const scopeStarts = /* @__PURE__ */ new Map();
+  const spanStarts = /* @__PURE__ */ new Map();
+  const activeFibers = metrics.gauge("brass_runtime_fibers_active");
+  const activeScopes = metrics.gauge("brass_runtime_scopes_active");
+  const activeSpans = metrics.gauge("brass_runtime_spans_active");
+  return {
+    emit(ev, ctx) {
+      try {
+        if (includeEventTotals) metrics.counter("brass_runtime_events_total", { type: ev.type }).increment();
+        recordRuntimeMetricEvent(ev, ctx, clock(), durationBuckets, {
+          metrics,
+          fiberStarts,
+          scopeStarts,
+          spanStarts,
+          activeFibers,
+          activeScopes,
+          activeSpans,
+          includeSpanNameLabel
+        });
+      } catch (e3) {
+      }
+    }
+  };
+}
+function recordRuntimeMetricEvent(ev, ctx, now, durationBuckets, state) {
+  switch (ev.type) {
+    case "fiber.start":
+      state.fiberStarts.set(ev.fiberId, now);
+      state.metrics.counter("brass_runtime_fibers_started_total").increment();
+      state.activeFibers.increment();
+      return;
+    case "fiber.end": {
+      state.metrics.counter("brass_runtime_fibers_finished_total", { status: ev.status }).increment();
+      decrementIfPositive(state.activeFibers);
+      const started = state.fiberStarts.get(ev.fiberId);
+      state.fiberStarts.delete(ev.fiberId);
+      if (started !== void 0) {
+        const durationMs = now - started;
+        state.metrics.histogram("brass_runtime_fiber_duration_ms", [...durationBuckets], { status: ev.status }).observe(durationMs, exemplarFromTraceContext(ctx, durationMs, now));
+      }
+      return;
+    }
+    case "scope.open":
+      state.scopeStarts.set(ev.scopeId, now);
+      state.metrics.counter("brass_runtime_scopes_opened_total").increment();
+      state.activeScopes.increment();
+      return;
+    case "scope.close": {
+      state.metrics.counter("brass_runtime_scopes_closed_total", { status: ev.status }).increment();
+      decrementIfPositive(state.activeScopes);
+      const started = state.scopeStarts.get(ev.scopeId);
+      state.scopeStarts.delete(ev.scopeId);
+      if (started !== void 0) {
+        const durationMs = now - started;
+        state.metrics.histogram("brass_runtime_scope_duration_ms", [...durationBuckets], { status: ev.status }).observe(durationMs, exemplarFromTraceContext(ctx, durationMs, now));
+      }
+      return;
+    }
+    case "span.start":
+      if (ctx.spanId) state.spanStarts.set(ctx.spanId, now);
+      state.metrics.counter("brass_runtime_spans_started_total", state.includeSpanNameLabel ? { name: ev.name } : {}).increment();
+      state.activeSpans.increment();
+      return;
+    case "span.end": {
+      const status = ev.status;
+      state.metrics.counter("brass_runtime_spans_finished_total", { status }).increment();
+      decrementIfPositive(state.activeSpans);
+      if (ctx.spanId) {
+        const started = state.spanStarts.get(ctx.spanId);
+        state.spanStarts.delete(ctx.spanId);
+        if (started !== void 0) {
+          const durationMs = now - started;
+          state.metrics.histogram("brass_runtime_span_duration_ms", [...durationBuckets], { status }).observe(durationMs, exemplarFromTraceContext(ctx, durationMs, now));
+        }
+      }
+      return;
+    }
+    case "log":
+      state.metrics.counter("brass_runtime_logs_total", { level: ev.level }).increment();
+      return;
+  }
+}
+function exemplarFromTraceContext(trace, value, timestamp = Date.now(), labels) {
+  if (!_optionalChain([trace, 'optionalAccess', _31 => _31.traceId]) || !_optionalChain([trace, 'optionalAccess', _32 => _32.spanId])) return void 0;
+  return {
+    value,
+    timestamp,
+    traceId: normalizeTraceId(trace.traceId),
+    spanId: normalizeSpanId(trace.spanId),
+    ...labels ? { labels } : {}
+  };
+}
+function decrementIfPositive(gauge) {
+  if (gauge.value() > 0) gauge.decrement();
+}
+function numberDataPoint(labels, value, timeUnixNano) {
+  return {
+    attributes: toOtlpAttributes(labels),
+    timeUnixNano,
+    asDouble: finiteOrZero(value)
+  };
+}
+function exemplarToOtlp(exemplar) {
+  return {
+    timeUnixNano: unixNanoFromMs(exemplar.timestamp),
+    asDouble: finiteOrZero(exemplar.value),
+    ...exemplar.traceId ? { traceId: normalizeTraceId(exemplar.traceId) } : {},
+    ...exemplar.spanId ? { spanId: normalizeSpanId(exemplar.spanId) } : {},
+    filteredAttributes: toOtlpAttributes(_nullishCoalesce(exemplar.labels, () => ( {})))
+  };
+}
+function isMetricExemplar(value) {
+  return value !== void 0;
+}
+function toOtlpAttributes(labels) {
+  return Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => ({
+    key,
+    value: otlpAnyValue(value)
+  }));
+}
+function otlpAnyValue(value) {
+  if (typeof value === "boolean") return { boolValue: value };
+  if (typeof value === "number") return { doubleValue: finiteOrZero(value) };
+  return { stringValue: value };
+}
+async function postOtlpJson(options, body) {
+  const fetchImpl = _nullishCoalesce(options.fetch, () => ( globalThis.fetch));
+  if (typeof fetchImpl !== "function") {
+    throw new Error("No fetch implementation available for OTLP export");
+  }
+  const response = await fetchImpl(options.url, {
+    method: "POST",
+    headers: {
+      "content-type": OTLP_JSON_CONTENT_TYPE,
+      ..._nullishCoalesce(options.headers, () => ( {}))
+    },
+    body
+  });
+  if (_optionalChain([response, 'optionalAccess', _33 => _33.ok]) === false) {
+    let detail = "";
+    try {
+      detail = response.text ? `: ${await response.text()}` : "";
+    } catch (e4) {
+      detail = "";
+    }
+    throw new Error(`OTLP export failed with status ${_nullishCoalesce(response.status, () => ( "unknown"))}${detail}`);
+  }
+  return _nullishCoalesce(response, () => ( {}));
+}
+function unixNanoFromMs(ms) {
+  const wholeMs = Math.max(0, Math.trunc(ms));
+  return (BigInt(wholeMs) * 1000000n).toString();
+}
+function formatLabels(labels) {
+  const entries = Object.entries(labels).sort(([a], [b]) => a.localeCompare(b));
+  if (entries.length === 0) return "";
+  return `{${entries.map(([key, value]) => `${sanitizeLabelName(key)}="${escapeLabelValue(value)}"`).join(",")}}`;
+}
+function formatExemplar(exemplar) {
+  const labels = {
+    ..._nullishCoalesce(exemplar.labels, () => ( {})),
+    ...exemplar.traceId ? { trace_id: normalizeTraceId(exemplar.traceId) } : {},
+    ...exemplar.spanId ? { span_id: normalizeSpanId(exemplar.spanId) } : {}
+  };
+  if (Object.keys(labels).length === 0) return "";
+  return ` # ${formatLabels(labels)} ${formatNumber(exemplar.value)} ${formatNumber(exemplar.timestamp / 1e3)}`;
+}
+function sanitizeMetricName(name) {
+  const safe = name.replace(/[^a-zA-Z0-9_:]/g, "_");
+  return /^[a-zA-Z_:]/.test(safe) ? safe : `_${safe}`;
+}
+function sanitizeLabelName(name) {
+  const safe = name.replace(/[^a-zA-Z0-9_]/g, "_");
+  return /^[a-zA-Z_]/.test(safe) ? safe : `_${safe}`;
+}
+function escapeLabelValue(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, '\\"');
+}
+function escapeHelp(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/\n/g, "\\n");
+}
+function formatNumber(value) {
+  return Number.isFinite(value) ? String(value) : "0";
+}
+function finiteOrZero(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+
+// src/observability/logs.ts
+var LEVEL_WEIGHT = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function makeStructuredLogSink(options = {}) {
+  const minLevel = _nullishCoalesce(options.minLevel, () => ( "debug"));
+  const clock = _nullishCoalesce(options.clock, () => ( Date.now));
+  const write = _nullishCoalesce(options.write, () => ( defaultStructuredLogWriter));
+  const redactor = makeObservabilityRedactor(options.redact);
+  return {
+    emit(ev, ctx) {
+      if (ev.type !== "log") return;
+      if (LEVEL_WEIGHT[ev.level] < LEVEL_WEIGHT[minLevel]) return;
+      const wallTs = clock();
+      try {
+        write({
+          ts: new Date(wallTs).toISOString(),
+          wallTs,
+          level: ev.level,
+          message: ev.message,
+          fields: redactor.fields(_nullishCoalesce(ev.fields, () => ( {}))),
+          fiberId: ctx.fiberId,
+          scopeId: ctx.scopeId,
+          traceId: ctx.traceId,
+          spanId: ctx.spanId,
+          parentSpanId: ctx.parentSpanId,
+          traceState: ctx.traceState
+        });
+      } catch (e5) {
+      }
+    }
+  };
+}
+function formatStructuredLog(record) {
+  return JSON.stringify(record);
+}
+function structuredLogsToOtlp(records, options = {}) {
+  const scope = { name: _nullishCoalesce(options.scopeName, () => ( "brass-runtime")) };
+  if (options.scopeVersion) scope.version = options.scopeVersion;
+  return {
+    resourceLogs: [{
+      resource: { attributes: toOtlpAttributes(_nullishCoalesce(options.resource, () => ( {}))) },
+      scopeLogs: [{
+        scope,
+        logRecords: records.map(logRecordToOtlp)
+      }]
+    }]
+  };
+}
+function makeOtlpHttpLogExporter(source, options) {
+  return {
+    export: async () => {
+      const records = typeof source === "function" ? source() : source.exportRecords();
+      const body = JSON.stringify(structuredLogsToOtlp(records, options));
+      const response = await postOtlpJson(options, body);
+      return { status: response.status, body, logCount: records.length };
+    }
+  };
+}
+function logEffect(level, message, fields = {}) {
+  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', _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 _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+    startLogContext(patch),
+    (state) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+      effect,
+      (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 _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: _chunkGLE2WY7Zcjs.ctxExtend.call(void 0, previous, patch) };
+    _optionalChain([fiber, 'access', _38 => _38.addFinalizer, 'optionalCall', _39 => _39(() => restoreLogContext(state))]);
+    return state;
+  });
+}
+function endLogContext(state) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => restoreLogContext(state));
+}
+function restoreLogContext(state) {
+  if (!state || state.ended) return;
+  state.ended = true;
+  if (_optionalChain([state, 'access', _40 => _40.fiber, 'optionalAccess', _41 => _41.fiberContext])) {
+    state.fiber.fiberContext = { ...state.fiber.fiberContext, log: state.previous };
+  }
+}
+function defaultStructuredLogWriter(record) {
+  const line = formatStructuredLog(record);
+  if (record.level === "error") console.error(line);
+  else console.log(line);
+}
+function logRecordToOtlp(record) {
+  return {
+    timeUnixNano: unixNanoFromMs(record.wallTs),
+    severityText: record.level.toUpperCase(),
+    severityNumber: severityNumber(record.level),
+    body: { stringValue: record.message },
+    ...record.traceId ? { traceId: record.traceId } : {},
+    ...record.spanId ? { spanId: record.spanId } : {},
+    attributes: toOtlpAttributes(normalizeLogAttributes({
+      ...record.fields,
+      ...record.fiberId !== void 0 ? { "brass.fiber_id": record.fiberId } : {},
+      ...record.scopeId !== void 0 ? { "brass.scope_id": record.scopeId } : {},
+      ...record.parentSpanId ? { "brass.parent_span_id": record.parentSpanId } : {},
+      ...record.traceState ? { "w3c.tracestate": record.traceState } : {}
+    }))
+  };
+}
+function severityNumber(level) {
+  switch (level) {
+    case "debug":
+      return 5;
+    case "info":
+      return 9;
+    case "warn":
+      return 13;
+    case "error":
+      return 17;
+  }
+}
+function normalizeLogAttributes(fields) {
+  const out = {};
+  for (const [key, value] of Object.entries(fields)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      out[key] = value;
+    } else if (value != null) {
+      out[key] = JSON.stringify(value);
+    }
+  }
+  return out;
+}
+
+// src/observability/sampling.ts
+var alwaysOnSampler = {
+  shouldSample: () => true
+};
+var alwaysOffSampler = {
+  shouldSample: () => false
+};
+function ratioSampler(ratio2) {
+  const bounded = clampRatio(ratio2);
+  if (bounded >= 1) return alwaysOnSampler;
+  if (bounded <= 0) return alwaysOffSampler;
+  return {
+    shouldSample: (input) => traceRatio(input.traceId) < bounded
+  };
+}
+function makeTraceSampler(options = {}) {
+  const fallback = _nullishCoalesce(options.sampler, () => ( ratioSampler(_nullishCoalesce(options.ratio, () => ( 1)))));
+  const rules = _nullishCoalesce(options.rules, () => ( []));
+  return {
+    shouldSample(input) {
+      for (const rule of rules) {
+        if (!samplingRuleMatches(rule, input)) continue;
+        if (rule.sampled !== void 0) return rule.sampled;
+        if (rule.ratio !== void 0) return shouldSampleWith(ratioSampler(rule.ratio), input);
+      }
+      return shouldSampleWith(fallback, input);
+    }
+  };
+}
+function resolveTraceSampling(config) {
+  if (config === false) {
+    return { sampler: alwaysOffSampler, respectRemoteSampled: true, forceSampleOnError: false };
+  }
+  if (typeof config === "number") {
+    return { sampler: ratioSampler(config), respectRemoteSampled: true, forceSampleOnError: false };
+  }
+  if (isTraceSampler(config)) {
+    return { sampler: config, respectRemoteSampled: true, forceSampleOnError: false };
+  }
+  return {
+    sampler: makeTraceSampler(_nullishCoalesce(config, () => ( {}))),
+    respectRemoteSampled: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _42 => _42.respectRemoteSampled]), () => ( true)),
+    forceSampleOnError: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _43 => _43.forceSampleOnError]), () => ( false))
+  };
+}
+function shouldSampleWith(sampler, input) {
+  if (!sampler) return true;
+  if (typeof sampler === "function") return sampler(input);
+  return sampler.shouldSample(input);
+}
+function samplingRuleMatches(rule, input) {
+  if (rule.name && !matchText(rule.name, input.spanName)) 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) {
+  if (typeof value !== "string") return false;
+  return typeof pattern === "string" ? pattern === value : pattern.test(value);
+}
+function isTraceSampler(value) {
+  return typeof value === "function" || typeof value === "object" && value !== null && typeof value.shouldSample === "function";
+}
+function traceRatio(traceId) {
+  const normalized = normalizeTraceId(traceId);
+  const head = normalized.slice(0, 8);
+  const value = Number.parseInt(head, 16);
+  if (!Number.isFinite(value)) return 1;
+  return value / 4294967295;
+}
+function clampRatio(value) {
+  if (!Number.isFinite(value)) return 1;
+  return Math.max(0, Math.min(1, value));
+}
+
+// src/observability/traces.ts
+function withSpan(name, effect, attributesOrOptions) {
+  const options = resolveSpanOptions(attributesOrOptions);
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+    startSpan(name, options),
+    (state) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+      effect,
+      (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))
+    )
+  );
+}
+function spanLink(trace, attributes) {
+  return {
+    traceId: trace.traceId,
+    spanId: trace.spanId,
+    ...trace.traceState ? { traceState: trace.traceState } : {},
+    ...attributes ? { attributes } : {}
+  };
+}
+function currentSpanLink(attributes) {
+  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 _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+    startBaggage(baggage),
+    (state) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+      effect,
+      (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 = _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 _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)
+    );
+  });
+}
+function spansToOtlp(spans, options = {}) {
+  const scope = { name: _nullishCoalesce(options.scopeName, () => ( "brass-runtime")) };
+  if (options.scopeVersion) scope.version = options.scopeVersion;
+  return {
+    resourceSpans: [{
+      resource: { attributes: toOtlpAttributes(_nullishCoalesce(options.resource, () => ( {}))) },
+      scopeSpans: [{
+        scope,
+        spans: spans.map(spanToOtlp)
+      }]
+    }]
+  };
+}
+function makeOtlpHttpSpanExporter(source, options) {
+  return {
+    export: async () => {
+      const spans = typeof source === "function" ? source() : source.exportFinished();
+      const body = JSON.stringify(spansToOtlp(spans, options));
+      const response = await postOtlpJson(options, body);
+      return { status: response.status, body };
+    }
+  };
+}
+function startSpan(name, options) {
+  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', _58 => _58.traceId]), () => ( tracer.newTraceId()));
+    const sampled = decideSampling(runtime, {
+      traceId,
+      spanName: name,
+      parentSampled: _optionalChain([previousTrace, 'optionalAccess', _59 => _59.sampled]),
+      attributes: options.attributes
+    });
+    const trace = {
+      traceId,
+      spanId: tracer.newSpanId(),
+      parentSpanId: _optionalChain([previousTrace, 'optionalAccess', _60 => _60.spanId]),
+      sampled,
+      traceState: _optionalChain([previousTrace, 'optionalAccess', _61 => _61.traceState]),
+      ..._optionalChain([previousTrace, 'optionalAccess', _62 => _62.baggage]) ? { baggage: previousTrace.baggage } : {}
+    };
+    const state = {
+      fiber,
+      runtime,
+      previousTrace,
+      trace,
+      name,
+      options,
+      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', _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(
+        { type: "span.start", name, attributes: options.attributes, links: options.links.map(normalizeSpanLink) },
+        spanContext(fiber, trace)
+      );
+    }
+    return state;
+  });
+}
+function endSpan(state, status, error) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => finishSpan(state, status, error));
+}
+function finishSpan(state, status, error) {
+  if (!state || state.ended) return;
+  state.ended = true;
+  if (!state.startEmitted && status === "failure" && state.forceSampleOnError) {
+    state.trace.sampled = true;
+    state.startEmitted = true;
+    state.runtime.hooks.emit(
+      { type: "span.start", name: state.name, attributes: state.options.attributes, links: state.options.links.map(normalizeSpanLink) },
+      spanContext(state.fiber, state.trace)
+    );
+  }
+  if (state.startEmitted) {
+    state.runtime.hooks.emit(
+      { type: "span.end", name: state.name, status, error },
+      spanContext(state.fiber, state.trace)
+    );
+  }
+  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', _74 => _74.id]),
+    scopeId: _optionalChain([fiber, 'optionalAccess', _75 => _75.scopeId]),
+    traceId: trace.traceId,
+    spanId: trace.spanId,
+    parentSpanId: trace.parentSpanId,
+    traceState: trace.traceState,
+    baggage: trace.baggage,
+    sampled: trace.sampled
+  };
+}
+function startBaggage(baggage) {
+  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 };
+    fiber.fiberContext = {
+      ...fiber.fiberContext,
+      trace: {
+        ...previousTrace,
+        baggage: {
+          ..._nullishCoalesce(previousTrace.baggage, () => ( {})),
+          ...baggage
+        }
+      }
+    };
+    _optionalChain([fiber, 'access', _77 => _77.addFinalizer, 'optionalCall', _78 => _78(() => restoreBaggage(state))]);
+    return state;
+  });
+}
+function endBaggage(state) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => restoreBaggage(state));
+}
+function restoreBaggage(state) {
+  if (!state || state.ended) return;
+  state.ended = true;
+  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', _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', _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")
+  };
+}
+function spanToOtlp(span) {
+  const status = inferOtlpStatus(span);
+  return {
+    traceId: normalizeTraceId(span.traceId),
+    spanId: normalizeSpanId(span.spanId),
+    ...span.parentSpanId ? { parentSpanId: normalizeSpanId(span.parentSpanId) } : {},
+    ...span.traceState ? { traceState: span.traceState } : {},
+    name: span.name,
+    kind: spanKind(span),
+    startTimeUnixNano: unixNanoFromMs(span.startWallTs),
+    endTimeUnixNano: unixNanoFromMs(_nullishCoalesce(span.endWallTs, () => ( span.startWallTs))),
+    attributes: toOtlpAttributes(normalizeAttributes(span.attrs)),
+    events: span.events.map((event) => ({
+      name: event.name,
+      timeUnixNano: unixNanoFromMs(event.wallTs),
+      attributes: toOtlpAttributes(normalizeAttributes(event.attrs))
+    })),
+    links: (_nullishCoalesce(span.links, () => ( []))).map((link) => ({
+      traceId: normalizeTraceId(link.traceId),
+      spanId: normalizeSpanId(link.spanId),
+      ...link.traceState ? { traceState: link.traceState } : {},
+      attributes: toOtlpAttributes(normalizeAttributes(link.attributes))
+    })),
+    status
+  };
+}
+function spanKind(span) {
+  const kind = span.attrs["span.kind"];
+  if (kind === "server") return 2;
+  if (kind === "client") return 3;
+  if (kind === "producer") return 4;
+  if (kind === "consumer") return 5;
+  if (typeof kind === "number" && Number.isInteger(kind) && kind >= 1 && kind <= 5) return kind;
+  return 1;
+}
+function resolveSpanOptions(input) {
+  if (!input) return { attributes: {}, links: [] };
+  if ("attributes" in input || "links" in input) {
+    const options = input;
+    return {
+      attributes: _nullishCoalesce(options.attributes, () => ( {})),
+      links: _nullishCoalesce(options.links, () => ( []))
+    };
+  }
+  return { attributes: input, links: [] };
+}
+function normalizeSpanLink(link) {
+  return {
+    traceId: link.traceId,
+    spanId: link.spanId,
+    ...link.traceState ? { traceState: link.traceState } : {},
+    ...link.attributes ? { attributes: link.attributes } : {}
+  };
+}
+function inferOtlpStatus(span) {
+  const end = [...span.events].reverse().find((event) => event.name === "span.end" || event.name === "fiber.end");
+  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 };
+  }
+  if (status === "success") return { code: 1 };
+  return { code: 0 };
+}
+function normalizeAttributes(attrs) {
+  if (!attrs || typeof attrs !== "object") return {};
+  const out = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      out[key] = value;
+    } else if (value != null) {
+      out[key] = String(value);
+    }
+  }
+  return out;
+}
+function randomRuntimeId(prefix) {
+  const cryptoLike = globalThis.crypto;
+  if (typeof _optionalChain([cryptoLike, 'optionalAccess', _91 => _91.randomUUID]) === "function") return cryptoLike.randomUUID();
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+
+// src/observability/exportPipeline.ts
+var DEFAULT_BATCH_SIZE = 512;
+var DEFAULT_MAX_QUEUE_SIZE = 1e4;
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_SHUTDOWN_TIMEOUT_MS = 1e4;
+function makeExportPipeline(options) {
+  const signal = options.signal;
+  const clock = _nullishCoalesce(options.clock, () => ( Date.now));
+  const batchSize = Math.max(1, Math.floor(_nullishCoalesce(options.batchSize, () => ( DEFAULT_BATCH_SIZE))));
+  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', _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', _95 => _95.set, 'call', _96 => _96(queue.length)]);
+  const dropItems = (items) => {
+    if (items.length === 0) return;
+    droppedTotal += items.length;
+    _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) {
+      dropItems([...items]);
+      setQueueSize();
+      return 0;
+    }
+    const incoming = [...items];
+    const available = maxQueueSize - queue.length;
+    if (incoming.length <= available) {
+      queue.push(...incoming);
+      _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;
+    }
+    if (dropPolicy === "drop-newest") {
+      const accepted = incoming.slice(0, Math.max(0, available));
+      const dropped2 = incoming.slice(accepted.length);
+      queue.push(...accepted);
+      _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;
+    }
+    const total = queue.length + incoming.length;
+    const dropCount = Math.max(0, total - maxQueueSize);
+    const dropped = queue.splice(0, Math.min(dropCount, queue.length));
+    const remainingDrop = dropCount - dropped.length;
+    if (remainingDrop > 0) dropped.push(...incoming.splice(0, remainingDrop));
+    queue.push(...incoming);
+    _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;
+  };
+  const flush = async (flushOptions = {}) => {
+    const startedAt = clock();
+    const deadlineMs = flushOptions.deadlineMs;
+    const errors = [];
+    let exported = 0;
+    let failed = 0;
+    let batchCount = 0;
+    let attempts = 0;
+    let lastStatus;
+    let lastBody;
+    while (queue.length > 0) {
+      if (deadlineMs !== void 0 && clock() - startedAt >= deadlineMs) break;
+      const batch = queue.splice(0, batchSize);
+      const batchStartedAt = clock();
+      try {
+        const result = await exportWithRetry(
+          () => withTimeout(() => options.exportBatch(batch), timeoutMs),
+          {
+            signal,
+            metrics: options.metrics,
+            retry: options.retry
+          }
+        );
+        exported += batch.length;
+        batchCount++;
+        attempts += result.attempts;
+        lastStatus = result.value.status;
+        lastBody = result.value.body;
+        _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', _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', _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,
+      failed,
+      batchCount,
+      attempts,
+      queueSize: queue.length,
+      status: lastStatus,
+      body: lastBody,
+      errors
+    };
+  };
+  return {
+    enqueue,
+    flush,
+    shutdown: (deadline = _nullishCoalesce(options.shutdownTimeoutMs, () => ( DEFAULT_SHUTDOWN_TIMEOUT_MS))) => flush({ deadlineMs: deadline }),
+    stats: () => ({ queueSize: queue.length, dropped: droppedTotal })
+  };
+}
+async function exportWithRetry(operation, options) {
+  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 {
+      return { value: await operation(), attempts: attempt };
+    } catch (error) {
+      lastError = error;
+      if (attempt >= attempts) break;
+      _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));
+    }
+  }
+  throw lastError;
+}
+async function withTimeout(operation, timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0) return operation();
+  let handle;
+  try {
+    return await Promise.race([
+      operation(),
+      new Promise((_resolve, reject) => {
+        handle = setTimeout(() => reject(new Error(`Observability export timed out after ${timeoutMs}ms`)), timeoutMs);
+        _optionalChain([handle, 'access', _169 => _169.unref, 'optionalCall', _170 => _170()]);
+      })
+    ]);
+  } finally {
+    if (handle) clearTimeout(handle);
+  }
+}
+function jitteredDelay(initialDelayMs, maxDelayMs, jitterRatio, attempt) {
+  const base = Math.min(maxDelayMs, initialDelayMs * 2 ** Math.max(0, attempt - 1));
+  if (base <= 0 || jitterRatio <= 0) return base;
+  const spread = base * jitterRatio;
+  return Math.max(0, Math.round(base - spread + Math.random() * spread * 2));
+}
+function defaultSleep(ms) {
+  return new Promise((resolve) => {
+    const handle = setTimeout(resolve, ms);
+    _optionalChain([handle, 'access', _171 => _171.unref, 'optionalCall', _172 => _172()]);
+  });
+}
+
+// src/observability/cardinality.ts
+function makeCardinalityLimitedMetrics(registry, options = {}) {
+  const maxValuesPerLabel = Math.max(1, Math.floor(_nullishCoalesce(options.maxValuesPerLabel, () => ( 100))));
+  const overflowValue = _nullishCoalesce(options.overflowValue, () => ( "__overflow__"));
+  const seen = /* @__PURE__ */ new Map();
+  const limitLabels = (metricName, labels = {}) => {
+    const out = {};
+    for (const [label, value] of Object.entries(labels)) {
+      const key = `${metricName}:${label}`;
+      let values = seen.get(key);
+      if (!values) {
+        values = /* @__PURE__ */ new Set();
+        seen.set(key, values);
+      }
+      if (values.has(value) || values.size < maxValuesPerLabel) {
+        values.add(value);
+        out[label] = value;
+      } else {
+        out[label] = overflowValue;
+      }
+    }
+    return out;
+  };
+  return {
+    counter: (name, labels) => registry.counter(name, limitLabels(name, labels)),
+    gauge: (name, labels) => registry.gauge(name, limitLabels(name, labels)),
+    histogram: (name, boundaries, labels) => registry.histogram(name, boundaries, limitLabels(name, labels)),
+    snapshot: () => registry.snapshot(),
+    reset: () => {
+      seen.clear();
+      registry.reset();
+    }
+  };
+}
+function normalizeHttpRoute(path) {
+  if (!path) return void 0;
+  const withoutQuery = _nullishCoalesce(path.split("?", 1)[0], () => ( path));
+  const normalized = withoutQuery.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/gi, ":id").replace(/\b\d+\b/g, ":id");
+  return normalized || "/";
+}
+function sanitizeHttpTarget(url) {
+  if (!url) return void 0;
+  try {
+    const parsed = new URL(url, "http://local");
+    return `${parsed.pathname}${parsed.search ? "?[REDACTED]" : ""}`;
+  } catch (e6) {
+    const [withoutHash] = url.split("#", 1);
+    const queryIndex = withoutHash.indexOf("?");
+    return queryIndex < 0 ? withoutHash : `${withoutHash.slice(0, queryIndex)}?[REDACTED]`;
+  }
+}
+
+// src/observability/configValidation.ts
+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 = _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 = _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: _chunkCZIVE6NTcjs.Schema.enum(["drop-oldest", "drop-newest"]).optional(),
+  shutdownTimeoutMs: _chunkCZIVE6NTcjs.Schema.number({ min: 0, int: true }).optional()
+}, { unknownKeys: "passthrough" });
+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: _chunkCZIVE6NTcjs.Schema.number({ min: 1, int: true }).optional(),
+  retry: retryOptions.optional(),
+  pipeline: pipelineOptions.optional()
+}, { unknownKeys: "passthrough" });
+var samplingOptions = _chunkCZIVE6NTcjs.Schema.union([
+  _chunkCZIVE6NTcjs.Schema.literal(false),
+  ratio,
+  fn,
+  _chunkCZIVE6NTcjs.Schema.object({
+    ratio: ratio.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 = _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(),
+  logs: falseOrObject.optional(),
+  traces: falseOrObject.optional(),
+  sampling: samplingOptions.optional(),
+  redaction: falseOrObject.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: _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) {
+  _chunkCZIVE6NTcjs.parseConfig.call(void 0, "ObservabilityOptions", observabilityOptions, options);
+}
+function validateHttpObservabilityOptions(options) {
+  _chunkCZIVE6NTcjs.parseConfig.call(void 0, "HttpObservabilityOptions", httpObservabilityOptions, options);
+}
+
+// src/observability/setup.ts
+function makeObservability(options = {}) {
+  validateObservabilityOptions(options);
+  const serviceName = _nullishCoalesce(options.serviceName, () => ( "brass-runtime"));
+  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, _chunk52PPNNI4cjs.InMemoryTracer)({
+    maxFinishedSpans: _nullishCoalesce(traceOptions.maxFinishedSpans, () => ( 1e4)),
+    maxSpanAgeMs: _nullishCoalesce(traceOptions.maxSpanAgeMs, () => ( 10 * 6e4)),
+    clock: traceOptions.clock,
+    sanitizeAttributes: redactor.attributes,
+    sanitizeError: redactor.value
+  });
+  const traceIdGenerator = makeRuntimeTraceIdGenerator();
+  const sampling = resolveTraceSampling(options.traces === false ? false : options.sampling);
+  const makeEnv = (traceSeed, baggage) => ({
+    brass: {
+      tracer: traceIdGenerator,
+      ...traceSeed ? { traceSeed: baggage ? { ...traceSeed, baggage: { ..._nullishCoalesce(traceSeed.baggage, () => ( {})), ...baggage } } : traceSeed } : {},
+      ...!traceSeed && baggage ? { baggage } : {},
+      sampler: sampling.sampler,
+      respectRemoteSampled: sampling.respectRemoteSampled,
+      forceSampleOnError: sampling.forceSampleOnError,
+      childName: options.childName
+    }
+  });
+  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,
+    ...options.serviceVersion ? { "service.version": options.serviceVersion } : {},
+    ..._nullishCoalesce(options.resource, () => ( {}))
+  };
+  if (options.metrics !== false) {
+    const { prometheus: _prometheus, ...metricsOptions } = _nullishCoalesce(options.metrics, () => ( {}));
+    eventBus.subscribeHooks(makeRuntimeMetricsSink(metrics, metricsOptions));
+  }
+  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', _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,
+        scopeName: serviceName,
+        scopeVersion: options.serviceVersion
+      }));
+      const response = await postOtlpJson({
+        url: options.otlp.logsUrl,
+        headers: options.otlp.headers,
+        fetch: options.otlp.fetch
+      }, body);
+      return { status: response.status, body };
+    }
+  }) : void 0;
+  if (options.logs !== false) {
+    const configuredLogs = _nullishCoalesce(options.logs, () => ( {}));
+    const configuredWrite = configuredLogs.write;
+    eventBus.subscribeHooks(makeStructuredLogSink({
+      ...configuredLogs,
+      redact: options.logs && options.logs.redact !== void 0 ? options.logs.redact : redactor,
+      write: (record) => {
+        if (configuredWrite) configuredWrite(record);
+        else defaultStructuredLogWriter(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', _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,
+    resource,
+    scopeName: serviceName,
+    scopeVersion: options.serviceVersion
+  }) : void 0;
+  const otlpMetricsExporter = otlpMetrics ? {
+    export: async () => {
+      const result = await exportWithRetry(
+        () => withTimeout(() => otlpMetrics.export(), _nullishCoalesce(_optionalChain([options, 'access', _189 => _189.otlp, 'optionalAccess', _190 => _190.timeoutMs]), () => ( 1e4))),
+        {
+          signal: "metrics",
+          metrics,
+          retry: _optionalChain([options, 'access', _191 => _191.otlp, 'optionalAccess', _192 => _192.retry])
+        }
+      );
+      return result.value;
+    }
+  } : void 0;
+  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', _193 => _193.otlp, 'optionalAccess', _194 => _194.tracesUrl]) ? makeExportPipeline({
+    signal: "traces",
+    metrics,
+    ..._nullishCoalesce(options.otlp.pipeline, () => ( {})),
+    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,
+        scopeName: serviceName,
+        scopeVersion: options.serviceVersion
+      }));
+      const response = await postOtlpJson({
+        url: options.otlp.tracesUrl,
+        headers: options.otlp.headers,
+        fetch: options.otlp.fetch
+      }, body);
+      const spanIds = spans.map((span) => span.spanId);
+      for (const spanId of spanIds) {
+        exportedSpanIds.add(spanId);
+        queuedSpanIds.delete(spanId);
+      }
+      tracer.pruneFinished(spanIds);
+      for (const spanId of spanIds) exportedSpanIds.delete(spanId);
+      return { status: response.status, body };
+    },
+    onDrop: (spans) => {
+      const spanIds = spans.map((span) => span.spanId);
+      for (const spanId of spanIds) {
+        queuedSpanIds.delete(spanId);
+        exportedSpanIds.add(spanId);
+      }
+      tracer.pruneFinished(spanIds);
+      for (const spanId of spanIds) exportedSpanIds.delete(spanId);
+    }
+  }) : void 0;
+  const otlpTraces = _optionalChain([options, 'access', _201 => _201.otlp, 'optionalAccess', _202 => _202.tracesUrl]) ? {
+    pipeline: tracePipeline,
+    export: async () => {
+      const spans = pendingSpans();
+      for (const span of spans) queuedSpanIds.add(span.spanId);
+      tracePipeline.enqueue(spans);
+      if (tracePipeline.stats().queueSize === 0) {
+        return { status: void 0, body: "", spanCount: 0 };
+      }
+      const result = await tracePipeline.flush();
+      if (result.errors.length > 0) throw result.errors[0];
+      return {
+        status: result.status,
+        body: _nullishCoalesce(result.body, () => ( "")),
+        spanCount: result.exported
+      };
+    }
+  } : void 0;
+  const otlpLogs = logPipeline ? {
+    pipeline: logPipeline,
+    export: async () => {
+      if (logPipeline.stats().queueSize === 0) {
+        return { status: void 0, body: "", logCount: 0 };
+      }
+      const result = await logPipeline.flush();
+      if (result.errors.length > 0) throw result.errors[0];
+      return {
+        status: result.status,
+        body: _nullishCoalesce(result.body, () => ( "")),
+        logCount: result.exported
+      };
+    }
+  } : void 0;
+  let interval;
+  const flushNow = async () => {
+    eventBus.flush();
+    const errors = [];
+    let metricsResult;
+    let tracesResult;
+    let logsResult;
+    if (otlpMetricsExporter) {
+      try {
+        metricsResult = await otlpMetricsExporter.export();
+      } catch (error) {
+        errors.push({ signal: "metrics", error });
+        _optionalChain([options, 'access', _203 => _203.onFlushError, 'optionalCall', _204 => _204(error, "metrics")]);
+      }
+    }
+    if (otlpTraces) {
+      try {
+        tracesResult = await otlpTraces.export();
+      } catch (error) {
+        errors.push({ signal: "traces", error });
+        _optionalChain([options, 'access', _205 => _205.onFlushError, 'optionalCall', _206 => _206(error, "traces")]);
+      }
+    }
+    if (otlpLogs) {
+      try {
+        logsResult = await otlpLogs.export();
+      } catch (error) {
+        errors.push({ signal: "logs", error });
+        _optionalChain([options, 'access', _207 => _207.onFlushError, 'optionalCall', _208 => _208(error, "logs")]);
+      }
+    }
+    return { metrics: metricsResult, traces: tracesResult, logs: logsResult, errors };
+  };
+  let inFlightFlush;
+  const flush = () => {
+    if (inFlightFlush) {
+      metrics.counter("brass_export_flush_singleflight_total").increment();
+      return inFlightFlush;
+    }
+    inFlightFlush = flushNow().finally(() => {
+      inFlightFlush = void 0;
+    });
+    return inFlightFlush;
+  };
+  const start = () => {
+    if (interval || !options.flushIntervalMs || options.flushIntervalMs <= 0) return;
+    interval = setInterval(() => {
+      void flush();
+    }, options.flushIntervalMs);
+    _optionalChain([interval, 'access', _209 => _209.unref, 'optionalCall', _210 => _210()]);
+  };
+  const stop = () => {
+    if (!interval) return;
+    clearInterval(interval);
+    interval = void 0;
+  };
+  const shutdown = async () => {
+    stop();
+    const result = await flush();
+    const drainErrors = [];
+    let traces = result.traces;
+    let logs = result.logs;
+    if (tracePipeline && tracePipeline.stats().queueSize > 0) {
+      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', _214 => _214.onFlushError, 'optionalCall', _215 => _215(error, "traces")]);
+      }
+      traces = _nullishCoalesce(traces, () => ( {
+        status: drain.status,
+        body: _nullishCoalesce(drain.body, () => ( "")),
+        spanCount: drain.exported
+      }));
+    }
+    if (logPipeline && logPipeline.stats().queueSize > 0) {
+      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', _219 => _219.onFlushError, 'optionalCall', _220 => _220(error, "logs")]);
+      }
+      logs = _nullishCoalesce(logs, () => ( {
+        status: drain.status,
+        body: _nullishCoalesce(drain.body, () => ( "")),
+        logCount: drain.exported
+      }));
+    }
+    if (drainErrors.length === 0 && traces === result.traces && logs === result.logs) return result;
+    return {
+      ...result,
+      traces,
+      logs,
+      errors: [...result.errors, ...drainErrors]
+    };
+  };
+  if (_nullishCoalesce(options.autoStart, () => ( Boolean(options.flushIntervalMs)))) {
+    start();
+  }
+  return {
+    hooks: eventBus,
+    eventBus,
+    env,
+    envForRequest,
+    metrics,
+    tracer,
+    traceIdGenerator,
+    exporters: {
+      prometheus,
+      otlpMetrics: otlpMetricsExporter,
+      otlpTraces,
+      otlpLogs
+    },
+    prometheus,
+    health: (healthOptions = {}) => snapshotRuntimeHealth({ ...healthOptions, metrics }),
+    readiness: (healthOptions = {}) => snapshotRuntimeHealth({ ...healthOptions, metrics }).ready,
+    flush,
+    start,
+    stop,
+    shutdown
+  };
+}
+function resolveRequestTraceSeed(input) {
+  if (!input) return void 0;
+  if (isTraceContext(input)) return input;
+  const maybeRequest = input;
+  const explicitBaggage = typeof maybeRequest.baggage === "string" ? parseBaggage(maybeRequest.baggage) : maybeRequest.baggage;
+  if (maybeRequest.trace) {
+    return {
+      ...maybeRequest.trace,
+      ...explicitBaggage ? { baggage: { ..._nullishCoalesce(maybeRequest.trace.baggage, () => ( {})), ...explicitBaggage } } : {}
+    };
+  }
+  if (maybeRequest.traceparent) {
+    const trace = parseTraceparent(maybeRequest.traceparent);
+    return trace ? {
+      ...trace,
+      ...maybeRequest.tracestate ? { traceState: maybeRequest.tracestate } : {},
+      ...explicitBaggage ? { baggage: explicitBaggage } : {}
+    } : void 0;
+  }
+  if (maybeRequest.headers) {
+    const trace = extractTraceContext(maybeRequest.headers);
+    return trace && explicitBaggage ? { ...trace, baggage: { ..._nullishCoalesce(trace.baggage, () => ( {})), ...explicitBaggage } } : trace;
+  }
+  return extractTraceContext(input);
+}
+function resolveRequestBaggage(input) {
+  if (!input) return void 0;
+  if (isTraceContext(input)) return input.baggage;
+  const maybeRequest = input;
+  if (typeof maybeRequest.baggage === "string") return parseBaggage(maybeRequest.baggage);
+  if (maybeRequest.baggage) return maybeRequest.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);
+}
+function isTraceContext(value) {
+  return typeof value === "object" && value !== null && typeof value.traceId === "string" && typeof value.spanId === "string";
+}
+function makeRuntimeTraceIdGenerator() {
+  return {
+    newTraceId: () => randomHexId(32),
+    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', _223 => _223.getRandomValues]) === "function") {
+    const bytes = new Uint8Array(Math.ceil(length / 2));
+    cryptoLike.getRandomValues(bytes);
+    return bytesToHex(bytes, length);
+  }
+  if (typeof _optionalChain([cryptoLike, 'optionalAccess', _224 => _224.randomUUID]) === "function") {
+    const hex = cryptoLike.randomUUID().replace(/-/g, "");
+    if (hex.length >= length) return hex.slice(0, length);
+  }
+  let out = "";
+  while (out.length < length) {
+    out += Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0");
+  }
+  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 = {}) {
+  const trace = resolveRequestTraceSeed(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, _chunkGLE2WY7Zcjs.Runtime)({
+    ...options,
+    env: mergeEnv(extraEnv, env),
+    hooks: observability.hooks
+  });
+  return {
+    env,
+    trace,
+    route: input.route,
+    attributes,
+    makeRuntime,
+    run: (effect, extraEnv, options) => makeRuntime(extraEnv, options).toPromise(effect),
+    span: (name, effect, spanAttributes) => withSpan(name, effect, spanAttributes),
+    withRequestSpan: (effect, spanAttributes) => withSpan(defaultSpanName, effect, { ...attributes, ..._nullishCoalesce(spanAttributes, () => ( {})) }),
+    flush: observability.flush,
+    shutdown: observability.shutdown
+  };
+}
+function mergeEnv(extraEnv, observabilityEnv) {
+  return Object.assign({}, _nullishCoalesce(extraEnv, () => ( {})), observabilityEnv);
+}
+function requestSpanAttributes(input) {
+  return {
+    "span.kind": "server",
+    ...input.method ? { "http.method": input.method } : {},
+    ...input.method ? { "http.request.method": input.method } : {},
+    ...input.target ? { "http.target": input.target } : {},
+    ...input.target ? { "url.path": targetPath(input.target) } : {},
+    ...input.route ? { "http.route": input.route } : {},
+    ..._nullishCoalesce(input.attributes, () => ( {}))
+  };
+}
+function targetPath(target) {
+  try {
+    return new URL(target, "http://local").pathname;
+  } catch (e7) {
+    return _nullishCoalesce(target.split("?", 1)[0], () => ( target));
+  }
+}
+
+// src/observability/server.ts
+var DEFAULT_DURATION_BUCKETS2 = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4];
+async function runObservedHttpServerEffect(observability, input, effect, options = {}, env, runtimeOptions) {
+  return observeHttpServerRequest(
+    observability,
+    input,
+    async (ctx) => {
+      const effectWithServerEvents = withServerSpanEvents(effect, options);
+      const wrapped = options.spans === false ? effectWithServerEvents : ctx.span(serverSpanName(input, options), effectWithServerEvents, {
+        ...ctx.attributes,
+        ...serverSpanAttributes(input, options)
+      });
+      return ctx.run(wrapped, env, runtimeOptions);
+    },
+    options
+  );
+}
+function withServerSpanEvents(effect, options) {
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+    effect,
+    (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      spanEvent("http.server.error", {
+        "http.response.status_code": 500,
+        "error.type": error instanceof Error ? error.name : typeof error
+      }),
+      () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)
+    ),
+    (value) => {
+      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"
+        }),
+        () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value)
+      );
+    }
+  );
+}
+async function observeHttpServerRequest(observability, input, handler, options = {}) {
+  const resolved = resolveServerOptions(observability, options);
+  const ctx = makeRequestObservabilityContext(observability, input);
+  const startedAt = resolved.clock();
+  const baseLabels = requestBaseLabels(input, resolved);
+  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);
+    const statusCode = _nullishCoalesce(resolved.statusCode(value), () => ( 200));
+    const durationMs = finishServerObservation(startedAt, input, ctx.trace, statusCode, "success", resolved);
+    await ctx.run(logHttpServerResponse(input, statusCode, durationMs, "success", resolved));
+    return { value, ctx, statusCode, durationMs };
+  } catch (error) {
+    const durationMs = finishServerObservation(startedAt, input, ctx.trace, 500, "exception", resolved);
+    await ctx.run(logHttpServerError(input, error, durationMs, resolved));
+    throw error;
+  } finally {
+    if (inFlight && inFlight.value() > 0) inFlight.decrement();
+  }
+}
+function resolveServerOptions(observability, options) {
+  return {
+    metrics: options.metrics === false ? void 0 : _nullishCoalesce(options.metrics, () => ( observability.metrics)),
+    logs: _nullishCoalesce(options.logs, () => ( {})),
+    spans: _nullishCoalesce(options.spans, () => ( {})),
+    includeRouteLabel: _nullishCoalesce(options.includeRouteLabel, () => ( true)),
+    clock: _nullishCoalesce(options.clock, () => ( Date.now)),
+    durationBuckets: options.durationBuckets,
+    statusCode: _nullishCoalesce(options.statusCode, () => ( (() => void 0)))
+  };
+}
+function finishServerObservation(startedAt, input, trace, statusCode, outcome, options) {
+  const durationMs = Math.max(0, options.clock() - startedAt);
+  const labels = {
+    ...requestBaseLabels(input, options),
+    outcome: statusCode >= 500 ? "error" : outcome,
+    status: String(statusCode)
+  };
+  _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)
+  )]);
+  return durationMs;
+}
+function logHttpServerRequest(input, options) {
+  const level = options.logs === false ? false : _nullishCoalesce(options.logs.requestLevel, () => ( false));
+  if (!level) return logNoop();
+  return logEffect(level, "http.server.request", requestLogFields(input));
+}
+function logHttpServerResponse(input, statusCode, durationMs, outcome, options) {
+  const configured = options.logs === false ? false : _nullishCoalesce(options.logs.responseLevel, () => ( false));
+  const level = configured || (statusCode >= 500 ? options.logs !== false ? _nullishCoalesce(options.logs.errorLevel, () => ( "warn")) : false : false);
+  if (!level) return logNoop();
+  return logEffect(level, "http.server.response", {
+    ...requestLogFields(input),
+    status: statusCode,
+    outcome,
+    durationMs
+  });
+}
+function logHttpServerError(input, error, durationMs, options) {
+  const level = options.logs === false ? false : _nullishCoalesce(options.logs.errorLevel, () => ( "error"));
+  if (!level) return logNoop();
+  return logEffect(level, "http.server.error", {
+    ...requestLogFields(input),
+    status: 500,
+    outcome: "exception",
+    durationMs,
+    error: error instanceof Error ? error.message : String(error)
+  });
+}
+function logNoop() {
+  return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0);
+}
+function serverSpanName(input, options) {
+  if (options.spans && options.spans.name) {
+    return typeof options.spans.name === "function" ? options.spans.name(input) : options.spans.name;
+  }
+  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', _242 => _242.spans, 'optionalAccess', _243 => _243.attributes]);
+  const custom = typeof spanOptions === "function" ? spanOptions(input) : _nullishCoalesce(spanOptions, () => ( {}));
+  return {
+    "span.kind": "server",
+    ...input.method ? { "http.request.method": input.method } : {},
+    ...input.route ? { "http.route": input.route } : {},
+    ...custom
+  };
+}
+function requestBaseLabels(input, options) {
+  return compactLabels({
+    method: input.method,
+    ...options.includeRouteLabel ? { route: input.route } : {}
+  });
+}
+function requestLogFields(input) {
+  return {
+    ...input.method ? { method: input.method } : {},
+    ...input.route ? { route: input.route } : {},
+    ...input.target ? { target: input.target } : {}
+  };
+}
+function compactLabels(labels) {
+  const out = {};
+  for (const [key, value] of Object.entries(labels)) {
+    if (value !== void 0 && value !== "") out[key] = value;
+  }
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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.makeObservability = makeObservability; exports.resolveRequestTraceSeed = resolveRequestTraceSeed; exports.resolveRequestBaggage = resolveRequestBaggage; exports.makeRequestObservabilityContext = makeRequestObservabilityContext; exports.runObservedHttpServerEffect = runObservedHttpServerEffect; exports.observeHttpServerRequest = observeHttpServerRequest;