@autter/runtime-node 1.3.4 → 1.5.0

package/dist/index.js

@@ -1,3 +1,69 @@
+import {
+  CODE_PATTERN,
+  DEFAULT_REQUEST_ID_HEADER,
+  RuntimeError,
+  captureExceptionAsLog,
+  compileIgnore,
+  configureRuntimeLogger,
+  consoleSink,
+  createRequestState,
+  createRuntimeLogger,
+  currentOperation,
+  defineRuntimeErrors,
+  emitSummary,
+  errorAttributes,
+  errorCodeOf,
+  errorInternal,
+  fileSink,
+  flushRuntimeLogs,
+  isRuntimeErrorLike,
+  local,
+  makeRedactor,
+  normalizeRoutePath,
+  noteOperationError,
+  notifyException,
+  otlpSink,
+  parseUserAgent,
+  recordOperationAiUsage,
+  redactAttributes,
+  redactText,
+  reportExplicitFailure,
+  requestOutcome,
+  resolveRequestId,
+  responseStatusOf,
+  runInBackground,
+  runtimeContext,
+  runtimeLogStats,
+  runtimeLogger,
+  shutdownRuntimeLogger,
+  toClientError,
+  withRuntimeOperation
+} from "./chunk-3TJHUCZ6.js";
+import {
+  runDoctor
+} from "./chunk-ZS4WQJQR.js";
+import {
+  COMPAT_MANIFEST,
+  CountingExporter,
+  INGESTER_VERSION_HEADER,
+  SDK_IDENTITY,
+  configureCompatCheck,
+  debugLog,
+  ensureCompatConfigured,
+  evaluateCompat,
+  featuresForBrowserEvents,
+  fetchIngesterCompat,
+  installAutterAutoFlush,
+  isDebugEnabled,
+  noteCompatFeature,
+  noteRelayRejection,
+  observeIngesterResponse,
+  registerFlushTarget,
+  setDebugMode,
+  telemetryStats,
+  unregisterFlushTargets
+} from "./chunk-L7HWKMCZ.js";
+
 // src/relay.ts
 var IpWindow = class {
   constructor(limitPerMinute) {
@@ -36,7 +102,120 @@ var EVENT_TYPES = /* @__PURE__ */ new Set([
   "timing"
 ]);
 var SEVERITIES = /* @__PURE__ */ new Set(["fatal", "error", "warning", "info"]);
-function sanitizeBrowserPayload(raw) {
+var CONTEXT_MAX_DEPTH = 6;
+var CONTEXT_MAX_NODES = 256;
+var CONTEXT_MAX_STRING = 4e3;
+var CONTEXT_MAX_ARRAY = 100;
+var CONTEXT_MAX_KEYS = 100;
+function byteLength(text) {
+  return new TextEncoder().encode(text).length;
+}
+function boundContext(value) {
+  let nodes = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (v, depth) => {
+    if (v === null) return null;
+    const t = typeof v;
+    if (t === "string") return v.slice(0, CONTEXT_MAX_STRING);
+    if (t === "number" || t === "boolean") return v;
+    if (t !== "object") return void 0;
+    if (depth >= CONTEXT_MAX_DEPTH || nodes >= CONTEXT_MAX_NODES) return void 0;
+    const obj = v;
+    if (seen.has(obj)) return void 0;
+    seen.add(obj);
+    let isArr = false;
+    try {
+      isArr = Array.isArray(v);
+    } catch {
+      return void 0;
+    }
+    if (isArr) {
+      const arr = v;
+      const out2 = [];
+      let len = 0;
+      try {
+        len = arr.length;
+      } catch {
+        return out2;
+      }
+      for (let i = 0; i < len && i < CONTEXT_MAX_ARRAY; i++) {
+        if (nodes >= CONTEXT_MAX_NODES) break;
+        nodes++;
+        let el;
+        try {
+          el = walk(arr[i], depth + 1);
+        } catch {
+          el = void 0;
+        }
+        if (el !== void 0) out2.push(el);
+      }
+      return out2;
+    }
+    let keys;
+    try {
+      keys = Object.keys(obj);
+    } catch {
+      return void 0;
+    }
+    const out = {};
+    for (let i = 0; i < keys.length && i < CONTEXT_MAX_KEYS; i++) {
+      if (nodes >= CONTEXT_MAX_NODES) break;
+      const key = keys[i];
+      if (key === void 0) continue;
+      nodes++;
+      let child;
+      try {
+        child = walk(obj[key], depth + 1);
+      } catch {
+        child = void 0;
+      }
+      if (child !== void 0) out[key] = child;
+    }
+    return out;
+  };
+  let result;
+  try {
+    result = walk(value, 0);
+  } catch {
+    result = void 0;
+  }
+  return result && typeof result === "object" ? result : {};
+}
+async function readBodyBounded(request, maxBody) {
+  const body = request.body;
+  if (!body) {
+    const text = await request.text();
+    return byteLength(text) > maxBody ? { tooLarge: true } : { tooLarge: false, text };
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    total += value.byteLength;
+    if (total > maxBody) {
+      void Promise.resolve().then(() => reader.cancel()).catch(() => {
+      });
+      return { tooLarge: true };
+    }
+    chunks.push(value);
+  }
+  const buf = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    buf.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { tooLarge: false, text: new TextDecoder().decode(buf) };
+}
+function relayContext(raw, redactor) {
+  const bounded = boundContext(raw);
+  return Array.isArray(bounded) ? {} : { context: redactor(bounded) };
+}
+var defaultRelayRedactor = makeRedactor(true);
+function sanitizeBrowserPayload(raw, redactor = defaultRelayRedactor) {
   if (typeof raw !== "object" || raw === null) return null;
   const p = raw;
   if (p.version !== 1) return null;
@@ -53,16 +232,16 @@ function sanitizeBrowserPayload(raw) {
       type: e.type,
       timestamp: e.timestamp,
       ...typeof e.severity === "string" && SEVERITIES.has(e.severity) ? { severity: e.severity } : {},
-      message: typeof e.message === "string" ? e.message.slice(0, 4e3) : "",
-      ...typeof e.name === "string" ? { name: e.name.slice(0, 200) } : {},
+      message: typeof e.message === "string" ? redactor.text(e.message.slice(0, 4512)).slice(0, 4e3) : "",
+      ...typeof e.name === "string" ? { name: redactor.text(e.name.slice(0, 712)).slice(0, 200) } : {},
       ...typeof e.durationMs === "number" && Number.isFinite(e.durationMs) ? { durationMs: Math.max(0, Math.min(12e4, e.durationMs)) } : {},
-      ...typeof e.stack === "string" ? { stack: e.stack.slice(0, 32e3) } : {},
+      ...typeof e.stack === "string" ? { stack: redactor.text(e.stack.slice(0, 32512)).slice(0, 32e3) } : {},
       ...typeof e.errorType === "string" ? { errorType: e.errorType.slice(0, 200) } : {},
       ...typeof e.filename === "string" ? { filename: e.filename.split("?")[0].slice(0, 1e3) } : {},
       ...typeof e.line === "number" ? { line: e.line } : {},
       ...typeof e.column === "number" ? { column: e.column } : {},
       ...typeof e.route === "string" ? { route: e.route.split("?")[0].slice(0, 1e3) } : {},
-      ...typeof e.context === "object" && e.context !== null ? { context: e.context } : {}
+      ...typeof e.context === "object" && e.context !== null ? relayContext(e.context, redactor) : {}
     });
   }
   return {
@@ -71,11 +250,16 @@ function sanitizeBrowserPayload(raw) {
     service: p.service.slice(0, 200),
     environment: p.environment.slice(0, 100),
     ...typeof p.release === "string" ? { release: p.release.slice(0, 200) } : {},
+    // @autter/runtime-browser version, for the ingester's compat records.
+    ...typeof p.sdk === "string" && /^\d{1,6}\.\d{1,6}\.\d{1,6}[0-9A-Za-z.+-]{0,20}$/.test(p.sdk) ? { sdk: p.sdk } : {},
     events
   };
 }
 function forward(payload, opts) {
-  const url = `${(opts.endpoint ?? DEFAULT_ENDPOINT).replace(/\/$/, "")}/v1/browser`;
+  const endpoint = (opts.endpoint ?? DEFAULT_ENDPOINT).replace(/\/$/, "");
+  const url = `${endpoint}/v1/browser`;
+  const compat = opts.compatCheck !== false;
+  if (compat) ensureCompatConfigured(endpoint);
   void fetch(url, {
     method: "POST",
     headers: {
@@ -84,6 +268,14 @@ function forward(payload, opts) {
     },
     body: JSON.stringify(payload),
     signal: AbortSignal.timeout(1e4)
+  }).then((response) => {
+    if (!compat) return;
+    const types = new Set(
+      (payload.events ?? []).map((e) => String(e.type))
+    );
+    observeIngesterResponse({ status: response.status, headers: response.headers });
+    for (const feature of featuresForBrowserEvents(types)) noteCompatFeature(feature);
+    noteRelayRejection(types, response.status, response.headers);
   }).catch((err) => {
     (opts.onError ?? ((e) => console.warn("autter relay forward failed:", e)))(
       err
@@ -92,6 +284,7 @@ function forward(payload, opts) {
 }
 function createBrowserRelayFetchHandler(opts) {
   const maxBody = opts.maxBodyBytes ?? DEFAULT_MAX_BODY;
+  const redactor = opts.redact === void 0 || opts.redact === true ? defaultRelayRedactor : makeRedactor(opts.redact);
   const limiter = opts.perIpRateLimit === false ? null : new IpWindow(opts.perIpRateLimit ?? 120);
   return async (request) => {
     if (request.method !== "POST") {
@@ -105,21 +298,28 @@ function createBrowserRelayFetchHandler(opts) {
         });
       }
     }
-    const text = await request.text();
-    if (text.length > maxBody) {
+    let bounded;
+    try {
+      bounded = await readBodyBounded(request, maxBody);
+    } catch {
+      return new Response(JSON.stringify({ error: "invalid json" }), {
+        status: 400
+      });
+    }
+    if (bounded.tooLarge) {
       return new Response(JSON.stringify({ error: "payload too large" }), {
         status: 413
       });
     }
     let raw;
     try {
-      raw = JSON.parse(text);
+      raw = JSON.parse(bounded.text);
     } catch {
       return new Response(JSON.stringify({ error: "invalid json" }), {
         status: 400
       });
     }
-    const payload = sanitizeBrowserPayload(raw);
+    const payload = sanitizeBrowserPayload(raw, redactor);
     if (!payload) {
       return new Response(JSON.stringify({ error: "invalid payload" }), {
         status: 400
@@ -131,6 +331,7 @@ function createBrowserRelayFetchHandler(opts) {
 }
 function createBrowserRelayHandler(opts) {
   const maxBody = opts.maxBodyBytes ?? DEFAULT_MAX_BODY;
+  const redactor = opts.redact === void 0 || opts.redact === true ? defaultRelayRedactor : makeRedactor(opts.redact);
   const limiter = opts.perIpRateLimit === false ? null : new IpWindow(opts.perIpRateLimit ?? 120);
   function respond(res, status, body) {
     res.statusCode = status;
@@ -142,7 +343,7 @@ function createBrowserRelayHandler(opts) {
     }
   }
   function handleParsed(raw, res) {
-    const payload = sanitizeBrowserPayload(raw);
+    const payload = sanitizeBrowserPayload(raw, redactor);
     if (!payload) {
       respond(res, 400, { error: "invalid payload" });
       return;
@@ -206,8 +407,8 @@ function createBrowserRelayHandler(opts) {
 import { ServerResponse } from "http";
 import { randomUUID } from "crypto";
 import {
-  context,
-  trace,
+  context as context2,
+  trace as trace2,
   SpanKind,
   SpanStatusCode,
   TraceFlags
@@ -219,7 +420,7 @@ import {
 } from "@opentelemetry/exporter-metrics-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
-import { Resource } from "@opentelemetry/resources";
+import { Resource as Resource2 } from "@opentelemetry/resources";
 import { ExplicitBucketHistogramAggregation, PeriodicExportingMetricReader, View } from "@opentelemetry/sdk-metrics";
 import { NodeSDK } from "@opentelemetry/sdk-node";
 import {
@@ -235,50 +436,83 @@ import {
   ATTR_SERVICE_VERSION
 } from "@opentelemetry/semantic-conventions";
 
-// src/lifecycle.ts
+// src/redact-exporter.ts
 import { ExportResultCode } from "@opentelemetry/core";
-var debugEnabled = process.env.AUTTER_DEBUG === "1" || process.env.AUTTER_DEBUG === "true";
-function setDebugMode(enabled) {
-  debugEnabled = enabled;
-}
-function isDebugEnabled() {
-  return debugEnabled;
+import { Resource } from "@opentelemetry/resources";
+import {
+  AggregationTemporality
+} from "@opentelemetry/sdk-metrics";
+var scrubbedResources = /* @__PURE__ */ new WeakMap();
+function redactResource(resource, redactor) {
+  const cached = scrubbedResources.get(resource);
+  if (cached) return cached;
+  const scrubbed = new Resource(redactor.exported(resource.attributes));
+  scrubbedResources.set(resource, scrubbed);
+  return scrubbed;
 }
-function debugLog(...args) {
-  if (debugEnabled) {
-    console.error("[autter]", ...args);
-  }
+function redactSpan(span, redactor) {
+  const status = span.status.message ? { ...span.status, message: redactor.text(span.status.message) } : span.status;
+  return {
+    name: redactor.text(span.name),
+    kind: span.kind,
+    spanContext: () => span.spanContext(),
+    parentSpanId: span.parentSpanId,
+    startTime: span.startTime,
+    endTime: span.endTime,
+    status,
+    attributes: redactor.exported(span.attributes),
+    links: span.links.map(
+      (link) => link.attributes ? { ...link, attributes: redactor.exported(link.attributes) } : link
+    ),
+    events: span.events.map((event) => ({
+      ...event,
+      name: redactor.text(event.name),
+      ...event.attributes ? { attributes: redactor.exported(event.attributes) } : {}
+    })),
+    duration: span.duration,
+    ended: span.ended,
+    resource: redactResource(span.resource, redactor),
+    instrumentationLibrary: span.instrumentationLibrary,
+    droppedAttributesCount: span.droppedAttributesCount,
+    droppedEventsCount: span.droppedEventsCount,
+    droppedLinksCount: span.droppedLinksCount
+  };
 }
-var TelemetryStats = class {
-  /** Captures queued via our APIs and not yet seen leaving an exporter. */
-  pendingCaptures = 0;
-  markCaptured(count = 1) {
-    this.pendingCaptures += count;
-  }
-  /** An exporter batch left the process successfully. */
-  onExported(spanCount) {
-    this.pendingCaptures = Math.max(0, this.pendingCaptures - spanCount);
-    if (debugEnabled && spanCount > 0) {
-      debugLog(`exported ${spanCount} span${spanCount === 1 ? "" : "s"}`);
-    }
-  }
-  markAllFlushed() {
-    this.pendingCaptures = 0;
-  }
-};
-var telemetryStats = new TelemetryStats();
-var CountingExporter = class {
-  constructor(inner) {
+var RedactingSpanExporter = class {
+  constructor(inner, redactor) {
     this.inner = inner;
+    this.redactor = redactor;
   }
   inner;
+  redactor;
   export(spans, resultCallback) {
-    this.inner.export(spans, (result) => {
-      if (result.code === ExportResultCode.SUCCESS) {
-        telemetryStats.onExported(spans.length);
+    const redactor = this.redactor();
+    let scrubbed = spans;
+    let failed = 0;
+    if (redactor.enabled) {
+      scrubbed = [];
+      for (const span of spans) {
+        try {
+          scrubbed.push(redactSpan(span, redactor));
+        } catch {
+          failed++;
+        }
       }
-      resultCallback(result);
-    });
+    }
+    if (!failed) {
+      this.inner.export(scrubbed, resultCallback);
+      return;
+    }
+    const error = new Error(`autter-runtime: ${failed} span(s) could not be redacted and were not exported`);
+    const fail = () => resultCallback({ code: ExportResultCode.FAILED, error });
+    if (!scrubbed.length) {
+      fail();
+      return;
+    }
+    this.inner.export(
+      scrubbed,
+      (result) => result.code === ExportResultCode.SUCCESS ? fail() : resultCallback(result)
+    );
   }
   shutdown() {
     return this.inner.shutdown();
@@ -287,394 +521,38 @@ var CountingExporter = class {
     return this.inner.forceFlush?.() ?? Promise.resolve();
   }
 };
-var flushTargets = /* @__PURE__ */ new Map();
-function registerFlushTarget(key, target) {
-  flushTargets.set(key, target);
-}
-function unregisterFlushTargets() {
-  flushTargets.clear();
-}
-function activeFlushTargets() {
-  return [...flushTargets.values()];
-}
-var DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
-var SIGNAL_EXIT_CODES = {
-  SIGINT: 130,
-  SIGTERM: 143
-};
-function installAutterAutoFlush(options = {}) {
-  const logger = options.logger ?? console;
-  const log = options.log !== false;
-  const warnOnUnflushedExit = options.warnOnUnflushedExit !== false;
-  const timeoutMs = Math.max(100, options.timeoutMs ?? 3e3);
-  const signals = options.signals ?? DEFAULT_SIGNALS;
-  const flushOnUncaughtException = options.flushOnUncaughtException !== false;
-  let disposed = false;
-  let inFlight = null;
-  const doFlush = async () => {
-    const targets = options.targets ?? activeFlushTargets();
-    if (targets.length === 0) return true;
-    let timer;
-    const timedOut = new Promise((resolve) => {
-      timer = setTimeout(() => resolve(false), timeoutMs);
-    });
-    const drained = Promise.allSettled(
-      targets.map(
-        (target) => Promise.resolve().then(() => target.forceFlush())
-      )
-    ).then(
-      (results) => results.every((result) => result.status === "fulfilled")
-    );
-    let ok;
-    try {
-      ok = await Promise.race([drained, timedOut]);
-    } finally {
-      clearTimeout(timer);
-    }
-    if (ok) {
-      telemetryStats.markAllFlushed();
-      if (log) {
-        logger.log("[autter] telemetry flushed");
-      }
-    } else {
-      logger.error(
-        `[autter] flush did not finish within ${timeoutMs}ms \u2014 some telemetry may be lost`
-      );
-    }
-    return ok;
-  };
-  const flush = (reason = "exit") => {
-    if (disposed) return Promise.resolve(false);
-    if (!inFlight) {
-      inFlight = doFlush().finally(() => {
-        inFlight = null;
-      });
-    }
-    if (isDebugEnabled()) debugLog(`auto-flush requested on ${reason}`);
-    return inFlight;
-  };
-  const signalCounts = /* @__PURE__ */ new Map();
-  let handlingUncaughtException = false;
-  const onUncaughtException = (error) => {
-    if (process.listenerCount("uncaughtException") > 1) return;
-    if (handlingUncaughtException) return;
-    handlingUncaughtException = true;
-    logger.error(error instanceof Error ? error.stack ?? error.message : String(error));
-    const keepAlive = setTimeout(() => {
-    }, timeoutMs + 50);
-    void flush("uncaughtException").finally(() => {
-      clearTimeout(keepAlive);
-      process.exit(1);
-    });
-  };
-  const onSignal = (signal) => {
-    const count = (signalCounts.get(signal) ?? 0) + 1;
-    signalCounts.set(signal, count);
-    const exitCode = SIGNAL_EXIT_CODES[signal] ?? 1;
-    if (count > 1) {
-      process.exit(exitCode);
-    }
-    const otherHandlers = process.listenerCount(signal) - 1;
-    if (otherHandlers > 0) {
-      void flush(signal);
-      return;
-    }
-    void flush(signal).finally(() => {
-      process.exit(exitCode);
-    });
-  };
-  const MAX_BEFORE_EXIT_FLUSHES = 10;
-  let beforeExitFlushes = 0;
-  const onBeforeExit = () => {
-    if (disposed) return;
-    const targets = options.targets ?? activeFlushTargets();
-    const worthIt = beforeExitFlushes === 0 ? targets.length > 0 : telemetryStats.pendingCaptures > 0;
-    if (!worthIt || beforeExitFlushes >= MAX_BEFORE_EXIT_FLUSHES) return;
-    beforeExitFlushes++;
-    const keepAlive = setTimeout(() => {
-    }, timeoutMs);
-    void flush("beforeExit").finally(() => clearTimeout(keepAlive));
-  };
-  const onExit = () => {
-    if (!warnOnUnflushedExit || disposed) return;
-    const pending = telemetryStats.pendingCaptures;
-    if (pending > 0) {
-      logger.error(
-        `[autter] process exiting with ~${pending} captured item(s) never confirmed exported \u2014 await autter.shutdown() on graceful shutdown`
-      );
-    }
-  };
-  const signalHandlers = /* @__PURE__ */ new Map();
-  process.on("beforeExit", onBeforeExit);
-  if (flushOnUncaughtException) {
-    process.on("uncaughtException", onUncaughtException);
-  }
-  for (const signal of signals) {
-    const handler = () => onSignal(signal);
-    signalHandlers.set(signal, handler);
-    process.on(signal, handler);
-  }
-  process.on("exit", onExit);
-  return {
-    flush,
-    dispose() {
-      disposed = true;
-      process.removeListener("beforeExit", onBeforeExit);
-      process.removeListener("uncaughtException", onUncaughtException);
-      process.removeListener("exit", onExit);
-      for (const [signal, handler] of signalHandlers) {
-        process.removeListener(signal, handler);
-      }
-      signalHandlers.clear();
-    }
-  };
-}
-
-// src/redact.ts
-var SENSITIVE_KEY_PATTERNS = [
-  /e-?mail/,
-  /pass(word|wd|phrase)|^pass$/,
-  /token/,
-  /secret/,
-  /credential/,
-  /(api|access|secret|private|consumer|client|signing|encryption)-?[_.]?key/,
-  /^-?x?-?authorization$|^auth(-|_|$)|bearer/,
-  /cookie/,
-  /phone|msisdn/,
-  /\bssn\b|social[-_ ]?security/,
-  /cvv|cvc|card([-_. ]?(number|num|no))?$/,
-  /credit[-_.]?card/,
-  /connection[-_.]?string/,
-  /recovery[-_.]?code|\botp\b|magic[-_.]?link/
-];
-var PRIVATE_KEY_BLOCK_RE = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g;
-var EMAIL_VALUE_RE = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
-var JWT_RE = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g;
-var OPENAI_KEY_RE = /\bsk-[A-Za-z0-9]{20,}\b/g;
-var GITHUB_TOKEN_RE = /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g;
-var AWS_KEY_RE = /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g;
-var SLACK_TOKEN_RE = /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g;
-var BEARER_RE = /\bbearer\s+[A-Za-z0-9._~+/=-]{10,}/gi;
-var URL_CREDENTIALS_RE = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/:@]+:[^\s/@]+@/gi;
-function toCaseInsensitive(pattern) {
-  return typeof pattern === "string" ? new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i") : new RegExp(pattern.source, pattern.flags.includes("i") ? pattern.flags : `${pattern.flags}i`);
-}
-function compile(options) {
-  const keyPatterns = [...SENSITIVE_KEY_PATTERNS];
-  const valuePatterns = [
-    JWT_RE,
-    OPENAI_KEY_RE,
-    GITHUB_TOKEN_RE,
-    AWS_KEY_RE,
-    SLACK_TOKEN_RE,
-    BEARER_RE
-  ];
-  if (options?.additionalKeyPatterns) {
-    for (const p of options.additionalKeyPatterns) {
-      keyPatterns.push(toCaseInsensitive(p));
-    }
+var RedactingMetricExporter = class {
+  constructor(inner, redactor) {
+    this.inner = inner;
+    this.redactor = redactor;
   }
-  if (options?.additionalValuePatterns) {
-    for (const p of options.additionalValuePatterns) {
-      if (!valuePatterns.some((existing) => existing.source === (typeof p === "string" ? p : p.source))) {
-        valuePatterns.push(typeof p === "string" ? new RegExp(p, "gi") : p);
-      }
+  inner;
+  redactor;
+  export(metrics2, resultCallback) {
+    const redactor = this.redactor();
+    if (!redactor.enabled) {
+      this.inner.export(metrics2, resultCallback);
+      return;
     }
-  }
-  return {
-    keyPatterns,
-    valuePatterns,
-    urlCredentials: URL_CREDENTIALS_RE,
-    privateKeyBlock: PRIVATE_KEY_BLOCK_RE,
-    mask: options?.mask ?? "[redacted]",
-    scrubEmailValues: options?.scrubEmailValues !== false
-  };
-}
-function redactString(value, r) {
-  let out = value.replace(r.privateKeyBlock, r.mask);
-  for (const re of r.valuePatterns) {
-    out = out.replace(re, r.mask);
-  }
-  out = out.replace(r.urlCredentials, "$1" + r.mask + "@");
-  if (r.scrubEmailValues) {
-    out = out.replace(EMAIL_VALUE_RE, r.mask);
-  }
-  return out;
-}
-var MAX_REDACTION_DEPTH = 64;
-var MAX_REDACTION_WORK = 1e4;
-var MAX_COLLECTION_ENTRIES = 1e3;
-function canTraverse(depth, state) {
-  if (depth > MAX_REDACTION_DEPTH || state.remainingWork <= 0) return false;
-  state.remainingWork -= 1;
-  return true;
-}
-function redactValue(value, r, state, depth) {
-  if (typeof value === "string") return redactString(value, r);
-  let isArray = false;
-  try {
-    isArray = Array.isArray(value);
-  } catch {
-    return r.mask;
-  }
-  if (isArray) {
-    return redactArray(value, r, state, depth);
-  }
-  if (typeof value === "object" && value !== null) {
-    return redactObject(value, r, state, depth);
-  }
-  return value;
-}
-function redactArray(value, r, state, depth) {
-  const existing = state.ancestors.get(value);
-  if (existing) return r.mask;
-  if (!canTraverse(depth, state)) return r.mask;
-  const out = [];
-  state.ancestors.set(value, out);
-  let length;
-  try {
-    length = value.length;
-  } catch {
-    state.ancestors.delete(value);
-    return r.mask;
-  }
-  const limit = Math.min(length, MAX_COLLECTION_ENTRIES);
-  for (let i = 0; i < limit; i += 1) {
-    let item;
+    let resource;
     try {
-      item = value[i];
-    } catch {
-      out.push(r.mask);
-      continue;
-    }
-    out.push(redactValue(item, r, state, depth + 1));
-  }
-  if (length > limit) {
-    out.push(r.mask);
-  }
-  state.ancestors.delete(value);
-  return out;
-}
-function redactObject(value, r, state, depth) {
-  const existing = state.ancestors.get(value);
-  if (existing) return r.mask;
-  if (!canTraverse(depth, state)) return r.mask;
-  const out = {};
-  state.ancestors.set(value, out);
-  let count = 0;
-  let truncated = false;
-  try {
-    for (const key in value) {
-      if (!Object.prototype.propertyIsEnumerable.call(
-        value,
-        key
-      )) {
-        continue;
-      }
-      if (count >= MAX_COLLECTION_ENTRIES) {
-        truncated = true;
-        break;
-      }
-      let nestedValue;
-      try {
-        nestedValue = value[key];
-      } catch {
-        out[key] = r.mask;
-        count += 1;
-        continue;
-      }
-      count += 1;
-      out[key] = isSensitiveKey(key, nestedValue, r) ? r.mask : redactValue(
-        nestedValue,
-        r,
-        state,
-        depth + 1
-      );
-    }
-  } catch {
-    truncated = true;
-  }
-  if (truncated) {
-    out.__redaction_truncated__ = r.mask;
-  }
-  state.ancestors.delete(value);
-  return out;
-}
-var USAGE_TOKEN_KEYS = /* @__PURE__ */ new Set([
-  "input_tokens",
-  "output_tokens",
-  "prompt_tokens",
-  "completion_tokens",
-  "total_tokens",
-  "token_count",
-  "gen_ai.usage.input_tokens",
-  "gen_ai.usage.output_tokens",
-  "gen_ai.usage.prompt_tokens",
-  "gen_ai.usage.completion_tokens",
-  "gen_ai.usage.total_tokens",
-  "gen_ai.usage.token_count"
-]);
-function isSensitiveKey(key, value, r) {
-  const lowered = key.toLowerCase();
-  if (USAGE_TOKEN_KEYS.has(lowered)) {
-    return !(typeof value === "number" && Number.isFinite(value) && value >= 0);
-  }
-  return r.keyPatterns.some((re) => re.test(lowered));
-}
-function redactAttributes(attributes, options) {
-  const r = compile(options);
-  return redactWith(attributes, r);
-}
-function redactWith(attributes, r) {
-  const out = {};
-  if (!attributes) return out;
-  const state = {
-    ancestors: /* @__PURE__ */ new WeakMap(),
-    remainingWork: MAX_REDACTION_WORK
-  };
-  let count = 0;
-  let truncated = false;
-  try {
-    for (const key in attributes) {
-      if (!Object.prototype.propertyIsEnumerable.call(
-        attributes,
-        key
-      )) {
-        continue;
-      }
-      if (count >= MAX_COLLECTION_ENTRIES || state.remainingWork <= 0) {
-        truncated = true;
-        break;
-      }
-      let value;
-      try {
-        value = attributes[key];
-      } catch {
-        out[key] = r.mask;
-        count += 1;
-        state.remainingWork -= 1;
-        continue;
-      }
-      count += 1;
-      state.remainingWork -= 1;
-      if (value === void 0) continue;
-      out[key] = isSensitiveKey(key, value, r) ? r.mask : redactValue(value, r, state, 0);
+      resource = redactResource(metrics2.resource, redactor);
+    } catch (error) {
+      resultCallback({ code: ExportResultCode.FAILED, error });
+      return;
     }
-  } catch {
-    truncated = true;
+    this.inner.export({ ...metrics2, resource }, resultCallback);
   }
-  if (truncated) {
-    out.__redaction_truncated__ = r.mask;
+  forceFlush() {
+    return this.inner.forceFlush();
   }
-  return out;
-}
-function makeRedactor(options) {
-  if (options === false) {
-    return (attributes) => ({ ...attributes ?? {} });
+  shutdown() {
+    return this.inner.shutdown();
   }
-  const r = compile(options === true ? void 0 : options);
-  return (attributes) => redactWith(attributes, r);
-}
+  selectAggregationTemporality(instrumentType) {
+    return this.inner.selectAggregationTemporality ? this.inner.selectAggregationTemporality(instrumentType) : AggregationTemporality.CUMULATIVE;
+  }
+};
 
 // src/memory.ts
 import { PerformanceObserver } from "perf_hooks";
@@ -721,6 +599,383 @@ function startMemoryMetrics() {
   };
 }
 
+// src/requests.ts
+import { AsyncResource } from "async_hooks";
+import { context, trace } from "@opentelemetry/api";
+var REQUEST_STATE = /* @__PURE__ */ Symbol.for("autter.runtime.request");
+var BOUND = /* @__PURE__ */ Symbol.for("autter.runtime.bound");
+var CAPTURED = /* @__PURE__ */ new WeakSet();
+var capturer = () => {
+};
+function setRequestExceptionCapturer(fn) {
+  capturer = fn;
+}
+function markCaptured(error) {
+  if (error && typeof error === "object") CAPTURED.add(error);
+}
+function expressRouteOf(req) {
+  const props = req;
+  const path = props?.route?.path;
+  if (typeof path !== "string" || path === "") return null;
+  const base = typeof props?.baseUrl === "string" ? props.baseUrl : "";
+  const route = base + path;
+  return route.startsWith("/") ? route : null;
+}
+function defaultShouldCapture(error) {
+  return error instanceof RuntimeError || errorCodeOf(error) !== void 0 || responseStatusOf(error) >= 500;
+}
+function captureAtBoundary(error, state, rule = void 0) {
+  const wanted = typeof rule === "function" ? rule(error) : rule === void 0 ? defaultShouldCapture(error) : rule;
+  if (!wanted) return;
+  if (error && typeof error === "object" && CAPTURED.has(error)) return;
+  markCaptured(error);
+  try {
+    if (state && !state.sealed) local.run(state, () => capturer(error));
+    else capturer(error);
+  } catch {
+  }
+}
+function bindEmitter(emitter, state) {
+  const target = emitter;
+  if (!target || typeof target !== "object" || target[BOUND]) return;
+  target[BOUND] = true;
+  const wrappers = /* @__PURE__ */ new WeakMap();
+  const wrap = (listener) => {
+    if (typeof listener !== "function") return listener;
+    let wrapped = wrappers.get(listener);
+    if (!wrapped) {
+      wrapped = function(...args) {
+        return local.run(
+          state,
+          () => listener.apply(this, args)
+        );
+      };
+      wrappers.set(listener, wrapped);
+    }
+    return wrapped;
+  };
+  for (const method of [
+    "on",
+    "addListener",
+    "prependListener",
+    "once",
+    "prependOnceListener"
+  ]) {
+    const original = target[method];
+    if (typeof original !== "function") continue;
+    target[method] = function(event, listener) {
+      return original.call(this, event, wrap(listener));
+    };
+  }
+  for (const method of ["removeListener", "off"]) {
+    const original = target[method];
+    if (typeof original !== "function") continue;
+    target[method] = function(event, listener) {
+      const wrapped = typeof listener === "function" ? wrappers.get(listener) ?? listener : listener;
+      return original.call(this, event, wrapped);
+    };
+  }
+}
+function exposeHeaderValue(current, header) {
+  const text = Array.isArray(current) ? current.join(", ") : String(current ?? "");
+  const names = text.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+  if (names.includes("*") || names.includes(header)) return null;
+  return names.length ? `${text}, ${header}` : header;
+}
+function exposeOnCors(res, header) {
+  const original = res.writeHead;
+  res.writeHead = function(...args) {
+    try {
+      const inline = args.slice(1).find(
+        (arg) => !!arg && typeof arg === "object" && !Array.isArray(arg)
+      );
+      const inlineKey = (name) => inline ? Object.keys(inline).find((key) => key.toLowerCase() === name) : void 0;
+      const cors = res.getHeader("access-control-allow-origin") !== void 0 || inlineKey("access-control-allow-origin") !== void 0;
+      if (cors) {
+        const key = inlineKey("access-control-expose-headers");
+        const value = exposeHeaderValue(
+          key && inline ? inline[key] : res.getHeader("access-control-expose-headers"),
+          header
+        );
+        if (value && key && inline) inline[key] = value;
+        else if (value) res.setHeader("access-control-expose-headers", value);
+      }
+    } catch {
+    }
+    return original.apply(this, args);
+  };
+}
+function pathOf(req) {
+  const raw = req.originalUrl ?? req.url ?? "/";
+  return raw.split(/[?#]/)[0] || "/";
+}
+function finishRequest(state, input) {
+  if (state.sealed) return;
+  state.name = (input.name ?? `${input.method} ${input.route}`).slice(0, 200);
+  state.outcome = requestOutcome({
+    ...state.explicitOutcome ? { explicit: state.outcome } : {},
+    ...state.error !== void 0 ? { error: state.error } : {},
+    ...state.errorThrown ? { thrown: true } : {},
+    status: input.status,
+    aborted: input.aborted
+  });
+  const span = trace.getActiveSpan();
+  if (span?.isRecording()) span.setAttribute("autter.operation.outcome", state.outcome);
+  if (input.span) {
+    const remote = trace.wrapSpanContext(input.span);
+    context.with(
+      trace.setSpan(context.active(), remote),
+      () => reportExplicitFailure(state)
+    );
+  } else reportExplicitFailure(state);
+  emitSummary(state, {
+    http: {
+      "http.request.method": input.method,
+      "http.route": input.route,
+      "http.response.status_code": input.status,
+      "autter.request.aborted": input.aborted
+    },
+    ...input.span ? { span: input.span } : {}
+  });
+}
+function beginNodeRequest(req, res, options, route) {
+  const header = (options.requestIdHeader ?? DEFAULT_REQUEST_ID_HEADER).toLowerCase();
+  const requestId = resolveRequestId(
+    options.trustRequestId === false ? void 0 : req.headers[header]
+  );
+  const method = (req.method ?? "GET").toUpperCase();
+  const path = pathOf(req);
+  const state = createRequestState({
+    name: `${method} ${normalizeRoutePath(path)}`,
+    requestId,
+    req,
+    res
+  });
+  req[REQUEST_STATE] = state;
+  try {
+    if (!res.headersSent) res.setHeader(header, requestId);
+    exposeOnCors(res, header);
+  } catch {
+  }
+  const span = trace.getActiveSpan();
+  if (span?.isRecording())
+    span.setAttributes({
+      "autter.request.id": requestId,
+      "autter.operation.kind": "request"
+    });
+  const spanContext = span?.spanContext();
+  bindEmitter(req, state);
+  bindEmitter(res, state);
+  let finished = false;
+  const done = () => {
+    finishRequest(state, {
+      method,
+      route: route?.() ?? expressRouteOf(req) ?? normalizeRoutePath(path),
+      status: res.statusCode,
+      aborted: !finished,
+      ...spanContext ? { span: spanContext } : {}
+    });
+  };
+  res.once("finish", () => {
+    finished = true;
+    done();
+  });
+  res.once("close", done);
+  return state;
+}
+function autterRequests(options = {}) {
+  const ignored = compileIgnore(options.ignore);
+  return function autterRequestsMiddleware(req, res, next) {
+    if (req[REQUEST_STATE] || ignored(pathOf(req))) {
+      next();
+      return;
+    }
+    const state = beginNodeRequest(req, res, options);
+    local.run(state, () => next());
+  };
+}
+function autterErrorResponse(options = {}) {
+  return function autterErrorResponseMiddleware(error, req, res, next) {
+    const state = req[REQUEST_STATE];
+    if (state) noteOperationError(error, true, state);
+    captureAtBoundary(error, state, options.capture);
+    if (res.headersSent) {
+      next(error);
+      return;
+    }
+    const header = (options.requestIdHeader ?? DEFAULT_REQUEST_ID_HEADER).toLowerCase();
+    const inbound = req.headers?.[header];
+    const requestId = state?.requestId ?? (typeof inbound === "string" ? inbound.slice(0, 128) : void 0);
+    res.statusCode = responseStatusOf(error);
+    res.setHeader("content-type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(toClientError(error, requestId)));
+  };
+}
+var RESOURCE = /* @__PURE__ */ Symbol.for("autter.runtime.resource");
+function autterFastify(fastify, options, done) {
+  const opts = options ?? {};
+  const header = (opts.requestIdHeader ?? DEFAULT_REQUEST_ID_HEADER).toLowerCase();
+  const ignored = compileIgnore(opts.ignore);
+  const stateOf = (request) => request[REQUEST_STATE];
+  fastify.addHook("onRequest", ((request, reply, next) => {
+    if (ignored(request.url) || request.raw[REQUEST_STATE]) {
+      next();
+      return;
+    }
+    const requestId = resolveRequestId(
+      opts.trustRequestId === false ? void 0 : request.headers[header]
+    );
+    const method = String(request.method ?? "GET").toUpperCase();
+    const state = createRequestState({
+      name: `${method} ${normalizeRoutePath(request.url)}`,
+      requestId,
+      req: request.raw,
+      res: reply.raw
+    });
+    request[REQUEST_STATE] = state;
+    request.raw[REQUEST_STATE] = state;
+    reply.header(header, requestId);
+    const span = trace.getActiveSpan();
+    if (span?.isRecording())
+      span.setAttributes({
+        "autter.request.id": requestId,
+        "autter.operation.kind": "request"
+      });
+    const spanContext = span?.spanContext();
+    bindEmitter(request.raw, state);
+    bindEmitter(reply.raw, state);
+    let finished = false;
+    const finish = (aborted) => finishRequest(state, {
+      method,
+      route: request.routeOptions?.url ?? request.routerPath ?? normalizeRoutePath(request.url),
+      status: reply.raw.statusCode || reply.statusCode,
+      aborted,
+      ...spanContext ? { span: spanContext } : {}
+    });
+    reply.raw.once("finish", () => {
+      finished = true;
+      finish(false);
+    });
+    reply.raw.once("close", () => finish(!finished));
+    local.run(state, () => {
+      request[RESOURCE] = new AsyncResource("autter-request");
+      next();
+    });
+  }));
+  fastify.addHook("preHandler", ((request, _reply, next) => {
+    const resource = request[RESOURCE];
+    if (resource) resource.runInAsyncScope(() => next());
+    else next();
+  }));
+  fastify.addHook("onSend", ((request, reply, payload, next) => {
+    try {
+      if (stateOf(request) && reply.getHeader("access-control-allow-origin") !== void 0) {
+        const value = exposeHeaderValue(reply.getHeader("access-control-expose-headers"), header);
+        if (value) reply.header("access-control-expose-headers", value);
+      }
+    } catch {
+    }
+    next(null, payload);
+  }));
+  fastify.addHook("onError", ((request, _reply, error, next) => {
+    const state = stateOf(request);
+    if (state) noteOperationError(error, true, state);
+    captureAtBoundary(error, state);
+    next();
+  }));
+  done();
+}
+autterFastify[/* @__PURE__ */ Symbol.for("skip-override")] = true;
+autterFastify[/* @__PURE__ */ Symbol.for("fastify.display-name")] = "autter-runtime";
+function withHeaders(response, header, requestId) {
+  const apply = (target) => {
+    target.headers.set(header, requestId);
+    if (target.headers.get("access-control-allow-origin") !== null) {
+      const value = exposeHeaderValue(
+        target.headers.get("access-control-expose-headers") ?? "",
+        header
+      );
+      if (value) target.headers.set("access-control-expose-headers", value);
+    }
+    return target;
+  };
+  try {
+    return apply(response);
+  } catch {
+    try {
+      return apply(new Response(response.body, response));
+    } catch {
+      return response;
+    }
+  }
+}
+function withRuntimeRequest(handler, options = {}) {
+  const header = (options.requestIdHeader ?? DEFAULT_REQUEST_ID_HEADER).toLowerCase();
+  const ignored = compileIgnore(options.ignore);
+  return async (request, ...rest) => {
+    let pathname = "/";
+    try {
+      pathname = new URL(request.url, "http://localhost").pathname;
+    } catch {
+    }
+    if (ignored(pathname)) return handler(request, ...rest);
+    const requestId = resolveRequestId(
+      options.trustRequestId === false ? void 0 : request.headers.get(header)
+    );
+    const method = String(request.method ?? "GET").toUpperCase();
+    const route = options.route ?? normalizeRoutePath(pathname);
+    const state = createRequestState({
+      name: `${method} ${options.name ?? route}`,
+      requestId,
+      req: request
+    });
+    const span = trace.getActiveSpan();
+    if (span?.isRecording())
+      span.setAttributes({
+        "autter.request.id": requestId,
+        "autter.operation.kind": "request"
+      });
+    const spanContext = span?.spanContext();
+    let status = 500;
+    try {
+      const response = await local.run(state, async () => {
+        try {
+          return await handler(request, ...rest);
+        } catch (error) {
+          noteOperationError(error, true, state);
+          captureAtBoundary(error, state, true);
+          throw error;
+        }
+      });
+      status = response.status;
+      return withHeaders(response, header, requestId);
+    } finally {
+      const aborted = request.signal?.aborted === true;
+      finishRequest(state, {
+        method,
+        route,
+        name: `${method} ${options.name ?? route}`,
+        status,
+        aborted,
+        ...spanContext ? { span: spanContext } : {}
+      });
+      if (options.waitUntil) {
+        try {
+          options.waitUntil(flushRuntimeLogs().catch(() => {
+          }));
+        } catch {
+        }
+      }
+    }
+  };
+}
+function startHookRequest(res) {
+  const req = res.req;
+  if (!req || req[REQUEST_STATE]) return;
+  const state = beginNodeRequest(req, res, {});
+  local.enterWith(state);
+}
+
 // src/server.ts
 var LLM_MARKER_ATTRIBUTES = [
   "gen_ai.operation.name",
@@ -849,7 +1104,7 @@ var ErrorTraceRetentionProcessor = class {
   }
   /** Promote the active trace, if any — called on captured errors. */
   retainActiveTrace() {
-    const active2 = trace.getActiveSpan()?.spanContext();
+    const active2 = trace2.getActiveSpan()?.spanContext();
     if (!active2 || (active2.traceFlags & TraceFlags.SAMPLED) !== 0) return;
     const entry = this.entryFor(active2.traceId);
     if (entry.retained) return;
@@ -942,36 +1197,43 @@ async function runLlmSpan(tracer, info, fn) {
     kind: SpanKind.CLIENT,
     attributes: llmBaseAttributes(info)
   });
-  const setResponseModel = (model) => span.setAttribute("gen_ai.response.model", model);
+  const usage = {};
+  let responseModel;
+  const setResponseModel = (model) => {
+    responseModel = model;
+    span.setAttribute("gen_ai.response.model", model);
+  };
   const handle = {
-    setUsage: (usage) => span.setAttributes(usageAttributes(usage)),
-    setCost: (usd) => span.setAttribute("autter.llm.cost_usd", usd),
+    setUsage: (next) => {
+      Object.assign(usage, next);
+      span.setAttributes(usageAttributes(next));
+    },
+    setCost: (usd) => {
+      usage.costUsd = usd;
+      span.setAttribute("autter.llm.cost_usd", usd);
+    },
     setResponseModel,
     setModel: setResponseModel,
-    setAttributes: (attributes) => span.setAttributes(attributes)
+    setAttributes: (attributes) => span.setAttributes(activeRedactor(attributes))
   };
   try {
-    const result = await context.with(
-      trace.setSpan(context.active(), span),
+    const result = await context2.with(
+      trace2.setSpan(context2.active(), span),
       () => fn(handle)
     );
     span.setStatus({ code: SpanStatusCode.OK });
     return result;
   } catch (err) {
-    if (err instanceof Error) {
-      span.recordException(err);
-      span.setAttribute("error.type", err.name);
-    }
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: err instanceof Error ? err.message : String(err)
-    });
+    recordError(span, err);
+    if (err instanceof Error) span.setAttribute("error.type", err.name);
     throw err;
   } finally {
     span.end();
+    recordOperationAiUsage({ ...usage, model: responseModel ?? info.model });
   }
 }
 function recordLlmCall(tracer, call) {
+  recordOperationAiUsage({ ...call, model: call.model });
   const durationMs = Math.max(0, call.durationMs ?? 0);
   const endTime = /* @__PURE__ */ new Date();
   const startTime = new Date(endTime.getTime() - durationMs);
@@ -984,50 +1246,52 @@ function recordLlmCall(tracer, call) {
     }
   );
   if (call.error !== void 0 && call.error !== null) {
+    recordError(span, call.error);
     if (call.error instanceof Error) {
-      span.recordException(call.error);
       span.setAttribute("error.type", call.error.name);
     }
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: call.error instanceof Error ? call.error.message : String(call.error)
-    });
   } else {
     span.setStatus({ code: SpanStatusCode.OK });
   }
   span.end(endTime);
 }
-async function runWithSpan(tracer, name, fn, attributes) {
-  const span = tracer.startSpan(name, { attributes });
+async function runWithSpan(tracer, name, fn, attributes, links) {
+  const span = tracer.startSpan(name, {
+    attributes,
+    ...links?.length ? { links } : {}
+  });
   try {
-    const result = await context.with(
-      trace.setSpan(context.active(), span),
+    const result = await context2.with(
+      trace2.setSpan(context2.active(), span),
       fn
     );
     span.setStatus({ code: SpanStatusCode.OK });
     return result;
   } catch (err) {
-    if (err instanceof Error) span.recordException(err);
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: err instanceof Error ? err.message : String(err)
-    });
+    recordError(span, err);
     throw err;
   } finally {
     span.end();
   }
 }
-function expressRouteOf(req) {
-  const props = req;
-  const path = props?.route?.path;
-  if (typeof path !== "string" || path === "") return null;
-  const base = typeof props?.baseUrl === "string" ? props.baseUrl : "";
-  const route = base + path;
-  return route.startsWith("/") ? route : null;
+function recordError(span, err) {
+  const isError = err instanceof Error;
+  const message = activeRedactor.text(isError ? err.message : String(err));
+  if (isError) {
+    span.addEvent("exception", {
+      "exception.type": err.name,
+      "exception.message": message,
+      ...err.stack ? { "exception.stacktrace": activeRedactor.text(err.stack) } : {}
+    });
+  }
+  span.setStatus({ code: SpanStatusCode.ERROR, message });
+}
+function redactWithActive(attributes) {
+  return activeRedactor(attributes);
 }
 function captureExpressRoute(_span, response) {
   if (!(response instanceof ServerResponse)) return;
-  const rpcMetadata = getRPCMetadata(context.active());
+  const rpcMetadata = getRPCMetadata(context2.active());
   if (rpcMetadata?.type !== RPCType.HTTP) return;
   const setRoute = () => {
     if (rpcMetadata.route) return;
@@ -1036,6 +1300,21 @@ function captureExpressRoute(_span, response) {
   };
   response.prependListener("finish", setRoute);
   response.prependListener("close", setRoute);
+  if (hookRequests) startHookRequest(response);
+}
+var hookRequests = false;
+function structuredErrorAttributes(error) {
+  const attrs = { ...errorAttributes(error, { causes: false }) };
+  const internal = errorInternal(error);
+  if (internal) {
+    try {
+      attrs["autter.error.internal"] = JSON.stringify(
+        activeRedactor(internal)
+      ).slice(0, 4e3);
+    } catch {
+    }
+  }
+  return attrs;
 }
 var active = null;
 var activeAlwaysOnProvider = null;
@@ -1047,15 +1326,27 @@ function initAutterServer(options) {
     ""
   );
   const headers = { authorization: `Bearer ${options.apiKey}` };
+  const traceExporter = () => new CountingExporter(
+    new RedactingSpanExporter(
+      new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers }),
+      () => activeRedactor
+    )
+  );
   const environment = options.environment ?? process.env.NODE_ENV ?? "production";
   if (isDebugEnabled() || options.debug === true) setDebugMode(true);
   debugLog(`initialising service=${options.service} endpoint=${endpoint}`);
   activeRedactor = makeRedactor(options.redactAttributes ?? true);
-  const resource = new Resource({
+  const distro = options.distro ?? SDK_IDENTITY;
+  configureCompatCheck({ endpoint, enabled: options.compatCheck !== false, sdk: distro });
+  const resource = new Resource2({
     [ATTR_SERVICE_NAME]: options.service,
     "service.instance.id": (options.instanceId || process.env.AUTTER_RUNTIME_INSTANCE_ID || randomUUID()).slice(0, 128),
     ...options.release ? { [ATTR_SERVICE_VERSION]: options.release } : {},
     "deployment.environment": environment,
+    // OTel semconv for SDK distributions: the ingester records which
+    // Autter SDK version each service runs (version compatibility checks).
+    "telemetry.distro.name": distro.name,
+    "telemetry.distro.version": distro.version,
     // Tells the ingester request metrics arrive on the metrics pipe, so
     // it must not also fold our server spans into usage rollups (that
     // would double-count every sampled request).
@@ -1070,30 +1361,24 @@ function initAutterServer(options) {
   let sampler = retainTraces ? new RecordUnsampledSampler(headSampler) : headSampler;
   if (options.llmTracing !== false) sampler = new LlmAwareSampler(sampler);
   const errorTraceBuffer = retainTraces ? new ErrorTraceRetentionProcessor(
-    new BatchSpanProcessor(
-      new CountingExporter(
-        new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers })
-      ),
-      { scheduledDelayMillis: 2e3 }
-    ),
+    new BatchSpanProcessor(traceExporter(), { scheduledDelayMillis: 2e3 }),
     retainOnError,
     slowThresholdMs
   ) : null;
-  const mainSpanProcessor = new BatchSpanProcessor(
-    new CountingExporter(
-      new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers })
-    )
-  );
+  const mainSpanProcessor = new BatchSpanProcessor(traceExporter());
   const metricReader = new PeriodicExportingMetricReader({
-    exporter: new OTLPMetricExporter({
-      url: `${endpoint}/v1/metrics`,
-      headers,
-      // Deltas, not lifetime totals: the ingester SUMs data points
-      // into runtime_metrics_1m, and the default (cumulative)
-      // temporality would re-count every past request on each
-      // 60 s export.
-      temporalityPreference: AggregationTemporalityPreference.DELTA
-    }),
+    exporter: new RedactingMetricExporter(
+      new OTLPMetricExporter({
+        url: `${endpoint}/v1/metrics`,
+        headers,
+        // Deltas, not lifetime totals: the ingester SUMs data points
+        // into runtime_metrics_1m, and the default (cumulative)
+        // temporality would re-count every past request on each
+        // 60 s export.
+        temporalityPreference: AggregationTemporalityPreference.DELTA
+      }),
+      () => activeRedactor
+    ),
     exportIntervalMillis: options.metricIntervalMs ?? 6e4
   });
   const sdk = new NodeSDK({
@@ -1119,16 +1404,14 @@ function initAutterServer(options) {
   });
   sdk.start();
   const stopMemoryMetrics = options.memoryMetrics === false ? null : startMemoryMetrics();
+  noteCompatFeature("endpoint_latency");
+  if (stopMemoryMetrics) noteCompatFeature("memory_metrics");
+  if (options.llmTracing !== false) noteCompatFeature("llm_calls");
   const alwaysOnProvider = new BasicTracerProvider({
     resource,
     sampler: new AlwaysOnSampler(),
     spanProcessors: [
-      new BatchSpanProcessor(
-        new CountingExporter(
-          new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers })
-        ),
-        { scheduledDelayMillis: 2e3 }
-      )
+      new BatchSpanProcessor(traceExporter(), { scheduledDelayMillis: 2e3 })
     ]
   });
   const errorTracer = alwaysOnProvider.getTracer("autter-errors");
@@ -1138,31 +1421,43 @@ function initAutterServer(options) {
     errorTraceBuffer?.retainActiveTrace();
     telemetryStats.markCaptured();
     const isError = error instanceof Error;
-    const message = isError ? error.message : String(error);
+    const message = activeRedactor.text(isError ? error.message : String(error));
+    const stackText = isError && error.stack ? activeRedactor.text(error.stack) : "";
     const redacted = activeRedactor(attributes);
-    const activeSpan = trace.getActiveSpan();
+    const activeSpan = trace2.getActiveSpan();
     const reuseActive = activeSpan?.isRecording() === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan(isError ? error.name : "Error");
-    span.setAttributes({ "autter.severity": "error", ...redacted });
-    if (isError && error.stack) {
-      if (redacted["autter.handled"] === true) {
-        span.addEvent("exception", {
-          "exception.type": error.name,
-          "exception.message": message,
-          "exception.stacktrace": error.stack,
-          "autter.handled": true,
-          "autter.sampled": redacted["autter.sampled"] === true
-        });
-      } else {
-        span.recordException(error);
-      }
+    const structured = structuredErrorAttributes(error);
+    const causes = errorAttributes(error);
+    const declared = Object.fromEntries(
+      Object.entries(causes).filter(([key]) => key !== "autter.error.internal")
+    );
+    const requestId = currentOperation()?.requestId;
+    span.setAttributes({
+      "autter.severity": "error",
+      ...redacted,
+      ...structured,
+      ...requestId ? { "autter.request.id": requestId } : {}
+    });
+    markCaptured(error);
+    noteOperationError(error);
+    notifyException(error, redacted);
+    if (isError && stackText) {
+      span.addEvent("exception", {
+        "exception.type": error.name,
+        "exception.message": message,
+        "exception.stacktrace": stackText,
+        ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {},
+        ...declared
+      });
     } else {
       const stack = new Error().stack?.split("\n").filter((line, i) => i === 0 || !line.includes("captureException")).join("\n");
       span.addEvent("exception", {
         "exception.type": isError ? error.name : "Error",
         "exception.message": message,
-        ...stack ? { "exception.stacktrace": stack } : {},
-        ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {}
+        ...stack ? { "exception.stacktrace": activeRedactor.text(stack) } : {},
+        ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {},
+        ...declared
       });
     }
     span.setStatus({ code: SpanStatusCode.ERROR, message });
@@ -1174,22 +1469,23 @@ function initAutterServer(options) {
     }
     telemetryStats.markCaptured();
     const stack = new Error().stack?.split("\n").filter((line, i) => i === 0 || !line.includes("captureMessage")).join("\n");
+    const safeMessage = activeRedactor.text(message);
     const span = errorTracer.startSpan("Message", {
       attributes: { "autter.severity": severity, ...activeRedactor(attributes) }
     });
     span.addEvent("exception", {
       "exception.type": "Message",
-      "exception.message": message,
-      ...stack ? { "exception.stacktrace": stack } : {},
+      "exception.message": safeMessage,
+      ...stack ? { "exception.stacktrace": activeRedactor.text(stack) } : {},
       "autter.severity": severity
     });
-    span.setStatus({ code: SpanStatusCode.ERROR, message });
+    span.setStatus({ code: SpanStatusCode.ERROR, message: safeMessage });
     span.end();
   }
   function reportOutcome2(name, message, attributes) {
     errorTraceBuffer?.retainActiveTrace();
     telemetryStats.markCaptured();
-    const activeSpan = trace.getActiveSpan();
+    const activeSpan = trace2.getActiveSpan();
     const reuseActive = activeSpan?.isRecording() === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan("OutcomeFailure");
     const safeOutcome = activeRedactor({ "autter.outcome.name": name.slice(0, 200), "autter.outcome.message": message.slice(0, 1e3) });
@@ -1204,6 +1500,19 @@ function initAutterServer(options) {
     span.setStatus({ code: SpanStatusCode.ERROR, message: safeMessage });
     if (!reuseActive) span.end();
   }
+  configureRuntimeLogger({
+    endpoint,
+    apiKey: options.apiKey,
+    service: options.service,
+    environment,
+    distro,
+    release: options.release,
+    options: options.logging,
+    redact: activeRedactor,
+    run: (name, fn, attributes, links) => runWithSpan(processTracer, name, fn, activeRedactor(attributes), links),
+    reportOutcome: reportOutcome2
+  });
+  hookRequests = options.logging?.requests === true;
   if (options.captureGlobalErrors !== false) {
     process.on("uncaughtExceptionMonitor", (err) => {
       captureException2(err, { "autter.unhandled": true });
@@ -1214,6 +1523,7 @@ function initAutterServer(options) {
   const flushTarget = {
     forceFlush: async () => {
       const results = await Promise.allSettled([
+        flushRuntimeLogs(),
         Promise.resolve().then(() => alwaysOnProvider.forceFlush()),
         Promise.resolve().then(() => mainSpanProcessor.forceFlush()),
         ...errorTraceBuffer ? [Promise.resolve().then(() => errorTraceBuffer.forceFlush())] : [],
@@ -1240,6 +1550,8 @@ function initAutterServer(options) {
     withLlmCall: (info, fn) => runLlmSpan(llmTracer, info, fn),
     trackLlmCall: (call) => recordLlmCall(llmTracer, call),
     shutdown: async () => {
+      const logShutdown = await Promise.allSettled([shutdownRuntimeLogger()]);
+      hookRequests = false;
       stopMemoryMetrics?.();
       active = null;
       activeAlwaysOnProvider = null;
@@ -1248,6 +1560,7 @@ function initAutterServer(options) {
       unregisterFlushTargets();
       telemetryStats.markAllFlushed();
       await Promise.allSettled([alwaysOnProvider.shutdown(), sdk.shutdown()]);
+      if (logShutdown[0]?.status === "rejected") throw logShutdown[0].reason;
     }
   };
   active = server;
@@ -1259,48 +1572,67 @@ function captureException(error, attributes) {
     active.captureException(error, attributes);
     return;
   }
-  const span = trace.getTracer("autter-errors").startSpan(error instanceof Error ? error.name : "Error", { attributes });
-  if (error instanceof Error) span.recordException(error);
-  span.setStatus({
-    code: SpanStatusCode.ERROR,
-    message: error instanceof Error ? error.message : String(error)
+  if (loggerOnlyCapture) {
+    loggerOnlyCapture(error, attributes);
+    return;
+  }
+  markCaptured(error);
+  noteOperationError(error);
+  notifyException(error, attributes);
+  const span = trace2.getTracer("autter-errors").startSpan(error instanceof Error ? error.name : "Error", {
+    attributes: activeRedactor(attributes)
   });
+  recordError(span, error);
   span.end();
 }
+var loggerOnlyCapture = null;
+function setLoggerOnlyCapture(fn) {
+  loggerOnlyCapture = fn;
+}
+function serverActive() {
+  return active !== null;
+}
+setRequestExceptionCapturer((error) => captureException(error));
 function withProcessSpan(name, fn, attributes) {
   if (active) return active.withProcessSpan(name, fn, attributes);
-  return runWithSpan(trace.getTracer("autter-processes"), name, fn, attributes);
+  return runWithSpan(
+    trace2.getTracer("autter-processes"),
+    name,
+    fn,
+    activeRedactor(attributes)
+  );
 }
 function withLlmCall(info, fn) {
   if (active) return active.withLlmCall(info, fn);
-  return runLlmSpan(trace.getTracer("autter-llm"), info, fn);
+  return runLlmSpan(trace2.getTracer("autter-llm"), info, fn);
 }
 function trackLlmCall(call) {
   if (active) {
     active.trackLlmCall(call);
     return;
   }
-  recordLlmCall(trace.getTracer("autter-llm"), call);
+  recordLlmCall(trace2.getTracer("autter-llm"), call);
 }
 function captureMessage(message, severity = "warning", attributes) {
   if (active) {
     active.captureMessage(message, severity, attributes);
     return;
   }
-  const span = trace.getTracer("autter-errors").startSpan("Message", {
-    attributes: { "autter.severity": severity, ...attributes }
+  const safeMessage = activeRedactor.text(message);
+  const span = trace2.getTracer("autter-errors").startSpan("Message", {
+    attributes: { "autter.severity": severity, ...activeRedactor(attributes) }
   });
   span.addEvent("exception", {
     "exception.type": "Message",
-    "exception.message": message,
+    "exception.message": safeMessage,
     "autter.severity": severity
   });
-  span.setStatus({ code: SpanStatusCode.ERROR, message });
+  span.setStatus({ code: SpanStatusCode.ERROR, message: safeMessage });
   span.end();
 }
 function reportOutcome(name, message, attributes) {
   if (active) return active.reportOutcome(name, message, attributes);
-  const span = trace.getTracer("autter-outcomes").startSpan("OutcomeFailure");
+  const span = trace2.getTracer("autter-outcomes").startSpan("OutcomeFailure");
   const safeOutcome = redactAttributes({ "autter.outcome.name": name.slice(0, 200), "autter.outcome.message": message.slice(0, 1e3) });
   const safeName = String(safeOutcome["autter.outcome.name"] ?? "operation");
   const safeMessage = String(safeOutcome["autter.outcome.message"] ?? "failed");
@@ -1321,7 +1653,7 @@ function makeSafeCapture(options) {
   };
 }
 function alwaysOnTracer(name) {
-  return activeAlwaysOnProvider ? activeAlwaysOnProvider.getTracer(name) : trace.getTracer(name);
+  return activeAlwaysOnProvider ? activeAlwaysOnProvider.getTracer(name) : trace2.getTracer(name);
 }
 function autterLlmTracer() {
   return alwaysOnTracer("autter-llm");
@@ -1341,7 +1673,7 @@ async function emitLlmSelftestTrace() {
       attributes: { "autter.selftest": true }
     },
     (llm) => {
-      traceId = trace.getActiveSpan()?.spanContext().traceId ?? "";
+      traceId = trace2.getActiveSpan()?.spanContext().traceId ?? "";
       llm.setUsage({ inputTokens: 1, outputTokens: 1 });
       llm.setCost(0);
     }
@@ -1389,15 +1721,26 @@ function extractUsage(result) {
   const r = result;
   const usage = r?.usage ?? r?.message?.usage;
   const meta = r?.usageMetadata;
+  const details = usage?.prompt_tokens_details;
+  const cached = usage?.cache_read_input_tokens ?? (typeof details?.cached_tokens === "number" ? details.cached_tokens : void 0) ?? meta?.cachedContentTokenCount;
   const input = usage?.prompt_tokens ?? usage?.input_tokens ?? meta?.promptTokenCount ?? void 0;
   const output = usage?.completion_tokens ?? usage?.output_tokens ?? meta?.candidatesTokenCount ?? void 0;
   const responseModel = r?.model ?? r?.modelVersion;
   return {
     inputTokens: typeof input === "number" ? input : void 0,
     outputTokens: typeof output === "number" ? output : void 0,
+    cacheReadTokens: typeof cached === "number" ? cached : void 0,
     responseModel: typeof responseModel === "string" ? responseModel : void 0
   };
 }
+function rollUp(model, usage) {
+  recordOperationAiUsage({
+    model: usage.responseModel ?? model,
+    ...usage.inputTokens !== void 0 ? { inputTokens: usage.inputTokens } : {},
+    ...usage.outputTokens !== void 0 ? { outputTokens: usage.outputTokens } : {},
+    ...usage.cacheReadTokens !== void 0 ? { cacheReadTokens: usage.cacheReadTokens } : {}
+  });
+}
 function applyUsage(span, usage) {
   if (usage.inputTokens !== void 0) {
     span.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens);
@@ -1410,14 +1753,10 @@ function applyUsage(span, usage) {
   }
 }
 function endWithError(span, err) {
-  if (err instanceof Error) span.recordException(err);
-  span.setStatus({
-    code: SpanStatusCode2.ERROR,
-    message: err instanceof Error ? err.message : String(err)
-  });
+  recordError(span, err);
   span.end();
 }
-function wrapStream(stream, span) {
+function wrapStream(stream, span, model) {
   let ended = false;
   const seen = {
     inputTokens: void 0,
@@ -1428,6 +1767,7 @@ function wrapStream(stream, span) {
     if (ended) return;
     ended = true;
     applyUsage(span, seen);
+    rollUp(model, seen);
     span.setAttribute("autter.llm.streamed", true);
     if (err !== void 0) {
       endWithError(span, err);
@@ -1449,6 +1789,7 @@ function wrapStream(stream, span) {
                   const usage = extractUsage(step.value);
                   if (usage.inputTokens !== void 0) seen.inputTokens = usage.inputTokens;
                   if (usage.outputTokens !== void 0) seen.outputTokens = usage.outputTokens;
+                  if (usage.cacheReadTokens !== void 0) seen.cacheReadTokens = usage.cacheReadTokens;
                   if (usage.responseModel) seen.responseModel = usage.responseModel;
                 } else {
                   finish();
@@ -1494,7 +1835,7 @@ function instrumentLlmClient(client, options) {
         "gen_ai.system": provider,
         "gen_ai.request.model": request.model,
         ...userId ? { "autter.user_id": userId } : {},
-        ...options?.attributes
+        ...redactWithActive(options?.attributes)
       }
     });
     let result;
@@ -1506,9 +1847,11 @@ function instrumentLlmClient(client, options) {
     }
     if (!(result instanceof Promise)) {
       if (result && typeof result === "object" && Symbol.asyncIterator in result) {
-        return wrapStream(result, span);
+        return wrapStream(result, span, request.model);
       }
-      applyUsage(span, extractUsage(result));
+      const usage = extractUsage(result);
+      applyUsage(span, usage);
+      rollUp(request.model, usage);
       span.setStatus({ code: SpanStatusCode2.OK });
       span.end();
       return result;
@@ -1516,9 +1859,11 @@ function instrumentLlmClient(client, options) {
     return result.then(
       (resolved) => {
         if (resolved && typeof resolved === "object" && Symbol.asyncIterator in resolved) {
-          return wrapStream(resolved, span);
+          return wrapStream(resolved, span, request.model);
         }
-        applyUsage(span, extractUsage(resolved));
+        const usage = extractUsage(resolved);
+        applyUsage(span, usage);
+        rollUp(request.model, usage);
         span.setStatus({ code: SpanStatusCode2.OK });
         span.end();
         return resolved;
@@ -1609,21 +1954,245 @@ ${frames.join("\n")}`;
     });
   } };
 }
+
+// src/logging-only.ts
+import {
+  SpanStatusCode as SpanStatusCode3,
+  trace as trace3
+} from "@opentelemetry/api";
+var activeLogging = null;
+function initAutterLogging(options) {
+  if (activeLogging) return activeLogging;
+  if (serverActive()) {
+    console.warn(
+      "[autter-runtime] initAutterLogging() ignored: initAutterServer() is already active and includes logging"
+    );
+    return {
+      captureException,
+      flush: flushRuntimeLogs,
+      shutdown: async () => {
+      }
+    };
+  }
+  if (isDebugEnabled() || options.debug === true) setDebugMode(true);
+  const endpoint = (options.endpoint ?? "https://otlp.autter.dev").replace(/\/$/, "");
+  const environment = options.environment ?? process.env.NODE_ENV ?? "production";
+  const redact = makeRedactor(options.redactAttributes ?? true);
+  const mode = options.exceptions ?? "auto";
+  debugLog(`initialising logger-only service=${options.service} endpoint=${endpoint}`);
+  function captureException2(error, attributes) {
+    markCaptured(error);
+    const redacted = redact(attributes);
+    const span = trace3.getActiveSpan();
+    if (mode === "auto" && span?.isRecording()) {
+      noteOperationError(error);
+      notifyException(error, redacted);
+      span.setAttributes({ "autter.severity": "error", ...redacted, ...structuredErrorAttributes(error) });
+      const declared = errorAttributes(error);
+      if (error instanceof Error) {
+        span.addEvent("exception", {
+          "exception.type": error.name,
+          "exception.message": error.message,
+          ...error.stack ? { "exception.stacktrace": error.stack } : {},
+          ...declared
+        });
+      } else {
+        span.addEvent("exception", {
+          "exception.type": "Error",
+          "exception.message": String(error),
+          ...declared
+        });
+      }
+      span.setStatus({
+        code: SpanStatusCode3.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    notifyException(error, redacted);
+    captureExceptionAsLog(error, redacted);
+  }
+  const captured = /* @__PURE__ */ new WeakSet();
+  configureRuntimeLogger({
+    endpoint,
+    apiKey: options.apiKey ?? "",
+    service: options.service,
+    environment,
+    ...options.release ? { release: options.release } : {},
+    ...options.logging ? { options: options.logging } : {},
+    redact,
+    reportOutcome: (name, message, attributes) => {
+      runtimeLogger.error(message, {
+        ...attributes,
+        "autter.outcome.name": name.slice(0, 200),
+        "autter.outcome.message": message.slice(0, 1e3)
+      });
+    },
+    captureThrown: (error) => {
+      if (error && typeof error === "object") {
+        if (captured.has(error)) return;
+        captured.add(error);
+      }
+      captureException2(error);
+    }
+  });
+  setLoggerOnlyCapture(captureException2);
+  const onCrash = (error) => captureException2(error, { "autter.unhandled": true });
+  if (options.captureGlobalErrors !== false)
+    process.on("uncaughtExceptionMonitor", onCrash);
+  registerFlushTarget("logging", { forceFlush: () => flushRuntimeLogs() });
+  let autoFlushHandle = options.autoFlush === false ? null : installAutterAutoFlush();
+  const handle = {
+    captureException: captureException2,
+    flush: flushRuntimeLogs,
+    shutdown: async () => {
+      process.off("uncaughtExceptionMonitor", onCrash);
+      setLoggerOnlyCapture(null);
+      autoFlushHandle?.dispose();
+      autoFlushHandle = null;
+      unregisterFlushTargets();
+      activeLogging = null;
+      await shutdownRuntimeLogger();
+    }
+  };
+  activeLogging = handle;
+  return handle;
+}
+
+// src/enrichers.ts
+function headerOf(req, name) {
+  const headers = req?.headers;
+  if (!headers) return void 0;
+  if (typeof headers.get === "function") {
+    return headers.get(name) ?? void 0;
+  }
+  const value = headers[name.toLowerCase()];
+  if (Array.isArray(value)) return value[0] === void 0 ? void 0 : String(value[0]);
+  return value === void 0 || value === null ? void 0 : String(value);
+}
+function enrichUserAgent() {
+  return (event, { req }) => {
+    const ua = headerOf(req, "user-agent");
+    if (!ua) return;
+    const info = parseUserAgent(ua);
+    if (info.browser) event.attributes["user_agent.browser"] = info.browser;
+    if (info.os) event.attributes["user_agent.os"] = info.os;
+    event.attributes["user_agent.device"] = info.device;
+    event.attributes["user_agent.bot"] = info.bot;
+  };
+}
+function enrichRequestSize() {
+  return (event, { req, res }) => {
+    const request = Number(headerOf(req, "content-length"));
+    if (Number.isFinite(request) && request >= 0)
+      event.attributes["http.request.body.size"] = request;
+    const raw = res?.getHeader?.(
+      "content-length"
+    );
+    const response = Number(raw);
+    if (raw !== void 0 && Number.isFinite(response) && response >= 0)
+      event.attributes["http.response.body.size"] = response;
+  };
+}
+var COUNTRY_HEADERS = [
+  "cf-ipcountry",
+  "x-vercel-ip-country",
+  "cloudfront-viewer-country",
+  "x-country-code",
+  "fastly-geo-country-code"
+];
+function enrichEdgeGeo() {
+  return (event, { req }) => {
+    for (const name of COUNTRY_HEADERS) {
+      const value = headerOf(req, name)?.trim().toUpperCase();
+      if (value && /^[A-Z]{2}$/.test(value) && value !== "XX" && value !== "T1") {
+        event.attributes["geo.country.iso_code"] = value;
+        return;
+      }
+    }
+  };
+}
+var REGION_VARS = [
+  "AUTTER_REGION",
+  "AWS_REGION",
+  "VERCEL_REGION",
+  "FLY_REGION",
+  "RAILWAY_REPLICA_REGION",
+  "GOOGLE_CLOUD_REGION",
+  "CLOUD_RUN_REGION",
+  "RENDER_REGION",
+  "AZURE_REGION"
+];
+var COMMIT_VARS = [
+  "AUTTER_COMMIT",
+  "GIT_SHA",
+  "GIT_COMMIT",
+  "COMMIT_SHA",
+  "SOURCE_COMMIT",
+  "VERCEL_GIT_COMMIT_SHA",
+  "GITHUB_SHA",
+  "RENDER_GIT_COMMIT",
+  "RAILWAY_GIT_COMMIT_SHA",
+  "CF_PAGES_COMMIT_SHA",
+  "HEROKU_SLUG_COMMIT",
+  "SOURCE_VERSION"
+];
+function enrichDeployment(env = process.env) {
+  const pick = (names) => names.map((name) => env[name]?.trim()).find((value) => value);
+  const region = pick(REGION_VARS)?.slice(0, 64);
+  const commit = pick(COMMIT_VARS)?.slice(0, 64);
+  return (event) => {
+    if (region) event.attributes["deployment.region"] = region;
+    if (commit) event.attributes["deployment.commit"] = commit;
+  };
+}
 export {
+  CODE_PATTERN,
+  COMPAT_MANIFEST,
+  INGESTER_VERSION_HEADER,
+  RuntimeError,
+  SDK_IDENTITY,
+  autterErrorResponse,
+  autterFastify,
+  autterRequests,
   captureException,
   captureMessage,
+  consoleSink,
   createBrowserRelayFetchHandler,
   createBrowserRelayHandler,
+  createRuntimeLogger,
+  defineRuntimeErrors,
   emitLlmSelftestTrace,
+  enrichDeployment,
+  enrichEdgeGeo,
+  enrichRequestSize,
+  enrichUserAgent,
+  errorAttributes,
+  evaluateCompat,
+  fetchIngesterCompat,
+  fileSink,
+  flushRuntimeLogs,
+  initAutterLogging,
   initAutterServer,
   installAutterAutoFlush,
   instrumentLlmClient,
+  isRuntimeErrorLike,
   makeSafeCapture,
+  otlpSink,
   redactAttributes,
+  redactText,
   reportOutcome,
+  runDoctor,
+  runInBackground,
+  runtimeContext,
+  runtimeLogStats,
+  runtimeLogger,
   sanitizeBrowserPayload,
   startCaughtExceptionSampler,
+  toClientError,
   trackLlmCall,
   withLlmCall,
-  withProcessSpan
+  withProcessSpan,
+  withRuntimeOperation,
+  withRuntimeRequest
 };