brass-runtime 1.15.0 → 1.16.0

package/dist/chunk-F5EUMJL7.mjs

@@ -0,0 +1,2143 @@
+import {
+  EventBus,
+  InMemoryTracer,
+  makeMetrics
+} from "./chunk-VFIUZG7J.mjs";
+import {
+  Runtime,
+  ctxExtend,
+  ctxToObject,
+  emptyContext,
+  getCurrentFiber
+} from "./chunk-G6IQOE4P.mjs";
+import {
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncSucceed,
+  asyncSync
+} from "./chunk-NOYZIMUJ.mjs";
+import {
+  Schema,
+  parseConfig
+} from "./chunk-U5KWK3PX.mjs";
+
+// src/observability/health.ts
+function snapshotRuntimeHealth(options = {}) {
+  const checkedAtMs = options.clock?.() ?? 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" && options.readiness?.failOnDegraded !== true,
+    checkedAt: new Date(checkedAtMs).toISOString(),
+    ...fibers ? { fibers } : {},
+    ...scopes ? { scopes } : {},
+    ...runtime ? { runtime } : {},
+    ...metrics ? { metrics } : {},
+    circuitBreakers,
+    adaptiveLimiters,
+    checks
+  };
+}
+function makeRuntimeHealth(options = {}) {
+  return asyncSync(() => snapshotRuntimeHealth(options));
+}
+var runtimeHealth = makeRuntimeHealth;
+function readiness(options = {}) {
+  return asyncSync(() => 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(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(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(limiters ?? {})) {
+    const stats = limiter.stats();
+    out[name] = {
+      ...stats,
+      status: adaptiveLimiterStatus(stats)
+    };
+  }
+  return out;
+}
+function adaptiveLimiterStatus(stats) {
+  const rejectionRate = stats.rejectionRate ?? 0;
+  const errorRate = 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) => snapshot.gauges.find((gauge) => gauge.name === name)?.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 = runtime.stats?.();
+  const scheduler = runtime.scheduler?.stats?.();
+  return {
+    engine: stats?.engine,
+    fiberStats: stats?.data,
+    scheduler
+  };
+}
+function runtimeSchedulerDropped(runtime) {
+  const data = runtime?.scheduler?.data;
+  return typeof data?.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 } : config ?? {};
+  const replacement = options.replacement ?? DEFAULT_REPLACEMENT;
+  const keys = options.keys ?? DEFAULT_KEY_PATTERNS;
+  const headers = options.headers ?? DEFAULT_HEADER_PATTERNS;
+  const maxDepth = Math.max(1, Math.floor(options.maxDepth ?? DEFAULT_MAX_DEPTH));
+  const maxStringLength = Math.max(0, Math.floor(options.maxStringLength ?? DEFAULT_MAX_STRING_LENGTH));
+  const redactUrlQuery = 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 {
+    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 = { ...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 = { ...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 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 value?.[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[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 {
+    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(options.now?.() ?? Date.now());
+  const metricName = (name) => sanitizeMetricName(`${options.prefix ?? ""}${name}`);
+  const emitHeader = (name, type) => {
+    const safeName = metricName(name);
+    const key = `${safeName}:${type}`;
+    if (emittedHeaders.has(key)) return;
+    emittedHeaders.add(key);
+    if (options.help?.[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 += buckets.counts[i] ?? 0;
+      emitSample(`${histogram.name}_bucket`, { ...histogram.labels, le: String(buckets.boundaries[i]) }, cumulative, buckets.exemplars?.[i]);
+    }
+    cumulative += buckets.counts[buckets.boundaries.length] ?? 0;
+    emitSample(`${histogram.name}_bucket`, { ...histogram.labels, le: "+Inf" }, cumulative, buckets.exemplars?.[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(options.now?.() ?? Date.now());
+  const scope = { name: 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(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 = options.clock ?? Date.now;
+  const durationBuckets = [...options.durationBuckets ?? DEFAULT_DURATION_BUCKETS];
+  const includeEventTotals = options.includeEventTotals ?? true;
+  const includeSpanNameLabel = 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 {
+      }
+    }
+  };
+}
+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 (!trace?.traceId || !trace?.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(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 = 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,
+      ...options.headers ?? {}
+    },
+    body
+  });
+  if (response?.ok === false) {
+    let detail = "";
+    try {
+      detail = response.text ? `: ${await response.text()}` : "";
+    } catch {
+      detail = "";
+    }
+    throw new Error(`OTLP export failed with status ${response.status ?? "unknown"}${detail}`);
+  }
+  return 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 = {
+    ...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 = options.minLevel ?? "debug";
+  const clock = options.clock ?? Date.now;
+  const write = 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(ev.fields ?? {}),
+          fiberId: ctx.fiberId,
+          scopeId: ctx.scopeId,
+          traceId: ctx.traceId,
+          spanId: ctx.spanId,
+          parentSpanId: ctx.parentSpanId,
+          traceState: ctx.traceState
+        });
+      } catch {
+      }
+    }
+  };
+}
+function formatStructuredLog(record) {
+  return JSON.stringify(record);
+}
+function structuredLogsToOtlp(records, options = {}) {
+  const scope = { name: options.scopeName ?? "brass-runtime" };
+  if (options.scopeVersion) scope.version = options.scopeVersion;
+  return {
+    resourceLogs: [{
+      resource: { attributes: toOtlpAttributes(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 asyncSync(() => {
+    const fiber = getCurrentFiber();
+    const runtime = fiber?.runtime;
+    if (!runtime) return;
+    const inherited = fiber.fiberContext?.log ? ctxToObject(fiber.fiberContext.log) : {};
+    runtime.log(level, message, { ...inherited, ...fields });
+  });
+}
+function withLogContext(patch, effect) {
+  return asyncFlatMap(
+    startLogContext(patch),
+    (state) => asyncFold(
+      effect,
+      (error) => asyncFlatMap(endLogContext(state), () => asyncFail(error)),
+      (value) => asyncFlatMap(endLogContext(state), () => asyncSucceed(value))
+    )
+  );
+}
+function startLogContext(patch) {
+  return asyncSync(() => {
+    const fiber = getCurrentFiber();
+    if (!fiber?.fiberContext) return void 0;
+    const previous = fiber.fiberContext.log ?? emptyContext;
+    const state = { fiber, previous, ended: false };
+    fiber.fiberContext = { ...fiber.fiberContext, log: ctxExtend(previous, patch) };
+    fiber.addFinalizer?.(() => restoreLogContext(state));
+    return state;
+  });
+}
+function endLogContext(state) {
+  return asyncSync(() => restoreLogContext(state));
+}
+function restoreLogContext(state) {
+  if (!state || state.ended) return;
+  state.ended = true;
+  if (state.fiber?.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 = options.sampler ?? ratioSampler(options.ratio ?? 1);
+  const rules = 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(config ?? {}),
+    respectRemoteSampled: config?.respectRemoteSampled ?? true,
+    forceSampleOnError: config?.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, input.attributes?.["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 asyncFlatMap(
+    startSpan(name, options),
+    (state) => asyncFold(
+      effect,
+      (error) => asyncFlatMap(endSpan(state, "failure", error), () => asyncFail(error)),
+      (value) => asyncFlatMap(endSpan(state, "success"), () => asyncSucceed(value))
+    )
+  );
+}
+function spanLink(trace, attributes) {
+  return {
+    traceId: trace.traceId,
+    spanId: trace.spanId,
+    ...trace.traceState ? { traceState: trace.traceState } : {},
+    ...attributes ? { attributes } : {}
+  };
+}
+function currentSpanLink(attributes) {
+  const fiber = getCurrentFiber();
+  const trace = fiber?.fiberContext?.trace;
+  return trace?.traceId && trace?.spanId ? spanLink(trace, attributes) : void 0;
+}
+function withBaggage(baggage, effect) {
+  return asyncFlatMap(
+    startBaggage(baggage),
+    (state) => asyncFold(
+      effect,
+      (error) => asyncFlatMap(endBaggage(state), () => asyncFail(error)),
+      (value) => asyncFlatMap(endBaggage(state), () => asyncSucceed(value))
+    )
+  );
+}
+function currentBaggage() {
+  const fiber = getCurrentFiber();
+  const baggage = fiber?.fiberContext?.trace?.baggage;
+  return baggage ? { ...baggage } : void 0;
+}
+function spanEvent(name, attributes = {}) {
+  return asyncSync(() => {
+    const fiber = getCurrentFiber();
+    const trace = fiber?.fiberContext?.trace;
+    if (!fiber?.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: options.scopeName ?? "brass-runtime" };
+  if (options.scopeVersion) scope.version = options.scopeVersion;
+  return {
+    resourceSpans: [{
+      resource: { attributes: toOtlpAttributes(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 asyncSync(() => {
+    const fiber = getCurrentFiber();
+    const runtime = fiber?.runtime;
+    if (!fiber?.fiberContext || !runtime) return void 0;
+    const previousTrace = fiber.fiberContext.trace ?? null;
+    const tracer = resolveTracer(runtime);
+    const traceId = previousTrace?.traceId ?? tracer.newTraceId();
+    const sampled = decideSampling(runtime, {
+      traceId,
+      spanName: name,
+      parentSampled: previousTrace?.sampled,
+      attributes: options.attributes
+    });
+    const trace = {
+      traceId,
+      spanId: tracer.newSpanId(),
+      parentSpanId: previousTrace?.spanId,
+      sampled,
+      traceState: previousTrace?.traceState,
+      ...previousTrace?.baggage ? { baggage: previousTrace.baggage } : {}
+    };
+    const state = {
+      fiber,
+      runtime,
+      previousTrace,
+      trace,
+      name,
+      options,
+      forceSampleOnError: runtime?.env?.brass?.forceSampleOnError === true,
+      startEmitted: sampled !== false,
+      ended: false
+    };
+    fiber.fiberContext = { ...fiber.fiberContext, trace };
+    fiber.addFinalizer?.((exit) => {
+      const status = exit?._tag === "Success" ? "success" : exit?.cause?._tag === "Interrupt" ? "interrupted" : "failure";
+      finishSpan(state, status, exit?._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 asyncSync(() => 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 (state.fiber?.fiberContext) {
+    state.fiber.fiberContext = { ...state.fiber.fiberContext, trace: state.previousTrace };
+  }
+}
+function spanContext(fiber, trace) {
+  return {
+    fiberId: fiber?.id,
+    scopeId: fiber?.scopeId,
+    traceId: trace.traceId,
+    spanId: trace.spanId,
+    parentSpanId: trace.parentSpanId,
+    traceState: trace.traceState,
+    baggage: trace.baggage,
+    sampled: trace.sampled
+  };
+}
+function startBaggage(baggage) {
+  return asyncSync(() => {
+    const fiber = getCurrentFiber();
+    if (!fiber?.fiberContext) return void 0;
+    const previousTrace = fiber.fiberContext.trace ?? null;
+    if (!previousTrace) return void 0;
+    const state = { fiber, previousTrace, ended: false };
+    fiber.fiberContext = {
+      ...fiber.fiberContext,
+      trace: {
+        ...previousTrace,
+        baggage: {
+          ...previousTrace.baggage ?? {},
+          ...baggage
+        }
+      }
+    };
+    fiber.addFinalizer?.(() => restoreBaggage(state));
+    return state;
+  });
+}
+function endBaggage(state) {
+  return asyncSync(() => restoreBaggage(state));
+}
+function restoreBaggage(state) {
+  if (!state || state.ended) return;
+  state.ended = true;
+  if (state.fiber?.fiberContext) {
+    state.fiber.fiberContext = { ...state.fiber.fiberContext, trace: state.previousTrace };
+  }
+}
+function decideSampling(runtime, input) {
+  const brass = runtime?.env?.brass;
+  if (input.parentSampled === false && brass?.respectRemoteSampled !== false) return false;
+  return shouldSampleWith(brass?.sampler, input);
+}
+function resolveTracer(runtime) {
+  const tracer = runtime?.env?.brass?.tracer;
+  if (tracer?.newTraceId && tracer?.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(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: (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: options.attributes ?? {},
+      links: 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 end?.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 cryptoLike?.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 = options.clock ?? Date.now;
+  const batchSize = Math.max(1, Math.floor(options.batchSize ?? DEFAULT_BATCH_SIZE));
+  const maxQueueSize = Math.max(0, Math.floor(options.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE));
+  const timeoutMs = Math.max(0, Math.floor(options.timeoutMs ?? DEFAULT_TIMEOUT_MS));
+  const dropPolicy = options.dropPolicy ?? "drop-oldest";
+  const queueGauge = options.metrics?.gauge("brass_export_queue_size", { signal });
+  let queue = [];
+  let droppedTotal = 0;
+  const setQueueSize = () => queueGauge?.set(queue.length);
+  const dropItems = (items) => {
+    if (items.length === 0) return;
+    droppedTotal += items.length;
+    options.metrics?.counter("brass_export_dropped_total", { signal }).increment(items.length);
+    options.onDrop?.(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);
+      options.metrics?.counter("brass_export_enqueued_total", { signal }).increment(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);
+      options.metrics?.counter("brass_export_enqueued_total", { signal }).increment(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);
+    options.metrics?.counter("brass_export_enqueued_total", { signal }).increment(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;
+        options.metrics?.counter("brass_export_batches_total", { signal, status: "success" }).increment();
+        options.metrics?.counter("brass_export_items_total", { signal, status: "success" }).increment(batch.length);
+        options.metrics?.histogram("brass_export_batch_duration_ms", void 0, { signal, status: "success" }).observe(clock() - batchStartedAt);
+      } catch (error) {
+        failed += batch.length;
+        errors.push(error);
+        queue = [...batch, ...queue];
+        options.metrics?.counter("brass_export_batches_total", { signal, status: "failure" }).increment();
+        options.metrics?.counter("brass_export_items_total", { signal, status: "failure" }).increment(batch.length);
+        options.metrics?.histogram("brass_export_batch_duration_ms", void 0, { signal, status: "failure" }).observe(clock() - batchStartedAt);
+        break;
+      } finally {
+        setQueueSize();
+      }
+    }
+    options.metrics?.histogram("brass_export_flush_duration_ms", void 0, { signal }).observe(clock() - startedAt);
+    return {
+      exported,
+      dropped: droppedTotal,
+      failed,
+      batchCount,
+      attempts,
+      queueSize: queue.length,
+      status: lastStatus,
+      body: lastBody,
+      errors
+    };
+  };
+  return {
+    enqueue,
+    flush,
+    shutdown: (deadline = 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(options.retry?.attempts ?? 1));
+  const initialDelayMs = Math.max(0, options.retry?.initialDelayMs ?? 100);
+  const maxDelayMs = Math.max(initialDelayMs, options.retry?.maxDelayMs ?? 2e3);
+  const jitterRatio = Math.max(0, Math.min(1, options.retry?.jitterRatio ?? 0.2));
+  const sleep = options.retry?.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;
+      options.metrics?.counter("brass_export_retries_total", { signal: options.signal }).increment();
+      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);
+        handle.unref?.();
+      })
+    ]);
+  } 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);
+    handle.unref?.();
+  });
+}
+
+// src/observability/cardinality.ts
+function makeCardinalityLimitedMetrics(registry, options = {}) {
+  const maxValuesPerLabel = Math.max(1, Math.floor(options.maxValuesPerLabel ?? 100));
+  const overflowValue = 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 = 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 {
+    const [withoutHash] = url.split("#", 1);
+    const queryIndex = withoutHash.indexOf("?");
+    return queryIndex < 0 ? withoutHash : `${withoutHash.slice(0, queryIndex)}?[REDACTED]`;
+  }
+}
+
+// src/observability/configValidation.ts
+var fn = Schema.custom((value) => typeof value === "function", "function");
+var object = Schema.custom(
+  (value) => typeof value === "object" && value !== null && !Array.isArray(value),
+  "object"
+);
+var falseOrObject = Schema.union([Schema.literal(false), object]);
+var ratio = Schema.number({ min: 0, max: 1 });
+var retryOptions = Schema.object({
+  attempts: Schema.number({ min: 0, int: true }).optional(),
+  initialDelayMs: Schema.number({ min: 0, int: true }).optional(),
+  maxDelayMs: Schema.number({ min: 0, int: true }).optional(),
+  jitterRatio: Schema.number({ min: 0, max: 1 }).optional(),
+  sleep: fn.optional()
+}, { unknownKeys: "passthrough" });
+var pipelineOptions = Schema.object({
+  maxQueueSize: Schema.number({ min: 0, int: true }).optional(),
+  batchSize: Schema.number({ min: 1, int: true }).optional(),
+  timeoutMs: Schema.number({ min: 0, int: true }).optional(),
+  retry: retryOptions.optional(),
+  dropPolicy: Schema.enum(["drop-oldest", "drop-newest"]).optional(),
+  shutdownTimeoutMs: Schema.number({ min: 0, int: true }).optional()
+}, { unknownKeys: "passthrough" });
+var otlpOptions = Schema.object({
+  metricsUrl: Schema.string().optional(),
+  tracesUrl: Schema.string().optional(),
+  logsUrl: Schema.string().optional(),
+  headers: Schema.record(Schema.string()).optional(),
+  fetch: fn.optional(),
+  timeoutMs: Schema.number({ min: 1, int: true }).optional(),
+  retry: retryOptions.optional(),
+  pipeline: pipelineOptions.optional()
+}, { unknownKeys: "passthrough" });
+var samplingOptions = Schema.union([
+  Schema.literal(false),
+  ratio,
+  fn,
+  Schema.object({
+    ratio: ratio.optional(),
+    rules: Schema.array(object).optional(),
+    sampler: Schema.union([fn, object]).optional(),
+    respectRemoteSampled: Schema.boolean().optional(),
+    forceSampleOnError: Schema.boolean().optional()
+  }, { unknownKeys: "passthrough" })
+]);
+var observabilityOptions = Schema.object({
+  serviceName: Schema.string({ minLength: 1 }).optional(),
+  serviceVersion: 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: Schema.union([
+    Schema.literal(false),
+    Schema.object({
+      maxValuesPerLabel: Schema.number({ min: 1, int: true }).optional(),
+      overflowValue: Schema.string({ minLength: 1 }).optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  otlp: otlpOptions.optional(),
+  flushIntervalMs: Schema.number({ min: 1, int: true }).optional(),
+  autoStart: Schema.boolean().optional(),
+  traceSeed: object.optional(),
+  childName: fn.optional(),
+  onFlushError: fn.optional()
+}, { unknownKeys: "passthrough" });
+function validateObservabilityOptions(options) {
+  parseConfig("ObservabilityOptions", observabilityOptions, options);
+}
+
+// src/observability/setup.ts
+function makeObservability(options = {}) {
+  validateObservabilityOptions(options);
+  const serviceName = options.serviceName ?? "brass-runtime";
+  const eventBus = options.eventBus ?? new EventBus();
+  const rawMetrics = makeMetrics();
+  const metrics = options.cardinality === false ? rawMetrics : makeCardinalityLimitedMetrics(rawMetrics, options.cardinality ?? {});
+  const redactor = makeObservabilityRedactor(options.redaction);
+  const traceOptions = options.traces && typeof options.traces === "object" ? options.traces : {};
+  const tracer = new InMemoryTracer({
+    maxFinishedSpans: traceOptions.maxFinishedSpans ?? 1e4,
+    maxSpanAgeMs: 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: { ...traceSeed.baggage ?? {}, ...baggage } } : traceSeed } : {},
+      ...!traceSeed && baggage ? { baggage } : {},
+      sampler: sampling.sampler,
+      respectRemoteSampled: sampling.respectRemoteSampled,
+      forceSampleOnError: sampling.forceSampleOnError,
+      childName: options.childName
+    }
+  });
+  const env = makeEnv(options.traceSeed, options.traceSeed?.baggage);
+  const envForRequest = (input) => makeEnv(resolveRequestTraceSeed(input) ?? options.traceSeed, resolveRequestBaggage(input));
+  const resource = {
+    "service.name": serviceName,
+    ...options.serviceVersion ? { "service.version": options.serviceVersion } : {},
+    ...options.resource ?? {}
+  };
+  if (options.metrics !== false) {
+    const { prometheus: _prometheus, ...metricsOptions } = options.metrics ?? {};
+    eventBus.subscribeHooks(makeRuntimeMetricsSink(metrics, metricsOptions));
+  }
+  const logPipeline = options.logs !== false && options.otlp?.logsUrl ? makeExportPipeline({
+    signal: "logs",
+    metrics,
+    ...options.otlp.pipeline ?? {},
+    timeoutMs: options.otlp.timeoutMs ?? options.otlp.pipeline?.timeoutMs,
+    retry: options.otlp.retry ?? options.otlp.pipeline?.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 = 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);
+        logPipeline?.enqueue([record]);
+      }
+    }));
+  }
+  if (options.traces !== false) {
+    eventBus.subscribeHooks(tracer);
+  }
+  const prometheus = makePrometheusMetricsExporter(metrics, options.metrics !== false ? options.metrics?.prometheus : void 0);
+  const otlpMetrics = options.otlp?.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(), options.otlp?.timeoutMs ?? 1e4),
+        {
+          signal: "metrics",
+          metrics,
+          retry: options.otlp?.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 = options.otlp?.tracesUrl ? makeExportPipeline({
+    signal: "traces",
+    metrics,
+    ...options.otlp.pipeline ?? {},
+    timeoutMs: options.otlp.timeoutMs ?? options.otlp.pipeline?.timeoutMs,
+    retry: options.otlp.retry ?? options.otlp.pipeline?.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 = options.otlp?.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: 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: 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 });
+        options.onFlushError?.(error, "metrics");
+      }
+    }
+    if (otlpTraces) {
+      try {
+        tracesResult = await otlpTraces.export();
+      } catch (error) {
+        errors.push({ signal: "traces", error });
+        options.onFlushError?.(error, "traces");
+      }
+    }
+    if (otlpLogs) {
+      try {
+        logsResult = await otlpLogs.export();
+      } catch (error) {
+        errors.push({ signal: "logs", error });
+        options.onFlushError?.(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);
+    interval.unref?.();
+  };
+  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(options.otlp?.pipeline?.shutdownTimeoutMs);
+      for (const error of drain.errors) {
+        drainErrors.push({ signal: "traces", error });
+        options.onFlushError?.(error, "traces");
+      }
+      traces = traces ?? {
+        status: drain.status,
+        body: drain.body ?? "",
+        spanCount: drain.exported
+      };
+    }
+    if (logPipeline && logPipeline.stats().queueSize > 0) {
+      const drain = await logPipeline.shutdown(options.otlp?.pipeline?.shutdownTimeoutMs);
+      for (const error of drain.errors) {
+        drainErrors.push({ signal: "logs", error });
+        options.onFlushError?.(error, "logs");
+      }
+      logs = logs ?? {
+        status: drain.status,
+        body: 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 (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: { ...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: { ...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 (maybeRequest.trace?.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)
+  };
+}
+function randomHexId(length) {
+  const cryptoLike = globalThis.crypto;
+  if (typeof cryptoLike?.getRandomValues === "function") {
+    const bytes = new Uint8Array(Math.ceil(length / 2));
+    cryptoLike.getRandomValues(bytes);
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, length);
+  }
+  if (typeof cryptoLike?.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);
+}
+
+// src/observability/request.ts
+function makeRequestObservabilityContext(observability, input = {}) {
+  const trace = resolveRequestTraceSeed(input);
+  const env = observability.envForRequest(input);
+  const attributes = requestSpanAttributes(input);
+  const defaultSpanName = input.spanName ?? (input.method && input.route ? `${input.method} ${input.route}` : input.route ?? "request");
+  const makeRuntime = (extraEnv, options = {}) => new 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, ...spanAttributes ?? {} }),
+    flush: observability.flush,
+    shutdown: observability.shutdown
+  };
+}
+function mergeEnv(extraEnv, observabilityEnv) {
+  return Object.assign({}, 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 } : {},
+    ...input.attributes ?? {}
+  };
+}
+function targetPath(target) {
+  try {
+    return new URL(target, "http://local").pathname;
+  } catch {
+    return 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 asyncFold(
+    effect,
+    (error) => asyncFlatMap(
+      spanEvent("http.server.error", {
+        "http.response.status_code": 500,
+        "error.type": error instanceof Error ? error.name : typeof error
+      }),
+      () => asyncFail(error)
+    ),
+    (value) => {
+      const statusCode = options.statusCode?.(value) ?? 200;
+      return asyncFlatMap(
+        spanEvent("http.server.response", {
+          "http.response.status_code": statusCode,
+          "http.outcome": statusCode >= 500 ? "error" : "success"
+        }),
+        () => asyncSucceed(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 = resolved.metrics?.gauge("brass_http_server_in_flight", baseLabels);
+  inFlight?.increment();
+  try {
+    await ctx.run(logHttpServerRequest(input, resolved));
+    const value = await handler(ctx);
+    const statusCode = 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 : options.metrics ?? observability.metrics,
+    logs: options.logs ?? {},
+    spans: options.spans ?? {},
+    includeRouteLabel: options.includeRouteLabel ?? true,
+    clock: options.clock ?? Date.now,
+    durationBuckets: options.durationBuckets,
+    statusCode: 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)
+  };
+  options.metrics?.counter("brass_http_server_requests_total", labels).increment();
+  options.metrics?.histogram("brass_http_server_duration_ms", [...options.durationBuckets ?? DEFAULT_DURATION_BUCKETS2], labels).observe(
+    durationMs,
+    exemplarFromTraceContext(trace, durationMs, startedAt + durationMs)
+  );
+  return durationMs;
+}
+function logHttpServerRequest(input, options) {
+  const level = options.logs === false ? false : 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 : options.logs.responseLevel ?? false;
+  const level = configured || (statusCode >= 500 ? options.logs !== false ? 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 : 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 asyncSucceed(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}` : input.route ?? "request";
+}
+function serverSpanAttributes(input, options) {
+  const spanOptions = options.spans === false ? {} : options.spans?.attributes;
+  const custom = typeof spanOptions === "function" ? spanOptions(input) : 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;
+}
+
+export {
+  snapshotRuntimeHealth,
+  makeRuntimeHealth,
+  runtimeHealth,
+  readiness,
+  healthToHttpResponse,
+  makeObservabilityRedactor,
+  parseTraceparent,
+  formatTraceparent,
+  extractTraceContext,
+  injectTraceContext,
+  parseBaggage,
+  formatBaggage,
+  extractBaggage,
+  injectBaggage,
+  normalizeTraceId,
+  normalizeSpanId,
+  PROMETHEUS_CONTENT_TYPE,
+  OTLP_JSON_CONTENT_TYPE,
+  makePrometheusMetricsExporter,
+  formatPrometheusMetrics,
+  metricsSnapshotToOtlp,
+  makeOtlpHttpMetricsExporter,
+  makeRuntimeMetricsSink,
+  exemplarFromTraceContext,
+  toOtlpAttributes,
+  otlpAnyValue,
+  postOtlpJson,
+  unixNanoFromMs,
+  makeStructuredLogSink,
+  formatStructuredLog,
+  structuredLogsToOtlp,
+  makeOtlpHttpLogExporter,
+  logEffect,
+  withLogContext,
+  defaultStructuredLogWriter,
+  alwaysOnSampler,
+  alwaysOffSampler,
+  ratioSampler,
+  makeTraceSampler,
+  resolveTraceSampling,
+  shouldSampleWith,
+  withSpan,
+  spanLink,
+  currentSpanLink,
+  withBaggage,
+  currentBaggage,
+  spanEvent,
+  spansToOtlp,
+  makeOtlpHttpSpanExporter,
+  makeExportPipeline,
+  exportWithRetry,
+  withTimeout,
+  makeCardinalityLimitedMetrics,
+  normalizeHttpRoute,
+  sanitizeHttpTarget,
+  makeObservability,
+  resolveRequestTraceSeed,
+  resolveRequestBaggage,
+  makeRequestObservabilityContext,
+  runObservedHttpServerEffect,
+  observeHttpServerRequest
+};