autotel 3.6.0 → 3.7.0

package/dist/index.cjs

@@ -1,1278 +1,1155 @@
-'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_sampling = require('./sampling.cjs');
+const require_init = require('./init-DvapOXCc.cjs');
+const require_filtering_span_processor = require('./filtering-span-processor.cjs');
+const require_span_name_normalizer = require('./span-name-normalizer.cjs');
+const require_attribute_redacting_processor = require('./attribute-redacting-processor.cjs');
+const require_canonical_log_line_processor = require('./canonical-log-line-processor--RlFDHhm.cjs');
+const require_tracer_provider = require('./tracer-provider.cjs');
+const require_track = require('./track-3HY4NGV-.cjs');
+const require_structured_error = require('./structured-error-CHg7DoIQ.cjs');
+const require_trace_helpers = require('./trace-helpers.cjs');
+const require_operation_context = require('./operation-context-n4_obUwq.cjs');
+const require_functional = require('./functional-C4CzoVrX.cjs');
+const require_stable_hash = require('./stable-hash-BNTMrmdB.cjs');
+const require_event = require('./event-Dlqr4ZNL.cjs');
+const require_metric = require('./metric.cjs');
+const require_correlated_events = require('./correlated-events-kSwLo3mi.cjs');
+const require_parse_error = require('./parse-error.cjs');
+const require_drain_pipeline = require('./drain-pipeline.cjs');
+const require_metric_helpers = require('./metric-helpers.cjs');
+const require_semantic_helpers = require('./semantic-helpers.cjs');
+const require_registry = require('./registry-JZg2J3RZ.cjs');
+const require_semantic_conventions = require('./semantic-conventions.cjs');
+const require_attributes = require('./attributes-D3etyRVc.cjs');
+const require_messaging = require('./messaging.cjs');
+const require_business_baggage = require('./business-baggage.cjs');
+const require_workflow = require('./workflow.cjs');
+let _opentelemetry_api = require("@opentelemetry/api");
+let _opentelemetry_sdk_metrics = require("@opentelemetry/sdk-metrics");
+let node_async_hooks = require("node:async_hooks");
 
-var chunk2ZKEORFN_cjs = require('./chunk-2ZKEORFN.cjs');
-var chunkT4B5LB6E_cjs = require('./chunk-T4B5LB6E.cjs');
-var chunk7EQ4G4SI_cjs = require('./chunk-7EQ4G4SI.cjs');
-var chunkNENU7E6V_cjs = require('./chunk-NENU7E6V.cjs');
-var chunkE6TERL5O_cjs = require('./chunk-E6TERL5O.cjs');
-var chunkM3LFHHTN_cjs = require('./chunk-M3LFHHTN.cjs');
-var chunkESMHTKLJ_cjs = require('./chunk-ESMHTKLJ.cjs');
-var chunkB7SWBE4P_cjs = require('./chunk-B7SWBE4P.cjs');
-var chunk4P6ZOARG_cjs = require('./chunk-4P6ZOARG.cjs');
-var chunkINJD3G4K_cjs = require('./chunk-INJD3G4K.cjs');
-var chunkTC5ZPWM4_cjs = require('./chunk-TC5ZPWM4.cjs');
-require('./chunk-YTXEZ4SD.cjs');
-var chunkWJH6IYU2_cjs = require('./chunk-WJH6IYU2.cjs');
-var chunkKYXZS3EA_cjs = require('./chunk-KYXZS3EA.cjs');
-var chunkV7UBMJAB_cjs = require('./chunk-V7UBMJAB.cjs');
-var chunkOPPXYVEZ_cjs = require('./chunk-OPPXYVEZ.cjs');
-var chunkEOFB7XCL_cjs = require('./chunk-EOFB7XCL.cjs');
-require('./chunk-NZ72VDNY.cjs');
-require('./chunk-UY3UYPBZ.cjs');
-var chunkVQTCQKHQ_cjs = require('./chunk-VQTCQKHQ.cjs');
-var chunkFMTHVSYY_cjs = require('./chunk-FMTHVSYY.cjs');
-var chunkEE6CPXKH_cjs = require('./chunk-EE6CPXKH.cjs');
-var chunkR7QYGZUP_cjs = require('./chunk-R7QYGZUP.cjs');
-require('./chunk-QWW3E3JM.cjs');
-require('./chunk-CEAQK2QY.cjs');
-var chunkZNMBW67B_cjs = require('./chunk-ZNMBW67B.cjs');
-var chunkIOYFAFHJ_cjs = require('./chunk-IOYFAFHJ.cjs');
-var chunkNEIB3TLD_cjs = require('./chunk-NEIB3TLD.cjs');
-require('./chunk-CU6IDACR.cjs');
-var chunk6S5RUKU3_cjs = require('./chunk-6S5RUKU3.cjs');
-require('./chunk-NVAI5CCN.cjs');
-var chunkVH77IPJN_cjs = require('./chunk-VH77IPJN.cjs');
-require('./chunk-FU6R566Y.cjs');
-require('./chunk-ESLWRGAG.cjs');
-var chunkYREV3LGG_cjs = require('./chunk-YREV3LGG.cjs');
-var api = require('@opentelemetry/api');
-var async_hooks = require('async_hooks');
-var sdkMetrics = require('@opentelemetry/sdk-metrics');
-
-var otelMethods = {
-  // Class methods on TraceAPI — bind to the singleton.
-  setGlobalTracerProvider: api.trace.setGlobalTracerProvider.bind(api.trace),
-  getTracerProvider: api.trace.getTracerProvider.bind(api.trace),
-  getTracer: api.trace.getTracer.bind(api.trace),
-  disable: api.trace.disable.bind(api.trace),
-  // Instance fields on TraceAPI — already standalone, copy by reference.
-  wrapSpanContext: api.trace.wrapSpanContext,
-  isSpanContextValid: api.trace.isSpanContextValid,
-  deleteSpan: api.trace.deleteSpan,
-  getSpan: api.trace.getSpan,
-  getActiveSpan: api.trace.getActiveSpan,
-  getSpanContext: api.trace.getSpanContext,
-  setSpan: api.trace.setSpan,
-  setSpanContext: api.trace.setSpanContext
+//#region src/trace-hybrid.ts
+/**
+* Hybrid `trace` export: callable like autotel's `trace(fn)`, AND exposes the
+* full `@opentelemetry/api` `TraceAPI` surface (`trace.getActiveSpan()`,
+* `trace.getTracer()`, …) so existing OTel code "just works" when imported
+* from `autotel`.
+*
+* Implementation: `Object.assign` mutates the autotel `trace` function to
+* attach the OTel TraceAPI methods. Because every reference to `trace` across
+* autotel resolves to the same function instance, this is a one-time, global
+* augmentation.
+*/
+const otelMethods = {
+	setGlobalTracerProvider: _opentelemetry_api.trace.setGlobalTracerProvider.bind(_opentelemetry_api.trace),
+	getTracerProvider: _opentelemetry_api.trace.getTracerProvider.bind(_opentelemetry_api.trace),
+	getTracer: _opentelemetry_api.trace.getTracer.bind(_opentelemetry_api.trace),
+	disable: _opentelemetry_api.trace.disable.bind(_opentelemetry_api.trace),
+	wrapSpanContext: _opentelemetry_api.trace.wrapSpanContext,
+	isSpanContextValid: _opentelemetry_api.trace.isSpanContextValid,
+	deleteSpan: _opentelemetry_api.trace.deleteSpan,
+	getSpan: _opentelemetry_api.trace.getSpan,
+	getActiveSpan: _opentelemetry_api.trace.getActiveSpan,
+	getSpanContext: _opentelemetry_api.trace.getSpanContext,
+	setSpan: _opentelemetry_api.trace.setSpan,
+	setSpanContext: _opentelemetry_api.trace.setSpanContext
 };
-var trace2 = Object.assign(
-  chunkV7UBMJAB_cjs.trace,
-  otelMethods
-);
+const trace = Object.assign(require_functional.trace, otelMethods);
 
-// src/define-event.ts
+//#endregion
+//#region src/define-event.ts
 function defineEvent(name, schema, options = {}) {
-  const jsonSchema = options.toJsonSchema?.(schema);
-  const schemaMetadata = jsonSchema ? {
-    source: "zod",
-    jsonSchema,
-    hash: chunkE6TERL5O_cjs.hashJson(jsonSchema)
-  } : void 0;
-  return {
-    name,
-    schemaMetadata,
-    track(payload) {
-      const parsed = schema.safeParse(payload);
-      if (!parsed.success) {
-        throw new Error(
-          `Invalid payload for event "${name}". Schema validation failed.`
-        );
-      }
-      chunkFMTHVSYY_cjs.track(
-        name,
-        parsed.data,
-        schemaMetadata ? { schema: schemaMetadata } : void 0
-      );
-    }
-  };
+	const jsonSchema = options.toJsonSchema?.(schema);
+	const schemaMetadata = jsonSchema ? {
+		source: "zod",
+		jsonSchema,
+		hash: require_stable_hash.hashJson(jsonSchema)
+	} : void 0;
+	return {
+		name,
+		schemaMetadata,
+		track(payload) {
+			const parsed = schema.safeParse(payload);
+			if (!parsed.success) throw new Error(`Invalid payload for event "${name}". Schema validation failed.`);
+			require_track.track(name, parsed.data, schemaMetadata ? { schema: schemaMetadata } : void 0);
+		}
+	};
 }
 
-// src/shutdown.ts
+//#endregion
+//#region src/shutdown.ts
+/**
+* Graceful shutdown with flush and cleanup
+*/
+/**
+* Flush all pending telemetry
+*
+* Flushes both events events and OpenTelemetry spans to their destinations.
+* Includes timeout protection to prevent hanging in serverless environments.
+*
+* Safe to call multiple times.
+*
+* @param options - Optional configuration
+* @param options.timeout - Timeout in milliseconds (default: 2000ms)
+* @param options.forShutdown - If true, permanently disables the events queue after flush (used internally by shutdown())
+*
+* @example Manual flush in serverless
+* ```typescript
+* import { flush } from 'autotel';
+*
+* export const handler = async (event) => {
+*   // ... process event
+*   await flush(); // Flush before function returns
+*   return result;
+* };
+* ```
+*
+* @example With custom timeout
+* ```typescript
+* await flush({ timeout: 5000 }); // 5 second timeout
+* ```
+*/
 async function flush(options) {
-  const timeout = options?.timeout ?? 2e3;
-  const forShutdown = options?.forShutdown ?? false;
-  const doFlush = async () => {
-    const eventsQueue = chunkFMTHVSYY_cjs.getEventQueue();
-    if (eventsQueue) {
-      if (forShutdown) {
-        await eventsQueue.shutdown();
-      } else {
-        await eventsQueue.flush();
-      }
-    }
-    const sdk = chunkR7QYGZUP_cjs.getSdk();
-    if (sdk) {
-      try {
-        const sdkAny = sdk;
-        if (typeof sdkAny.getTracerProvider === "function") {
-          const tracerProvider = sdkAny.getTracerProvider();
-          if (tracerProvider && typeof tracerProvider.forceFlush === "function") {
-            await tracerProvider.forceFlush();
-          }
-        }
-      } catch {
-      }
-    }
-  };
-  let timeoutHandle;
-  try {
-    await Promise.race([
-      doFlush().finally(() => {
-        if (timeoutHandle) {
-          clearTimeout(timeoutHandle);
-        }
-      }),
-      new Promise((_, reject) => {
-        timeoutHandle = setTimeout(
-          () => reject(new Error("Flush timeout")),
-          timeout
-        );
-        timeoutHandle.unref();
-      })
-    ]);
-  } catch (error) {
-    if (timeoutHandle) {
-      clearTimeout(timeoutHandle);
-    }
-    const logger = chunkR7QYGZUP_cjs.getLogger();
-    logger.error(
-      {
-        err: error instanceof Error ? error : new Error(String(error))
-      },
-      "[autotel] Flush error"
-    );
-    throw error;
-  }
+	const timeout = options?.timeout ?? 2e3;
+	const forShutdown = options?.forShutdown ?? false;
+	const doFlush = async () => {
+		const eventsQueue = require_track.getEventQueue();
+		if (eventsQueue) if (forShutdown) await eventsQueue.shutdown();
+		else await eventsQueue.flush();
+		const sdk = require_init.getSdk();
+		if (sdk) try {
+			const sdkAny = sdk;
+			if (typeof sdkAny.getTracerProvider === "function") {
+				const tracerProvider = sdkAny.getTracerProvider();
+				if (tracerProvider && typeof tracerProvider.forceFlush === "function") await tracerProvider.forceFlush();
+			}
+		} catch {}
+	};
+	let timeoutHandle;
+	try {
+		await Promise.race([doFlush().finally(() => {
+			if (timeoutHandle) clearTimeout(timeoutHandle);
+		}), new Promise((_, reject) => {
+			timeoutHandle = setTimeout(() => reject(/* @__PURE__ */ new Error("Flush timeout")), timeout);
+			timeoutHandle.unref();
+		})]);
+	} catch (error) {
+		if (timeoutHandle) clearTimeout(timeoutHandle);
+		require_init.getLogger().error({ err: error instanceof Error ? error : new Error(String(error)) }, "[autotel] Flush error");
+		throw error;
+	}
 }
+/**
+* Shutdown telemetry and cleanup resources
+*
+* - Flushes all pending data
+* - Shuts down OpenTelemetry SDK
+* - Cleans up resources
+*
+* Call this before process exit.
+*
+* Always performs cleanup even if flush fails, preventing resource leaks
+* in serverless handlers or tests.
+*
+* @example Express server
+* ```typescript
+* const server = app.listen(3000)
+*
+* process.on('SIGTERM', async () => {
+*   await server.close()
+*   await shutdown()
+*   process.exit(0)
+* })
+* ```
+*/
 async function shutdown() {
-  const logger = chunkR7QYGZUP_cjs.getLogger();
-  let shutdownError = null;
-  try {
-    await flush({ forShutdown: true });
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    shutdownError = err;
-    logger.error(
-      {
-        err
-      },
-      "[autotel] Flush failed during shutdown, continuing cleanup"
-    );
-  }
-  try {
-    const sdk = chunkR7QYGZUP_cjs.getSdk();
-    if (sdk) {
-      await sdk.shutdown();
-    }
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    const isConnectionRefused = typeof error === "object" && error !== null && "code" in error && error.code === "ECONNREFUSED";
-    if (!isConnectionRefused) {
-      if (!shutdownError) {
-        shutdownError = err;
-      }
-      logger.error({ err }, "[autotel] SDK shutdown failed");
-    }
-  } finally {
-    await chunkR7QYGZUP_cjs._closeEmbeddedDevtools();
-    const eventsQueue = chunkFMTHVSYY_cjs.getEventQueue();
-    if (eventsQueue && typeof eventsQueue.cleanup === "function") {
-      eventsQueue.cleanup();
-    }
-    chunkEOFB7XCL_cjs.resetEvents();
-    chunkTC5ZPWM4_cjs.resetMetrics();
-    chunkFMTHVSYY_cjs.resetEventQueue();
-  }
-  if (shutdownError) {
-    throw shutdownError;
-  }
+	const logger = require_init.getLogger();
+	let shutdownError = null;
+	try {
+		await flush({ forShutdown: true });
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		shutdownError = err;
+		logger.error({ err }, "[autotel] Flush failed during shutdown, continuing cleanup");
+	}
+	try {
+		const sdk = require_init.getSdk();
+		if (sdk) await sdk.shutdown();
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		if (!(typeof error === "object" && error !== null && "code" in error && error.code === "ECONNREFUSED")) {
+			if (!shutdownError) shutdownError = err;
+			logger.error({ err }, "[autotel] SDK shutdown failed");
+		}
+	} finally {
+		await require_init._closeEmbeddedDevtools();
+		const eventsQueue = require_track.getEventQueue();
+		if (eventsQueue && typeof eventsQueue.cleanup === "function") eventsQueue.cleanup();
+		require_event.resetEvents();
+		require_metric.resetMetrics();
+		require_track.resetEventQueue();
+	}
+	if (shutdownError) throw shutdownError;
 }
+/**
+* Register automatic shutdown hooks for common signals
+*
+* Handles:
+* - SIGTERM (Docker/K8s graceful shutdown)
+* - SIGINT (Ctrl+C)
+*
+* @internal Called automatically on module load
+*/
 function registerShutdownHooks() {
-  if (typeof process === "undefined") return;
-  const signals = ["SIGTERM", "SIGINT"];
-  let shuttingDown = false;
-  for (const signal of signals) {
-    process.on(signal, async () => {
-      if (shuttingDown) return;
-      shuttingDown = true;
-      if (process.env.NODE_ENV !== "test") {
-        chunkR7QYGZUP_cjs.getLogger().info(
-          {},
-          `[autotel] Received ${signal}, flushing telemetry...`
-        );
-      }
-      try {
-        await shutdown();
-      } catch (error) {
-        chunkR7QYGZUP_cjs.getLogger().error(
-          {
-            err: error instanceof Error ? error : void 0
-          },
-          "[autotel] Error during shutdown"
-        );
-      } finally {
-        process.exit(0);
-      }
-    });
-  }
+	if (typeof process === "undefined") return;
+	const signals = ["SIGTERM", "SIGINT"];
+	let shuttingDown = false;
+	for (const signal of signals) process.on(signal, async () => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		if (process.env.NODE_ENV !== "test") require_init.getLogger().info({}, `[autotel] Received ${signal}, flushing telemetry...`);
+		try {
+			await shutdown();
+		} catch (error) {
+			require_init.getLogger().error({ err: error instanceof Error ? error : void 0 }, "[autotel] Error during shutdown");
+		} finally {
+			process.exit(0);
+		}
+	});
 }
 registerShutdownHooks();
-var POST_EMIT_FORK_HINT = "For intentional background work tied to this request, use log.fork('label', fn) when available.";
+
+//#endregion
+//#region src/request-logger.ts
+const POST_EMIT_FORK_HINT = "For intentional background work tied to this request, use log.fork('label', fn) when available.";
 function warnPostEmit(method, detail) {
-  console.warn(
-    `[autotel] ${method} called after the wide event was emitted \u2014 ${detail} This data will not appear in observability. ${POST_EMIT_FORK_HINT}`
-  );
+	console.warn(`[autotel] ${method} called after the wide event was emitted — ${detail} This data will not appear in observability. ${POST_EMIT_FORK_HINT}`);
 }
-function mergeInto(target, source) {
-  for (const key in source) {
-    const sourceVal = source[key];
-    if (sourceVal === void 0) continue;
-    const targetVal = target[key];
-    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
-      mergeInto(
-        targetVal,
-        sourceVal
-      );
-    } else if (Array.isArray(targetVal) && Array.isArray(sourceVal)) {
-      target[key] = [...targetVal, ...sourceVal];
-    } else {
-      target[key] = sourceVal;
-    }
-  }
+function mergeInto$1(target, source) {
+	for (const key in source) {
+		const sourceVal = source[key];
+		if (sourceVal === void 0) continue;
+		const targetVal = target[key];
+		if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) mergeInto$1(targetVal, sourceVal);
+		else if (Array.isArray(targetVal) && Array.isArray(sourceVal)) target[key] = [...targetVal, ...sourceVal];
+		else target[key] = sourceVal;
+	}
 }
-var requestContextStore = new async_hooks.AsyncLocalStorage();
-function runWithRequestContext(ctx2, fn) {
-  return requestContextStore.run(ctx2, fn);
+const requestContextStore = new node_async_hooks.AsyncLocalStorage();
+function runWithRequestContext(ctx, fn) {
+	return requestContextStore.run(ctx, fn);
 }
-function resolveContext(ctx2) {
-  if (ctx2) return ctx2;
-  const stored = requestContextStore.getStore();
-  if (stored) return stored;
-  const span2 = api.trace.getActiveSpan();
-  if (!span2) {
-    throw new Error(
-      "[autotel] getRequestLogger() requires an active span or runWithRequestContext(). Wrap your handler with trace() or use runWithRequestContext()."
-    );
-  }
-  return chunkFMTHVSYY_cjs.createTraceContext(span2);
+function resolveContext(ctx) {
+	if (ctx) return ctx;
+	const stored = requestContextStore.getStore();
+	if (stored) return stored;
+	const span = _opentelemetry_api.trace.getActiveSpan();
+	if (!span) throw new Error("[autotel] getRequestLogger() requires an active span or runWithRequestContext(). Wrap your handler with trace() or use runWithRequestContext().");
+	return require_track.createTraceContext(span);
+}
+function getRequestLogger(ctx, options) {
+	const activeContext = resolveContext(ctx);
+	let contextState = {};
+	let emitted = false;
+	let lastSnapshot = null;
+	const addLogEvent = (level, message, fields) => {
+		const attrs = fields ? require_structured_error.flattenToAttributes(fields) : void 0;
+		require_correlated_events.emitCorrelatedEvent(activeContext, `log.${level}`, {
+			message,
+			...attrs ?? {}
+		});
+	};
+	const sealCheck = (method, keys) => {
+		if (emitted) warnPostEmit(method, `Keys dropped: ${keys.length ? keys.join(", ") : "(empty)"}.`);
+	};
+	return {
+		set(fields) {
+			sealCheck("log.set()", Object.keys(fields));
+			if (emitted) return;
+			mergeInto$1(contextState, fields);
+			activeContext.setAttributes(require_structured_error.flattenToAttributes(fields));
+		},
+		info(message, fields) {
+			sealCheck("log.info()", fields ? ["message", ...Object.keys(fields).filter((k) => k !== "requestLogs")] : ["message"]);
+			if (emitted) return;
+			addLogEvent("info", message, fields);
+			if (fields) {
+				mergeInto$1(contextState, fields);
+				activeContext.setAttributes(require_structured_error.flattenToAttributes(fields));
+			}
+		},
+		warn(message, fields) {
+			sealCheck("log.warn()", fields ? ["message", ...Object.keys(fields).filter((k) => k !== "requestLogs")] : ["message"]);
+			if (emitted) return;
+			addLogEvent("warn", message, fields);
+			activeContext.setAttribute("autotel.log.level", "warn");
+			if (fields) {
+				mergeInto$1(contextState, fields);
+				activeContext.setAttributes(require_structured_error.flattenToAttributes(fields));
+			}
+		},
+		error(error, fields) {
+			sealCheck("log.error()", fields ? [...Object.keys(fields), "error"] : ["error"]);
+			if (emitted) return;
+			const err = typeof error === "string" ? new Error(error) : error;
+			require_structured_error.recordStructuredError(activeContext, err);
+			addLogEvent("error", err.message, fields);
+			if (fields) {
+				mergeInto$1(contextState, fields);
+				activeContext.setAttributes(require_structured_error.flattenToAttributes(fields));
+			}
+			activeContext.setAttribute("autotel.log.level", "error");
+		},
+		getContext() {
+			return { ...contextState };
+		},
+		emitNow(overrides) {
+			if (emitted) {
+				warnPostEmit("log.emitNow()", "Ignoring duplicate emit.");
+				return lastSnapshot;
+			}
+			const mergedContext = {
+				...contextState,
+				...overrides ?? {}
+			};
+			const flattened = require_structured_error.flattenToAttributes(mergedContext);
+			activeContext.setAttributes(flattened);
+			const snapshot = {
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				traceId: activeContext.traceId,
+				spanId: activeContext.spanId,
+				correlationId: activeContext.correlationId,
+				context: mergedContext
+			};
+			require_correlated_events.emitCorrelatedEvent(activeContext, "log.emit.manual", { ...flattened });
+			if (options?.onEmit) Promise.resolve(options.onEmit(snapshot)).catch((error) => {
+				console.warn("[autotel] request logger onEmit failed:", error);
+			});
+			emitted = true;
+			lastSnapshot = snapshot;
+			return snapshot;
+		},
+		fork(label, fn, forkOptions) {
+			const parentRequestId = activeContext.correlationId;
+			if (typeof parentRequestId !== "string" || parentRequestId.length === 0) throw new Error("[autotel] log.fork() requires the parent logger to have a correlationId. Ensure the request was created by autotel middleware.");
+			const tracer = _opentelemetry_api.trace.getTracer("autotel.request-logger");
+			const lifecycle = forkOptions?.lifecycle;
+			tracer.startActiveSpan(`request.fork:${label}`, (childSpan) => {
+				const childContext = {
+					...require_track.createTraceContext(childSpan),
+					correlationId: crypto.randomUUID()
+				};
+				requestContextStore.run(childContext, () => {
+					const childLog = getRequestLogger(childContext);
+					childLog.set({
+						operation: label,
+						_parentCorrelationId: parentRequestId
+					});
+					lifecycle?.onChildEnter?.(childLog);
+					Promise.resolve().then(() => fn()).then(() => {
+						childLog.emitNow();
+					}).catch((err) => {
+						const error = err instanceof Error ? err : new Error(String(err));
+						childLog.error(error);
+						childLog.emitNow();
+					}).finally(() => {
+						try {
+							lifecycle?.onChildExit?.(childLog);
+						} catch (hookError) {
+							console.warn("[autotel] fork onChildExit hook threw:", hookError);
+						}
+						childSpan.end();
+					});
+				});
+			});
+		}
+	};
+}
+/**
+* Returns `true` when a request-logger context can be resolved without throwing —
+* i.e. an explicit `ctx` was provided, a `runWithRequestContext()` scope is active,
+* or there is an active OpenTelemetry span.
+*
+* Use this to branch on observability availability instead of wrapping
+* {@link getRequestLogger} in try/catch.
+*/
+function hasRequestContext(ctx) {
+	if (ctx) return true;
+	if (requestContextStore.getStore()) return true;
+	return _opentelemetry_api.trace.getActiveSpan() != null;
 }
-function getRequestLogger(ctx2, options) {
-  const activeContext = resolveContext(ctx2);
-  let contextState = {};
-  let emitted = false;
-  let lastSnapshot = null;
-  const addLogEvent = (level, message, fields) => {
-    const attrs2 = fields ? chunkEE6CPXKH_cjs.flattenToAttributes(fields) : void 0;
-    chunk4P6ZOARG_cjs.emitCorrelatedEvent(activeContext, `log.${level}`, {
-      message,
-      ...attrs2 ?? {}
-    });
-  };
-  const sealCheck = (method, keys) => {
-    if (emitted) {
-      warnPostEmit(
-        method,
-        `Keys dropped: ${keys.length ? keys.join(", ") : "(empty)"}.`
-      );
-    }
-  };
-  return {
-    set(fields) {
-      sealCheck("log.set()", Object.keys(fields));
-      if (emitted) return;
-      mergeInto(contextState, fields);
-      activeContext.setAttributes(chunkEE6CPXKH_cjs.flattenToAttributes(fields));
-    },
-    info(message, fields) {
-      const keys = fields ? ["message", ...Object.keys(fields).filter((k) => k !== "requestLogs")] : ["message"];
-      sealCheck("log.info()", keys);
-      if (emitted) return;
-      addLogEvent("info", message, fields);
-      if (fields) {
-        mergeInto(contextState, fields);
-        activeContext.setAttributes(chunkEE6CPXKH_cjs.flattenToAttributes(fields));
-      }
-    },
-    warn(message, fields) {
-      const keys = fields ? ["message", ...Object.keys(fields).filter((k) => k !== "requestLogs")] : ["message"];
-      sealCheck("log.warn()", keys);
-      if (emitted) return;
-      addLogEvent("warn", message, fields);
-      activeContext.setAttribute("autotel.log.level", "warn");
-      if (fields) {
-        mergeInto(contextState, fields);
-        activeContext.setAttributes(chunkEE6CPXKH_cjs.flattenToAttributes(fields));
-      }
-    },
-    error(error, fields) {
-      const keys = fields ? [...Object.keys(fields), "error"] : ["error"];
-      sealCheck("log.error()", keys);
-      if (emitted) return;
-      const err = typeof error === "string" ? new Error(error) : error;
-      chunkEE6CPXKH_cjs.recordStructuredError(activeContext, err);
-      addLogEvent("error", err.message, fields);
-      if (fields) {
-        mergeInto(contextState, fields);
-        activeContext.setAttributes(chunkEE6CPXKH_cjs.flattenToAttributes(fields));
-      }
-      activeContext.setAttribute("autotel.log.level", "error");
-    },
-    getContext() {
-      return { ...contextState };
-    },
-    emitNow(overrides) {
-      if (emitted) {
-        warnPostEmit("log.emitNow()", "Ignoring duplicate emit.");
-        return lastSnapshot;
-      }
-      const mergedContext = {
-        ...contextState,
-        ...overrides ?? {}
-      };
-      const flattened = chunkEE6CPXKH_cjs.flattenToAttributes(mergedContext);
-      activeContext.setAttributes(flattened);
-      const snapshot = {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        traceId: activeContext.traceId,
-        spanId: activeContext.spanId,
-        correlationId: activeContext.correlationId,
-        context: mergedContext
-      };
-      chunk4P6ZOARG_cjs.emitCorrelatedEvent(activeContext, "log.emit.manual", {
-        ...flattened
-      });
-      if (options?.onEmit) {
-        Promise.resolve(options.onEmit(snapshot)).catch((error) => {
-          console.warn("[autotel] request logger onEmit failed:", error);
-        });
-      }
-      emitted = true;
-      lastSnapshot = snapshot;
-      return snapshot;
-    },
-    fork(label, fn, forkOptions) {
-      const parentRequestId = activeContext.correlationId;
-      if (typeof parentRequestId !== "string" || parentRequestId.length === 0) {
-        throw new Error(
-          "[autotel] log.fork() requires the parent logger to have a correlationId. Ensure the request was created by autotel middleware."
-        );
-      }
-      const tracer = api.trace.getTracer("autotel.request-logger");
-      const lifecycle = forkOptions?.lifecycle;
-      void tracer.startActiveSpan(`request.fork:${label}`, (childSpan) => {
-        const childContext = {
-          ...chunkFMTHVSYY_cjs.createTraceContext(childSpan),
-          correlationId: crypto.randomUUID()
-        };
-        requestContextStore.run(childContext, () => {
-          const childLog = getRequestLogger(childContext);
-          childLog.set({
-            operation: label,
-            _parentCorrelationId: parentRequestId
-          });
-          lifecycle?.onChildEnter?.(childLog);
-          void Promise.resolve().then(() => fn()).then(() => {
-            childLog.emitNow();
-          }).catch((err) => {
-            const error = err instanceof Error ? err : new Error(String(err));
-            childLog.error(error);
-            childLog.emitNow();
-          }).finally(() => {
-            try {
-              lifecycle?.onChildExit?.(childLog);
-            } catch (hookError) {
-              console.warn(
-                "[autotel] fork onChildExit hook threw:",
-                hookError
-              );
-            }
-            childSpan.end();
-          });
-        });
-      });
-    }
-  };
+/**
+* Like {@link getRequestLogger}, but returns `null` instead of throwing when no
+* request context is available. Intended for best-effort instrumentation where a
+* missing telemetry context must never crash business logic.
+*/
+function getRequestLoggerSafe(ctx, options) {
+	if (!hasRequestContext(ctx)) return null;
+	return getRequestLogger(ctx, options);
+}
+/**
+* A no-op {@link RequestLogger} whose methods do nothing. Used as a fallback by
+* best-effort instrumentation so wrapped handlers can run un-instrumented without
+* branching on logger presence.
+*/
+function createNoopRequestLogger() {
+	const snapshot = () => ({
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		traceId: "",
+		spanId: "",
+		correlationId: "",
+		context: {}
+	});
+	return {
+		set() {},
+		info() {},
+		warn() {},
+		error() {},
+		getContext() {
+			return {};
+		},
+		emitNow() {
+			return snapshot();
+		},
+		fork(_label, fn) {
+			Promise.resolve().then(() => fn());
+		}
+	};
 }
 
-// src/error-catalog.ts
-var catalogCodeKey = /* @__PURE__ */ Symbol.for("autotel.catalog.code");
+//#endregion
+//#region src/error-catalog.ts
+/**
+* Typed error and audit catalogs.
+*
+* Group related errors into one catalog and get a refactor-safe builder per
+* code, with autocomplete at every call site and typed message parameters.
+*
+* @example
+* ```typescript
+* import { defineErrorCatalog } from 'autotel';
+*
+* export const billing = defineErrorCatalog('billing', {
+*   PAYMENT_DECLINED: {
+*     status: 402,
+*     message: 'Card declined',
+*     why: 'The issuer rejected the charge',
+*     fix: 'Try a different payment method',
+*   },
+*   INSUFFICIENT_FUNDS: {
+*     status: 402,
+*     message: ({ available, required }: { available: number; required: number }) =>
+*       `Insufficient funds: $${available} of $${required}`,
+*   },
+* });
+*
+* throw billing.PAYMENT_DECLINED({ cause: stripeError });
+* throw billing.INSUFFICIENT_FUNDS({ available: 5, required: 100 });
+*
+* // In a catch block — refactor-safe, no magic strings:
+* if (billing.PAYMENT_DECLINED.match(err)) { ... }
+* ```
+*/
+const catalogCodeKey = Symbol.for("autotel.catalog.code");
 function readCatalogCode(error) {
-  if (error === null || typeof error !== "object") return void 0;
-  return error[catalogCodeKey];
+	if (error === null || typeof error !== "object") return void 0;
+	return error[catalogCodeKey];
 }
+/** True when `error` was produced by any autotel error catalog. */
 function isCatalogError(error) {
-  return readCatalogCode(error) !== void 0;
+	return readCatalogCode(error) !== void 0;
 }
+/** Returns the catalog code of `error`, or `undefined` if it has none. */
 function getCatalogCode(error) {
-  return readCatalogCode(error);
+	return readCatalogCode(error);
 }
+/**
+* Define a typed error catalog. Returns an object whose keys are error
+* builders. Each builder produces a {@link StructuredError} carrying the
+* entry's message, status, code, why, fix, and link.
+*/
 function defineErrorCatalog(namespace, entries) {
-  const catalog = {};
-  for (const [key, entry] of Object.entries(entries)) {
-    const code = entry.code ?? `${namespace}.${key}`;
-    const usesParams = typeof entry.message === "function" || typeof entry.why === "function";
-    const builder = ((paramsOrOptions, maybeOptions) => {
-      const params = usesParams ? paramsOrOptions : void 0;
-      const options = usesParams ? maybeOptions : paramsOrOptions;
-      const message = typeof entry.message === "function" ? entry.message(params) : entry.message;
-      const why = typeof entry.why === "function" ? entry.why(params) : entry.why;
-      const error = chunkEE6CPXKH_cjs.createStructuredError({
-        message,
-        name: entry.name ?? key,
-        code,
-        ...entry.status === void 0 ? {} : { status: entry.status },
-        ...why === void 0 ? {} : { why },
-        ...entry.fix === void 0 ? {} : { fix: entry.fix },
-        ...entry.link === void 0 ? {} : { link: entry.link },
-        ...options?.cause === void 0 ? {} : { cause: options.cause },
-        ...options?.details === void 0 ? {} : { details: options.details },
-        ...options?.internal === void 0 ? {} : { internal: options.internal }
-      });
-      Object.defineProperty(error, catalogCodeKey, {
-        value: code,
-        enumerable: false,
-        writable: false,
-        configurable: true
-      });
-      return error;
-    });
-    Object.defineProperty(builder, "code", {
-      value: code,
-      enumerable: true
-    });
-    Object.defineProperty(builder, "match", {
-      value: (error) => readCatalogCode(error) === code,
-      enumerable: false
-    });
-    catalog[key] = builder;
-  }
-  return Object.freeze(catalog);
+	const catalog = {};
+	for (const [key, entry] of Object.entries(entries)) {
+		const code = entry.code ?? `${namespace}.${key}`;
+		const usesParams = typeof entry.message === "function" || typeof entry.why === "function";
+		const builder = ((paramsOrOptions, maybeOptions) => {
+			const params = usesParams ? paramsOrOptions : void 0;
+			const options = usesParams ? maybeOptions : paramsOrOptions;
+			const message = typeof entry.message === "function" ? entry.message(params) : entry.message;
+			const why = typeof entry.why === "function" ? entry.why(params) : entry.why;
+			const error = require_structured_error.createStructuredError({
+				message,
+				name: entry.name ?? key,
+				code,
+				...entry.status === void 0 ? {} : { status: entry.status },
+				...why === void 0 ? {} : { why },
+				...entry.fix === void 0 ? {} : { fix: entry.fix },
+				...entry.link === void 0 ? {} : { link: entry.link },
+				...options?.cause === void 0 ? {} : { cause: options.cause },
+				...options?.details === void 0 ? {} : { details: options.details },
+				...options?.internal === void 0 ? {} : { internal: options.internal }
+			});
+			Object.defineProperty(error, catalogCodeKey, {
+				value: code,
+				enumerable: false,
+				writable: false,
+				configurable: true
+			});
+			return error;
+		});
+		Object.defineProperty(builder, "code", {
+			value: code,
+			enumerable: true
+		});
+		Object.defineProperty(builder, "match", {
+			value: (error) => readCatalogCode(error) === code,
+			enumerable: false
+		});
+		catalog[key] = builder;
+	}
+	return Object.freeze(catalog);
 }
+/**
+* Define a typed audit catalog. Returns typed action descriptors you can pass
+* to `track()` or audit helpers without scattering magic strings.
+*/
 function defineAuditCatalog(namespace, entries) {
-  const catalog = {};
-  for (const [key, entry] of Object.entries(entries)) {
-    const action = entry.action ?? `${namespace}.${key}`;
-    const severity = entry.severity ?? "info";
-    const descriptor = ((params) => {
-      const message = typeof entry.message === "function" ? entry.message(params) : entry.message;
-      return Object.freeze({
-        action,
-        severity,
-        ...message === void 0 ? {} : { message }
-      });
-    });
-    Object.defineProperty(descriptor, "action", {
-      value: action,
-      enumerable: true
-    });
-    Object.defineProperty(descriptor, "severity", {
-      value: severity,
-      enumerable: true
-    });
-    catalog[key] = descriptor;
-  }
-  return Object.freeze(catalog);
+	const catalog = {};
+	for (const [key, entry] of Object.entries(entries)) {
+		const action = entry.action ?? `${namespace}.${key}`;
+		const severity = entry.severity ?? "info";
+		const descriptor = ((params) => {
+			const message = typeof entry.message === "function" ? entry.message(params) : entry.message;
+			return Object.freeze({
+				action,
+				severity,
+				...message === void 0 ? {} : { message }
+			});
+		});
+		Object.defineProperty(descriptor, "action", {
+			value: action,
+			enumerable: true
+		});
+		Object.defineProperty(descriptor, "severity", {
+			value: severity,
+			enumerable: true
+		});
+		catalog[key] = descriptor;
+	}
+	return Object.freeze(catalog);
 }
 
-// src/drain-toolkit.ts
-var DEFAULT_TIMEOUT_MS = 5e3;
-var DEFAULT_RETRIES = 2;
+//#endregion
+//#region src/drain-toolkit.ts
+const DEFAULT_TIMEOUT_MS = 5e3;
+const DEFAULT_RETRIES = 2;
 function delay(ms) {
-  return new Promise((resolve) => {
-    const t = setTimeout(resolve, ms);
-    t.unref?.();
-  });
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms).unref?.();
+	});
 }
 async function postWithRetry(options) {
-  const { name, request: request2, timeoutMs, retries } = options;
-  const attempts = Math.max(1, retries);
-  let lastError;
-  for (let attempt = 1; attempt <= attempts; attempt++) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    timeout.unref?.();
-    try {
-      const response = await fetch(request2.url, {
-        method: "POST",
-        headers: request2.headers,
-        body: request2.body,
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        throw new Error(
-          `[autotel/${name}] HTTP ${response.status} draining ${request2.url}`
-        );
-      }
-      return;
-    } catch (error) {
-      lastError = error;
-      if (attempt < attempts) {
-        await delay(100 * attempt);
-      }
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-  throw lastError;
+	const { name, request, timeoutMs, retries } = options;
+	const attempts = Math.max(1, retries);
+	let lastError;
+	for (let attempt = 1; attempt <= attempts; attempt++) {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+		timeout.unref?.();
+		try {
+			const response = await fetch(request.url, {
+				method: "POST",
+				headers: request.headers,
+				body: request.body,
+				signal: controller.signal
+			});
+			if (!response.ok) throw new Error(`[autotel/${name}] HTTP ${response.status} draining ${request.url}`);
+			return;
+		} catch (error) {
+			lastError = error;
+			if (attempt < attempts) await delay(100 * attempt);
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
+	throw lastError;
 }
 function defineDrain(options) {
-  return async (ctx2) => {
-    const contexts = Array.isArray(ctx2) ? ctx2 : [ctx2];
-    if (contexts.length === 0) return;
-    const config = await options.resolve();
-    if (!config) return;
-    const payloads = options.transform ? options.transform(contexts) : contexts;
-    if (payloads.length === 0) return;
-    try {
-      await options.send(payloads, config);
-    } catch (error) {
-      console.error(`[autotel/${options.name}] drain failed:`, error);
-    }
-  };
+	return async (ctx) => {
+		const contexts = Array.isArray(ctx) ? ctx : [ctx];
+		if (contexts.length === 0) return;
+		const config = await options.resolve();
+		if (!config) return;
+		const payloads = options.transform ? options.transform(contexts) : contexts;
+		if (payloads.length === 0) return;
+		try {
+			await options.send(payloads, config);
+		} catch (error) {
+			console.error(`[autotel/${options.name}] drain failed:`, error);
+		}
+	};
 }
 function defineHttpDrain(options) {
-  return defineDrain({
-    name: options.name,
-    resolve: options.resolve,
-    transform: options.transform,
-    send: async (payloads, config) => {
-      const request2 = options.encode(payloads, config);
-      if (!request2) return;
-      const timeoutMs = options.resolveTimeoutMs?.(config) ?? options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-      const retries = options.resolveRetries?.(config) ?? options.retries ?? DEFAULT_RETRIES;
-      await postWithRetry({
-        name: options.name,
-        request: request2,
-        timeoutMs,
-        retries
-      });
-    }
-  });
+	return defineDrain({
+		name: options.name,
+		resolve: options.resolve,
+		transform: options.transform,
+		send: async (payloads, config) => {
+			const request = options.encode(payloads, config);
+			if (!request) return;
+			const timeoutMs = options.resolveTimeoutMs?.(config) ?? options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+			const retries = options.resolveRetries?.(config) ?? options.retries ?? DEFAULT_RETRIES;
+			await postWithRetry({
+				name: options.name,
+				request,
+				timeoutMs,
+				retries
+			});
+		}
+	});
 }
 
-// src/enricher-toolkit.ts
+//#endregion
+//#region src/enricher-toolkit.ts
 function isPlainObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function mergeInto2(target, source) {
-  for (const key in source) {
-    const sourceVal = source[key];
-    if (sourceVal === void 0) continue;
-    const targetVal = target[key];
-    if (isPlainObject(sourceVal) && isPlainObject(targetVal)) {
-      mergeInto2(targetVal, sourceVal);
-    } else {
-      target[key] = sourceVal;
-    }
-  }
+function mergeInto(target, source) {
+	for (const key in source) {
+		const sourceVal = source[key];
+		if (sourceVal === void 0) continue;
+		const targetVal = target[key];
+		if (isPlainObject(sourceVal) && isPlainObject(targetVal)) mergeInto(targetVal, sourceVal);
+		else target[key] = sourceVal;
+	}
 }
 function defineEnricher(def, options = {}) {
-  return (ctx2) => {
-    let computed;
-    try {
-      computed = def.compute(ctx2);
-    } catch (error) {
-      console.error(`[autotel/${def.name}] enrich failed:`, error);
-      return;
-    }
-    if (!computed) return;
-    if (options.overwrite || !isPlainObject(ctx2.event[def.field])) {
-      ctx2.event[def.field] = computed;
-      return;
-    }
-    mergeInto2(
-      ctx2.event[def.field],
-      computed
-    );
-  };
+	return (ctx) => {
+		let computed;
+		try {
+			computed = def.compute(ctx);
+		} catch (error) {
+			console.error(`[autotel/${def.name}] enrich failed:`, error);
+			return;
+		}
+		if (!computed) return;
+		if (options.overwrite || !isPlainObject(ctx.event[def.field])) {
+			ctx.event[def.field] = computed;
+			return;
+		}
+		mergeInto(ctx.event[def.field], computed);
+	};
 }
-var GEN_AI_DURATION_BUCKETS_SECONDS = Object.freeze(
-  [0.01, 0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 20, 30, 60, 120, 300]
-);
-var GEN_AI_TOKEN_USAGE_BUCKETS = Object.freeze([
-  1,
-  4,
-  16,
-  64,
-  256,
-  1024,
-  4096,
-  16384,
-  65536,
-  262144,
-  1048576,
-  4194304
+
+//#endregion
+//#region src/gen-ai-metrics.ts
+/**
+* LLM-tuned histogram buckets.
+*
+* Default OpenTelemetry histogram buckets target HTTP latency (0ms–10s)
+* and small counter values. LLM workloads have very different shapes:
+*
+*   - **Duration**: single-token prompts can be fast (50ms), long
+*     generations and reasoning models can run for minutes. Default buckets
+*     crush everything above 10s into one bucket.
+*   - **Token usage**: heavily right-skewed. A single request can range
+*     from tens of tokens to the million-token context windows.
+*   - **Cost (USD)**: per-request values are tiny (fractions of a cent),
+*     so linear buckets waste resolution at the low end.
+*
+* This module exposes empirically-chosen bucket arrays and a View helper
+* so users can apply them to their `MeterProvider` without knowing the
+* exact instrument names emitted by OpenAI/Anthropic/Traceloop plugins.
+*
+* @example
+* ```typescript
+* import { NodeSDK } from '@opentelemetry/sdk-node';
+* import { genAiMetricViews } from 'autotel';
+*
+* const sdk = new NodeSDK({
+*   serviceName: 'my-agent',
+*   views: [...genAiMetricViews()],
+* });
+* sdk.start();
+* ```
+*/
+/**
+* Duration buckets for LLM operations, in **seconds**. Covers fast
+* completions (50ms) through long-running reasoning jobs (5 min).
+*
+* Aligns with the OTel GenAI semantic conventions' published advice for
+* `gen_ai.client.operation.duration`.
+*/
+const GEN_AI_DURATION_BUCKETS_SECONDS = Object.freeze([
+	.01,
+	.05,
+	.1,
+	.25,
+	.5,
+	1,
+	2,
+	5,
+	10,
+	20,
+	30,
+	60,
+	120,
+	300
+]);
+/**
+* Token-count buckets for prompt, completion, and total token histograms.
+* Ranges from tiny prompts to million-token context windows.
+*
+* Aligns with the OTel GenAI semantic conventions' published advice for
+* `gen_ai.client.token.usage`.
+*/
+const GEN_AI_TOKEN_USAGE_BUCKETS = Object.freeze([
+	1,
+	4,
+	16,
+	64,
+	256,
+	1024,
+	4096,
+	16384,
+	65536,
+	262144,
+	1048576,
+	4194304
 ]);
-var GEN_AI_COST_USD_BUCKETS = Object.freeze([
-  1e-5,
-  1e-4,
-  1e-3,
-  5e-3,
-  0.01,
-  0.05,
-  0.1,
-  0.5,
-  1,
-  5,
-  10,
-  50
+/**
+* USD cost buckets. Sub-cent resolution at the low end (fractions of a
+* cent per small call) up to tens of dollars (batch jobs, Opus/o1 runs).
+*/
+const GEN_AI_COST_USD_BUCKETS = Object.freeze([
+	1e-5,
+	1e-4,
+	.001,
+	.005,
+	.01,
+	.05,
+	.1,
+	.5,
+	1,
+	5,
+	10,
+	50
 ]);
+/**
+* Instrument-level advice object for `createHistogram(name, advice)`.
+* Use when you control the instrument creation (e.g. custom business
+* LLM metrics); `genAiMetricViews()` is better when the metric comes
+* from a third-party plugin.
+*/
 function llmHistogramAdvice(kind) {
-  const boundaries = kind === "duration" ? GEN_AI_DURATION_BUCKETS_SECONDS : kind === "tokens" ? GEN_AI_TOKEN_USAGE_BUCKETS : GEN_AI_COST_USD_BUCKETS;
-  return { advice: { explicitBucketBoundaries: [...boundaries] } };
+	return { advice: { explicitBucketBoundaries: [...kind === "duration" ? GEN_AI_DURATION_BUCKETS_SECONDS : kind === "tokens" ? GEN_AI_TOKEN_USAGE_BUCKETS : GEN_AI_COST_USD_BUCKETS] } };
 }
+/**
+* Returns `View`s that re-bucket the standard OTel GenAI histograms. Pass
+* the result to your `MeterProvider`'s `views` option.
+*
+* Matches instrument names emitted by:
+* - OpenTelemetry GenAI autoinstrumentation
+* - OpenInference / OpenLLMetry (traceloop)
+* - Arize Phoenix, LangSmith, etc. that follow the OTel spec
+*
+* Add more instrument patterns via the `extra` argument if you emit
+* custom LLM metrics.
+*/
 function genAiMetricViews(extra = []) {
-  const defaults = [
-    { instrumentName: "gen_ai.client.operation.duration", kind: "duration" },
-    { instrumentName: "gen_ai.client.token.usage", kind: "tokens" },
-    // Autotel-emitted cost metric. No-op if you don't emit it.
-    { instrumentName: "gen_ai.client.cost.usd", kind: "cost" }
-  ];
-  return [...defaults, ...extra].map(
-    ({ instrumentName, kind }) => ({
-      instrumentName,
-      aggregation: {
-        type: sdkMetrics.AggregationType.EXPLICIT_BUCKET_HISTOGRAM,
-        options: {
-          boundaries: kind === "duration" ? [...GEN_AI_DURATION_BUCKETS_SECONDS] : kind === "tokens" ? [...GEN_AI_TOKEN_USAGE_BUCKETS] : [...GEN_AI_COST_USD_BUCKETS]
-        }
-      }
-    })
-  );
+	return [...[
+		{
+			instrumentName: "gen_ai.client.operation.duration",
+			kind: "duration"
+		},
+		{
+			instrumentName: "gen_ai.client.token.usage",
+			kind: "tokens"
+		},
+		{
+			instrumentName: "gen_ai.client.cost.usd",
+			kind: "cost"
+		}
+	], ...extra].map(({ instrumentName, kind }) => ({
+		instrumentName,
+		aggregation: {
+			type: _opentelemetry_sdk_metrics.AggregationType.EXPLICIT_BUCKET_HISTOGRAM,
+			options: { boundaries: kind === "duration" ? [...GEN_AI_DURATION_BUCKETS_SECONDS] : kind === "tokens" ? [...GEN_AI_TOKEN_USAGE_BUCKETS] : [...GEN_AI_COST_USD_BUCKETS] }
+		}
+	}));
 }
 
-// src/gen-ai-events.ts
-function recordPromptSent(ctx2, event = {}) {
-  chunk4P6ZOARG_cjs.emitCorrelatedEvent(ctx2, "gen_ai.prompt.sent", buildPromptSentAttrs(event));
+//#endregion
+//#region src/gen-ai-events.ts
+/**
+* Record that a prompt was dispatched to the provider. Typically called
+* before `await provider.chat.completions.create(...)`.
+*/
+function recordPromptSent(ctx, event = {}) {
+	require_correlated_events.emitCorrelatedEvent(ctx, "gen_ai.prompt.sent", buildPromptSentAttrs(event));
 }
-function recordResponseReceived(ctx2, event = {}) {
-  chunk4P6ZOARG_cjs.emitCorrelatedEvent(
-    ctx2,
-    "gen_ai.response.received",
-    buildResponseAttrs(event)
-  );
+/**
+* Record a successful provider response. Call after the response arrives
+* (for non-streaming) or after the stream completes.
+*/
+function recordResponseReceived(ctx, event = {}) {
+	require_correlated_events.emitCorrelatedEvent(ctx, "gen_ai.response.received", buildResponseAttrs(event));
 }
-function recordRetry(ctx2, event) {
-  chunk4P6ZOARG_cjs.emitCorrelatedEvent(ctx2, "gen_ai.retry", buildRetryAttrs(event));
+/**
+* Record a retry attempt on an LLM call. Call *before* sleeping for
+* `delayMs` so the event timestamp accurately marks when the retry
+* decision was made.
+*/
+function recordRetry(ctx, event) {
+	require_correlated_events.emitCorrelatedEvent(ctx, "gen_ai.retry", buildRetryAttrs(event));
 }
-function recordToolCall(ctx2, event) {
-  chunk4P6ZOARG_cjs.emitCorrelatedEvent(ctx2, "gen_ai.tool.call", buildToolCallAttrs(event));
+/**
+* Record a tool / function call made in the course of an agent step.
+* Emits an event rather than a child span because many frameworks fire
+* several tool calls within a single provider response.
+*/
+function recordToolCall(ctx, event) {
+	require_correlated_events.emitCorrelatedEvent(ctx, "gen_ai.tool.call", buildToolCallAttrs(event));
 }
-function recordStreamFirstToken(ctx2, event = {}) {
-  chunk4P6ZOARG_cjs.emitCorrelatedEvent(
-    ctx2,
-    "gen_ai.stream.first_token",
-    buildStreamFirstTokenAttrs(event)
-  );
+/**
+* Record the time-to-first-token for a streaming response. Pair with
+* `recordResponseReceived` at the end so the span carries both the TTFT
+* marker and the final usage numbers.
+*/
+function recordStreamFirstToken(ctx, event = {}) {
+	require_correlated_events.emitCorrelatedEvent(ctx, "gen_ai.stream.first_token", buildStreamFirstTokenAttrs(event));
 }
 function buildPromptSentAttrs(event) {
-  const attrs2 = {};
-  if (event.model) attrs2["gen_ai.request.model"] = event.model;
-  if (event.promptTokens !== void 0)
-    attrs2["gen_ai.usage.input_tokens"] = event.promptTokens;
-  if (event.messageCount !== void 0)
-    attrs2["gen_ai.request.message_count"] = event.messageCount;
-  if (event.operation) attrs2["gen_ai.operation.name"] = event.operation;
-  return attrs2;
+	const attrs = {};
+	if (event.model) attrs["gen_ai.request.model"] = event.model;
+	if (event.promptTokens !== void 0) attrs["gen_ai.usage.input_tokens"] = event.promptTokens;
+	if (event.messageCount !== void 0) attrs["gen_ai.request.message_count"] = event.messageCount;
+	if (event.operation) attrs["gen_ai.operation.name"] = event.operation;
+	return attrs;
 }
 function buildResponseAttrs(event) {
-  const attrs2 = {};
-  if (event.model) attrs2["gen_ai.response.model"] = event.model;
-  if (event.promptTokens !== void 0)
-    attrs2["gen_ai.usage.input_tokens"] = event.promptTokens;
-  if (event.completionTokens !== void 0)
-    attrs2["gen_ai.usage.output_tokens"] = event.completionTokens;
-  if (event.totalTokens !== void 0)
-    attrs2["gen_ai.usage.total_tokens"] = event.totalTokens;
-  if (event.finishReasons && event.finishReasons.length > 0) {
-    attrs2["gen_ai.response.finish_reasons"] = event.finishReasons.join(",");
-  }
-  return attrs2;
+	const attrs = {};
+	if (event.model) attrs["gen_ai.response.model"] = event.model;
+	if (event.promptTokens !== void 0) attrs["gen_ai.usage.input_tokens"] = event.promptTokens;
+	if (event.completionTokens !== void 0) attrs["gen_ai.usage.output_tokens"] = event.completionTokens;
+	if (event.totalTokens !== void 0) attrs["gen_ai.usage.total_tokens"] = event.totalTokens;
+	if (event.finishReasons && event.finishReasons.length > 0) attrs["gen_ai.response.finish_reasons"] = event.finishReasons.join(",");
+	return attrs;
 }
 function buildRetryAttrs(event) {
-  const attrs2 = { "retry.attempt": event.attempt };
-  if (event.reason) attrs2["retry.reason"] = event.reason;
-  if (event.delayMs !== void 0) attrs2["retry.delay_ms"] = event.delayMs;
-  if (event.statusCode !== void 0)
-    attrs2["http.response.status_code"] = event.statusCode;
-  return attrs2;
+	const attrs = { "retry.attempt": event.attempt };
+	if (event.reason) attrs["retry.reason"] = event.reason;
+	if (event.delayMs !== void 0) attrs["retry.delay_ms"] = event.delayMs;
+	if (event.statusCode !== void 0) attrs["http.response.status_code"] = event.statusCode;
+	return attrs;
 }
 function buildToolCallAttrs(event) {
-  const attrs2 = { "gen_ai.tool.name": event.toolName };
-  if (event.toolCallId) attrs2["gen_ai.tool.call.id"] = event.toolCallId;
-  if (event.arguments) attrs2["gen_ai.tool.arguments"] = event.arguments;
-  return attrs2;
+	const attrs = { "gen_ai.tool.name": event.toolName };
+	if (event.toolCallId) attrs["gen_ai.tool.call.id"] = event.toolCallId;
+	if (event.arguments) attrs["gen_ai.tool.arguments"] = event.arguments;
+	return attrs;
 }
 function buildStreamFirstTokenAttrs(event) {
-  const attrs2 = {};
-  if (event.tokensSoFar !== void 0)
-    attrs2["gen_ai.stream.tokens_so_far"] = event.tokensSoFar;
-  return attrs2;
+	const attrs = {};
+	if (event.tokensSoFar !== void 0) attrs["gen_ai.stream.tokens_so_far"] = event.tokensSoFar;
+	return attrs;
 }
 
-// src/gen-ai-cost.ts
-var GEN_AI_COST_ATTRIBUTE = "gen_ai.usage.cost.usd";
-var MODEL_PRICING = {
-  // OpenAI
-  "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10 },
-  "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6 },
-  "gpt-4.1": { inputPer1M: 2, outputPer1M: 8 },
-  "gpt-4.1-mini": { inputPer1M: 0.4, outputPer1M: 1.6 },
-  "gpt-4.1-nano": { inputPer1M: 0.1, outputPer1M: 0.4 },
-  "o3-mini": { inputPer1M: 1.1, outputPer1M: 4.4 },
-  // Anthropic Claude
-  "claude-opus-4": { inputPer1M: 15, outputPer1M: 75 },
-  "claude-sonnet-4": { inputPer1M: 3, outputPer1M: 15 },
-  "claude-3-5-sonnet": { inputPer1M: 3, outputPer1M: 15 },
-  "claude-3-5-haiku": { inputPer1M: 0.8, outputPer1M: 4 },
-  "claude-3-opus": { inputPer1M: 15, outputPer1M: 75 },
-  "claude-3-haiku": { inputPer1M: 0.25, outputPer1M: 1.25 },
-  // Google Gemini
-  "gemini-1.5-pro": { inputPer1M: 1.25, outputPer1M: 5 },
-  "gemini-1.5-flash": { inputPer1M: 0.075, outputPer1M: 0.3 },
-  "gemini-2.0-flash": { inputPer1M: 0.1, outputPer1M: 0.4 }
+//#endregion
+//#region src/gen-ai-cost.ts
+/** Span attribute key autotel sets for an estimated call cost. */
+const GEN_AI_COST_ATTRIBUTE = "gen_ai.usage.cost.usd";
+/**
+* Approximate public list prices (USD per 1M tokens) at the time of writing.
+* Prices change; treat these as convenience defaults, not a billing source of
+* truth. Override per call via `options.pricing` or mutate this table at init.
+* Matching is exact first, then by longest key prefix, so versioned model ids
+* (`claude-sonnet-4-6-20251101`) resolve to a base entry (`claude-sonnet-4-6`).
+*/
+const MODEL_PRICING = {
+	"gpt-4o": {
+		inputPer1M: 2.5,
+		outputPer1M: 10
+	},
+	"gpt-4o-mini": {
+		inputPer1M: .15,
+		outputPer1M: .6
+	},
+	"gpt-4.1": {
+		inputPer1M: 2,
+		outputPer1M: 8
+	},
+	"gpt-4.1-mini": {
+		inputPer1M: .4,
+		outputPer1M: 1.6
+	},
+	"gpt-4.1-nano": {
+		inputPer1M: .1,
+		outputPer1M: .4
+	},
+	"o3-mini": {
+		inputPer1M: 1.1,
+		outputPer1M: 4.4
+	},
+	"claude-opus-4": {
+		inputPer1M: 15,
+		outputPer1M: 75
+	},
+	"claude-sonnet-4": {
+		inputPer1M: 3,
+		outputPer1M: 15
+	},
+	"claude-3-5-sonnet": {
+		inputPer1M: 3,
+		outputPer1M: 15
+	},
+	"claude-3-5-haiku": {
+		inputPer1M: .8,
+		outputPer1M: 4
+	},
+	"claude-3-opus": {
+		inputPer1M: 15,
+		outputPer1M: 75
+	},
+	"claude-3-haiku": {
+		inputPer1M: .25,
+		outputPer1M: 1.25
+	},
+	"gemini-1.5-pro": {
+		inputPer1M: 1.25,
+		outputPer1M: 5
+	},
+	"gemini-1.5-flash": {
+		inputPer1M: .075,
+		outputPer1M: .3
+	},
+	"gemini-2.0-flash": {
+		inputPer1M: .1,
+		outputPer1M: .4
+	}
 };
 function resolvePricing(table, model) {
-  const exact = table[model];
-  if (exact) return exact;
-  let best;
-  let bestLength = 0;
-  for (const key of Object.keys(table)) {
-    if (model.startsWith(key) && key.length > bestLength) {
-      best = table[key];
-      bestLength = key.length;
-    }
-  }
-  return best;
+	const exact = table[model];
+	if (exact) return exact;
+	let best;
+	let bestLength = 0;
+	for (const key of Object.keys(table)) if (model.startsWith(key) && key.length > bestLength) {
+		best = table[key];
+		bestLength = key.length;
+	}
+	return best;
 }
 function round(value) {
-  return Math.round(value * 1e6) / 1e6;
+	return Math.round(value * 1e6) / 1e6;
 }
+/**
+* Estimate the USD cost of an LLM call. Returns `undefined` when the model has
+* no known pricing (supply one via `options.pricing`).
+*/
 function estimateLLMCost(model, usage, options) {
-  const table = options?.pricing ? { ...MODEL_PRICING, ...options.pricing } : MODEL_PRICING;
-  const price = resolvePricing(table, model);
-  if (!price) return void 0;
-  const cachedInput = usage.cachedInputTokens ?? 0;
-  const billedInput = Math.max(0, (usage.inputTokens ?? 0) - cachedInput);
-  const output = usage.outputTokens ?? 0;
-  const cachedRate = price.cachedInputPer1M ?? price.inputPer1M;
-  const cost = billedInput / 1e6 * price.inputPer1M + cachedInput / 1e6 * cachedRate + output / 1e6 * price.outputPer1M;
-  return round(cost);
+	const price = resolvePricing(options?.pricing ? {
+		...MODEL_PRICING,
+		...options.pricing
+	} : MODEL_PRICING, model);
+	if (!price) return void 0;
+	const cachedInput = usage.cachedInputTokens ?? 0;
+	const billedInput = Math.max(0, (usage.inputTokens ?? 0) - cachedInput);
+	const output = usage.outputTokens ?? 0;
+	const cachedRate = price.cachedInputPer1M ?? price.inputPer1M;
+	return round(billedInput / 1e6 * price.inputPer1M + cachedInput / 1e6 * cachedRate + output / 1e6 * price.outputPer1M);
 }
-function recordLLMCost(ctx2, model, usage, options) {
-  const cost = estimateLLMCost(model, usage, options);
-  if (cost !== void 0) {
-    ctx2.setAttribute(GEN_AI_COST_ATTRIBUTE, cost);
-  }
-  return cost;
+/**
+* Estimate cost and record it on `ctx` as the `gen_ai.usage.cost.usd` span
+* attribute. Returns the estimated cost, or `undefined` when the model is
+* unknown (in which case no attribute is set).
+*/
+function recordLLMCost(ctx, model, usage, options) {
+	const cost = estimateLLMCost(model, usage, options);
+	if (cost !== void 0) ctx.setAttribute(GEN_AI_COST_ATTRIBUTE, cost);
+	return cost;
 }
 
-Object.defineProperty(exports, "httpRequestHeaderAttribute", {
-  enumerable: true,
-  get: function () { return chunk2ZKEORFN_cjs.httpRequestHeaderAttribute; }
-});
-Object.defineProperty(exports, "httpResponseHeaderAttribute", {
-  enumerable: true,
-  get: function () { return chunk2ZKEORFN_cjs.httpResponseHeaderAttribute; }
-});
-Object.defineProperty(exports, "parseError", {
-  enumerable: true,
-  get: function () { return chunkT4B5LB6E_cjs.parseError; }
-});
-Object.defineProperty(exports, "createDrainPipeline", {
-  enumerable: true,
-  get: function () { return chunk7EQ4G4SI_cjs.createDrainPipeline; }
-});
-Object.defineProperty(exports, "getCurrentWorkflowContext", {
-  enumerable: true,
-  get: function () { return chunkNENU7E6V_cjs.getCurrentWorkflowContext; }
-});
-Object.defineProperty(exports, "isInWorkflow", {
-  enumerable: true,
-  get: function () { return chunkNENU7E6V_cjs.isInWorkflow; }
-});
-Object.defineProperty(exports, "traceStep", {
-  enumerable: true,
-  get: function () { return chunkNENU7E6V_cjs.traceStep; }
-});
-Object.defineProperty(exports, "traceWorkflow", {
-  enumerable: true,
-  get: function () { return chunkNENU7E6V_cjs.traceWorkflow; }
-});
-Object.defineProperty(exports, "attrs", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.attrs; }
-});
-Object.defineProperty(exports, "autoRedactPII", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.autoRedactPII; }
-});
-Object.defineProperty(exports, "dbClient", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.dbClient; }
-});
-Object.defineProperty(exports, "httpClient", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.httpClient; }
-});
-Object.defineProperty(exports, "httpServer", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.httpServer; }
-});
-Object.defineProperty(exports, "identify", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.identify; }
-});
-Object.defineProperty(exports, "mergeAttrs", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.mergeAttrs; }
-});
-Object.defineProperty(exports, "mergeServiceResource", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.mergeServiceResource; }
-});
-Object.defineProperty(exports, "request", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.request; }
-});
-Object.defineProperty(exports, "safeSetAttributes", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.safeSetAttributes; }
-});
-Object.defineProperty(exports, "setDevice", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.setDevice; }
-});
-Object.defineProperty(exports, "setError", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.setError; }
-});
-Object.defineProperty(exports, "setException", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.setException; }
-});
-Object.defineProperty(exports, "setSession", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.setSession; }
-});
-Object.defineProperty(exports, "setUser", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.setUser; }
-});
-Object.defineProperty(exports, "validateAttribute", {
-  enumerable: true,
-  get: function () { return chunkM3LFHHTN_cjs.validateAttribute; }
-});
-Object.defineProperty(exports, "HTTPAttributes", {
-  enumerable: true,
-  get: function () { return chunkESMHTKLJ_cjs.HTTPAttributes; }
-});
-Object.defineProperty(exports, "ServiceAttributes", {
-  enumerable: true,
-  get: function () { return chunkESMHTKLJ_cjs.ServiceAttributes; }
-});
-Object.defineProperty(exports, "URLAttributes", {
-  enumerable: true,
-  get: function () { return chunkESMHTKLJ_cjs.URLAttributes; }
-});
-Object.defineProperty(exports, "traceConsumer", {
-  enumerable: true,
-  get: function () { return chunkB7SWBE4P_cjs.traceConsumer; }
-});
-Object.defineProperty(exports, "traceProducer", {
-  enumerable: true,
-  get: function () { return chunkB7SWBE4P_cjs.traceProducer; }
-});
-Object.defineProperty(exports, "BusinessBaggage", {
-  enumerable: true,
-  get: function () { return chunkINJD3G4K_cjs.BusinessBaggage; }
-});
-Object.defineProperty(exports, "createSafeBaggageSchema", {
-  enumerable: true,
-  get: function () { return chunkINJD3G4K_cjs.createSafeBaggageSchema; }
-});
-Object.defineProperty(exports, "Metric", {
-  enumerable: true,
-  get: function () { return chunkTC5ZPWM4_cjs.Metric; }
-});
-Object.defineProperty(exports, "getMetrics", {
-  enumerable: true,
-  get: function () { return chunkTC5ZPWM4_cjs.getMetrics; }
-});
-Object.defineProperty(exports, "resetMetrics", {
-  enumerable: true,
-  get: function () { return chunkTC5ZPWM4_cjs.resetMetrics; }
-});
-Object.defineProperty(exports, "createCounter", {
-  enumerable: true,
-  get: function () { return chunkWJH6IYU2_cjs.createCounter; }
-});
-Object.defineProperty(exports, "createHistogram", {
-  enumerable: true,
-  get: function () { return chunkWJH6IYU2_cjs.createHistogram; }
-});
-Object.defineProperty(exports, "createObservableGauge", {
-  enumerable: true,
-  get: function () { return chunkWJH6IYU2_cjs.createObservableGauge; }
-});
-Object.defineProperty(exports, "createUpDownCounter", {
-  enumerable: true,
-  get: function () { return chunkWJH6IYU2_cjs.createUpDownCounter; }
-});
-Object.defineProperty(exports, "getMeter", {
-  enumerable: true,
-  get: function () { return chunkWJH6IYU2_cjs.getMeter; }
-});
-Object.defineProperty(exports, "traceDB", {
-  enumerable: true,
-  get: function () { return chunkKYXZS3EA_cjs.traceDB; }
-});
-Object.defineProperty(exports, "traceHTTP", {
-  enumerable: true,
-  get: function () { return chunkKYXZS3EA_cjs.traceHTTP; }
-});
-Object.defineProperty(exports, "traceLLM", {
-  enumerable: true,
-  get: function () { return chunkKYXZS3EA_cjs.traceLLM; }
-});
-Object.defineProperty(exports, "traceMessaging", {
-  enumerable: true,
-  get: function () { return chunkKYXZS3EA_cjs.traceMessaging; }
-});
-Object.defineProperty(exports, "ctx", {
-  enumerable: true,
-  get: function () { return chunkV7UBMJAB_cjs.ctx; }
-});
-Object.defineProperty(exports, "instrument", {
-  enumerable: true,
-  get: function () { return chunkV7UBMJAB_cjs.instrument; }
-});
-Object.defineProperty(exports, "markAsImmediate", {
-  enumerable: true,
-  get: function () { return chunkV7UBMJAB_cjs.markAsImmediate; }
-});
-Object.defineProperty(exports, "span", {
-  enumerable: true,
-  get: function () { return chunkV7UBMJAB_cjs.span; }
-});
-Object.defineProperty(exports, "withBaggage", {
-  enumerable: true,
-  get: function () { return chunkV7UBMJAB_cjs.withBaggage; }
-});
-Object.defineProperty(exports, "withNewContext", {
-  enumerable: true,
-  get: function () { return chunkV7UBMJAB_cjs.withNewContext; }
-});
-Object.defineProperty(exports, "withTracing", {
-  enumerable: true,
-  get: function () { return chunkV7UBMJAB_cjs.withTracing; }
-});
-Object.defineProperty(exports, "createDeterministicTraceId", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.createDeterministicTraceId; }
-});
-Object.defineProperty(exports, "enrichWithTraceContext", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.enrichWithTraceContext; }
-});
-Object.defineProperty(exports, "finalizeSpan", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.finalizeSpan; }
-});
-Object.defineProperty(exports, "flattenMetadata", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.flattenMetadata; }
-});
-Object.defineProperty(exports, "getActiveContext", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.getActiveContext; }
-});
-Object.defineProperty(exports, "getActiveSpan", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.getActiveSpan; }
-});
-Object.defineProperty(exports, "getTraceContext", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.getTraceContext; }
-});
-Object.defineProperty(exports, "getTracer", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.getTracer; }
-});
-Object.defineProperty(exports, "isTracing", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.isTracing; }
-});
-Object.defineProperty(exports, "resolveTraceUrl", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.resolveTraceUrl; }
-});
-Object.defineProperty(exports, "runWithSpan", {
-  enumerable: true,
-  get: function () { return chunkOPPXYVEZ_cjs.runWithSpan; }
-});
-Object.defineProperty(exports, "Event", {
-  enumerable: true,
-  get: function () { return chunkEOFB7XCL_cjs.Event; }
-});
-Object.defineProperty(exports, "getEvents", {
-  enumerable: true,
-  get: function () { return chunkEOFB7XCL_cjs.getEvents; }
-});
-Object.defineProperty(exports, "resetEvents", {
-  enumerable: true,
-  get: function () { return chunkEOFB7XCL_cjs.resetEvents; }
-});
-Object.defineProperty(exports, "getOperationContext", {
-  enumerable: true,
-  get: function () { return chunkVQTCQKHQ_cjs.getOperationContext; }
-});
-Object.defineProperty(exports, "runInOperationContext", {
-  enumerable: true,
-  get: function () { return chunkVQTCQKHQ_cjs.runInOperationContext; }
-});
-Object.defineProperty(exports, "CORRELATION_ID_BAGGAGE_KEY", {
-  enumerable: true,
-  get: function () { return chunkFMTHVSYY_cjs.CORRELATION_ID_BAGGAGE_KEY; }
-});
-Object.defineProperty(exports, "defineBaggageSchema", {
-  enumerable: true,
-  get: function () { return chunkFMTHVSYY_cjs.defineBaggageSchema; }
-});
-Object.defineProperty(exports, "generateCorrelationId", {
-  enumerable: true,
-  get: function () { return chunkFMTHVSYY_cjs.generateCorrelationId; }
-});
-Object.defineProperty(exports, "getCorrelationId", {
-  enumerable: true,
-  get: function () { return chunkFMTHVSYY_cjs.getCorrelationId; }
-});
-Object.defineProperty(exports, "getEventQueue", {
-  enumerable: true,
-  get: function () { return chunkFMTHVSYY_cjs.getEventQueue; }
-});
-Object.defineProperty(exports, "getOrCreateCorrelationId", {
-  enumerable: true,
-  get: function () { return chunkFMTHVSYY_cjs.getOrCreateCorrelationId; }
-});
-Object.defineProperty(exports, "runWithCorrelationId", {
-  enumerable: true,
-  get: function () { return chunkFMTHVSYY_cjs.runWithCorrelationId; }
-});
-Object.defineProperty(exports, "setCorrelationId", {
-  enumerable: true,
-  get: function () { return chunkFMTHVSYY_cjs.setCorrelationId; }
-});
-Object.defineProperty(exports, "setCorrelationIdInBaggage", {
-  enumerable: true,
-  get: function () { return chunkFMTHVSYY_cjs.setCorrelationIdInBaggage; }
-});
-Object.defineProperty(exports, "track", {
-  enumerable: true,
-  get: function () { return chunkFMTHVSYY_cjs.track; }
-});
-Object.defineProperty(exports, "createStructuredError", {
-  enumerable: true,
-  get: function () { return chunkEE6CPXKH_cjs.createStructuredError; }
-});
-Object.defineProperty(exports, "flattenToAttributes", {
-  enumerable: true,
-  get: function () { return chunkEE6CPXKH_cjs.flattenToAttributes; }
-});
-Object.defineProperty(exports, "getStructuredErrorAttributes", {
-  enumerable: true,
-  get: function () { return chunkEE6CPXKH_cjs.getStructuredErrorAttributes; }
-});
-Object.defineProperty(exports, "recordStructuredError", {
-  enumerable: true,
-  get: function () { return chunkEE6CPXKH_cjs.recordStructuredError; }
-});
-Object.defineProperty(exports, "structuredErrorToJSON", {
-  enumerable: true,
-  get: function () { return chunkEE6CPXKH_cjs.structuredErrorToJSON; }
-});
-Object.defineProperty(exports, "toAttributeValue", {
-  enumerable: true,
-  get: function () { return chunkEE6CPXKH_cjs.toAttributeValue; }
-});
-Object.defineProperty(exports, "BaggageSpanProcessor", {
-  enumerable: true,
-  get: function () { return chunkR7QYGZUP_cjs.BaggageSpanProcessor; }
-});
-Object.defineProperty(exports, "createStringRedactor", {
-  enumerable: true,
-  get: function () { return chunkR7QYGZUP_cjs.createStringRedactor; }
-});
-Object.defineProperty(exports, "init", {
-  enumerable: true,
-  get: function () { return chunkR7QYGZUP_cjs.init; }
-});
-Object.defineProperty(exports, "isInitialized", {
-  enumerable: true,
-  get: function () { return chunkR7QYGZUP_cjs.isInitialized; }
-});
-Object.defineProperty(exports, "isLoggerLocked", {
-  enumerable: true,
-  get: function () { return chunkR7QYGZUP_cjs.isLoggerLocked; }
-});
-Object.defineProperty(exports, "lockLogger", {
-  enumerable: true,
-  get: function () { return chunkR7QYGZUP_cjs.lockLogger; }
-});
-Object.defineProperty(exports, "FilteringSpanProcessor", {
-  enumerable: true,
-  get: function () { return chunkZNMBW67B_cjs.FilteringSpanProcessor; }
-});
-Object.defineProperty(exports, "NORMALIZER_PATTERNS", {
-  enumerable: true,
-  get: function () { return chunkIOYFAFHJ_cjs.NORMALIZER_PATTERNS; }
-});
-Object.defineProperty(exports, "NORMALIZER_PRESETS", {
-  enumerable: true,
-  get: function () { return chunkIOYFAFHJ_cjs.NORMALIZER_PRESETS; }
-});
-Object.defineProperty(exports, "SpanNameNormalizingProcessor", {
-  enumerable: true,
-  get: function () { return chunkIOYFAFHJ_cjs.SpanNameNormalizingProcessor; }
-});
-Object.defineProperty(exports, "AttributeRedactingProcessor", {
-  enumerable: true,
-  get: function () { return chunkNEIB3TLD_cjs.AttributeRedactingProcessor; }
-});
-Object.defineProperty(exports, "REDACTOR_PATTERNS", {
-  enumerable: true,
-  get: function () { return chunkNEIB3TLD_cjs.REDACTOR_PATTERNS; }
-});
-Object.defineProperty(exports, "REDACTOR_PRESETS", {
-  enumerable: true,
-  get: function () { return chunkNEIB3TLD_cjs.REDACTOR_PRESETS; }
-});
-Object.defineProperty(exports, "builtinPatterns", {
-  enumerable: true,
-  get: function () { return chunkNEIB3TLD_cjs.builtinPatterns; }
-});
-Object.defineProperty(exports, "createAttributeRedactor", {
-  enumerable: true,
-  get: function () { return chunkNEIB3TLD_cjs.createAttributeRedactor; }
-});
-Object.defineProperty(exports, "createRedactedSpan", {
-  enumerable: true,
-  get: function () { return chunkNEIB3TLD_cjs.createRedactedSpan; }
-});
-Object.defineProperty(exports, "normalizeAttributeRedactorConfig", {
-  enumerable: true,
-  get: function () { return chunkNEIB3TLD_cjs.normalizeAttributeRedactorConfig; }
-});
-Object.defineProperty(exports, "formatDuration", {
-  enumerable: true,
-  get: function () { return chunk6S5RUKU3_cjs.formatDuration; }
-});
-Object.defineProperty(exports, "AUTOTEL_SAMPLING_TAIL_EVALUATED", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.AUTOTEL_SAMPLING_TAIL_EVALUATED; }
-});
-Object.defineProperty(exports, "AUTOTEL_SAMPLING_TAIL_KEEP", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.AUTOTEL_SAMPLING_TAIL_KEEP; }
-});
-Object.defineProperty(exports, "AdaptiveSampler", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.AdaptiveSampler; }
-});
-Object.defineProperty(exports, "AlwaysSampler", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.AlwaysSampler; }
-});
-Object.defineProperty(exports, "NeverSampler", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.NeverSampler; }
-});
-Object.defineProperty(exports, "RandomSampler", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.RandomSampler; }
-});
-Object.defineProperty(exports, "UserIdSampler", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.UserIdSampler; }
-});
-Object.defineProperty(exports, "createLinkFromHeaders", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.createLinkFromHeaders; }
-});
-Object.defineProperty(exports, "extractLinksFromBatch", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.extractLinksFromBatch; }
-});
-Object.defineProperty(exports, "resolveSamplingPreset", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.resolveSamplingPreset; }
-});
-Object.defineProperty(exports, "samplingPresets", {
-  enumerable: true,
-  get: function () { return chunkVH77IPJN_cjs.samplingPresets; }
-});
-Object.defineProperty(exports, "getAutotelTracer", {
-  enumerable: true,
-  get: function () { return chunkYREV3LGG_cjs.getAutotelTracer; }
-});
-Object.defineProperty(exports, "getAutotelTracerProvider", {
-  enumerable: true,
-  get: function () { return chunkYREV3LGG_cjs.getAutotelTracerProvider; }
-});
-Object.defineProperty(exports, "setAutotelTracerProvider", {
-  enumerable: true,
-  get: function () { return chunkYREV3LGG_cjs.setAutotelTracerProvider; }
-});
-Object.defineProperty(exports, "ROOT_CONTEXT", {
-  enumerable: true,
-  get: function () { return api.ROOT_CONTEXT; }
-});
-Object.defineProperty(exports, "SpanKind", {
-  enumerable: true,
-  get: function () { return api.SpanKind; }
-});
-Object.defineProperty(exports, "SpanStatusCode", {
-  enumerable: true,
-  get: function () { return api.SpanStatusCode; }
+//#endregion
+exports.AUTOTEL_SAMPLING_TAIL_EVALUATED = require_sampling.AUTOTEL_SAMPLING_TAIL_EVALUATED;
+exports.AUTOTEL_SAMPLING_TAIL_KEEP = require_sampling.AUTOTEL_SAMPLING_TAIL_KEEP;
+exports.AdaptiveSampler = require_sampling.AdaptiveSampler;
+exports.AlwaysSampler = require_sampling.AlwaysSampler;
+exports.AttributeRedactingProcessor = require_attribute_redacting_processor.AttributeRedactingProcessor;
+exports.BaggageSpanProcessor = require_init.BaggageSpanProcessor;
+exports.BusinessBaggage = require_business_baggage.BusinessBaggage;
+exports.CORRELATION_ID_BAGGAGE_KEY = require_track.CORRELATION_ID_BAGGAGE_KEY;
+exports.Event = require_event.Event;
+exports.FilteringSpanProcessor = require_filtering_span_processor.FilteringSpanProcessor;
+exports.GEN_AI_COST_ATTRIBUTE = GEN_AI_COST_ATTRIBUTE;
+exports.GEN_AI_COST_USD_BUCKETS = GEN_AI_COST_USD_BUCKETS;
+exports.GEN_AI_DURATION_BUCKETS_SECONDS = GEN_AI_DURATION_BUCKETS_SECONDS;
+exports.GEN_AI_TOKEN_USAGE_BUCKETS = GEN_AI_TOKEN_USAGE_BUCKETS;
+exports.HTTPAttributes = require_registry.HTTPAttributes;
+exports.MODEL_PRICING = MODEL_PRICING;
+exports.Metric = require_metric.Metric;
+exports.NORMALIZER_PATTERNS = require_span_name_normalizer.NORMALIZER_PATTERNS;
+exports.NORMALIZER_PRESETS = require_span_name_normalizer.NORMALIZER_PRESETS;
+exports.NeverSampler = require_sampling.NeverSampler;
+exports.REDACTOR_PATTERNS = require_attribute_redacting_processor.REDACTOR_PATTERNS;
+exports.REDACTOR_PRESETS = require_attribute_redacting_processor.REDACTOR_PRESETS;
+Object.defineProperty(exports, 'ROOT_CONTEXT', {
+  enumerable: true,
+  get: function () {
+    return _opentelemetry_api.ROOT_CONTEXT;
+  }
 });
-Object.defineProperty(exports, "context", {
+exports.RandomSampler = require_sampling.RandomSampler;
+exports.ServiceAttributes = require_registry.ServiceAttributes;
+Object.defineProperty(exports, 'SpanKind', {
   enumerable: true,
-  get: function () { return api.context; }
+  get: function () {
+    return _opentelemetry_api.SpanKind;
+  }
 });
-Object.defineProperty(exports, "otelTrace", {
+exports.SpanNameNormalizingProcessor = require_span_name_normalizer.SpanNameNormalizingProcessor;
+Object.defineProperty(exports, 'SpanStatusCode', {
   enumerable: true,
-  get: function () { return api.trace; }
+  get: function () {
+    return _opentelemetry_api.SpanStatusCode;
+  }
 });
-Object.defineProperty(exports, "propagation", {
+exports.URLAttributes = require_registry.URLAttributes;
+exports.UserIdSampler = require_sampling.UserIdSampler;
+exports.attrs = require_attributes.attrs;
+exports.autoRedactPII = require_attributes.autoRedactPII;
+exports.builtinPatterns = require_attribute_redacting_processor.builtinPatterns;
+Object.defineProperty(exports, 'context', {
   enumerable: true,
-  get: function () { return api.propagation; }
+  get: function () {
+    return _opentelemetry_api.context;
+  }
 });
-exports.GEN_AI_COST_ATTRIBUTE = GEN_AI_COST_ATTRIBUTE;
-exports.GEN_AI_COST_USD_BUCKETS = GEN_AI_COST_USD_BUCKETS;
-exports.GEN_AI_DURATION_BUCKETS_SECONDS = GEN_AI_DURATION_BUCKETS_SECONDS;
-exports.GEN_AI_TOKEN_USAGE_BUCKETS = GEN_AI_TOKEN_USAGE_BUCKETS;
-exports.MODEL_PRICING = MODEL_PRICING;
+exports.createAttributeRedactor = require_attribute_redacting_processor.createAttributeRedactor;
+exports.createCounter = require_metric_helpers.createCounter;
+exports.createDeterministicTraceId = require_trace_helpers.createDeterministicTraceId;
+exports.createDrainPipeline = require_drain_pipeline.createDrainPipeline;
+exports.createHistogram = require_metric_helpers.createHistogram;
+exports.createLinkFromHeaders = require_sampling.createLinkFromHeaders;
+exports.createNoopRequestLogger = createNoopRequestLogger;
+exports.createObservableGauge = require_metric_helpers.createObservableGauge;
+exports.createRedactedSpan = require_attribute_redacting_processor.createRedactedSpan;
+exports.createSafeBaggageSchema = require_business_baggage.createSafeBaggageSchema;
+exports.createStringRedactor = require_init.createStringRedactor;
+exports.createStructuredError = require_structured_error.createStructuredError;
+exports.createUpDownCounter = require_metric_helpers.createUpDownCounter;
+exports.ctx = require_functional.ctx;
+exports.dbClient = require_attributes.dbClient;
 exports.defineAuditCatalog = defineAuditCatalog;
+exports.defineBaggageSchema = require_track.defineBaggageSchema;
 exports.defineDrain = defineDrain;
 exports.defineEnricher = defineEnricher;
 exports.defineErrorCatalog = defineErrorCatalog;
 exports.defineEvent = defineEvent;
 exports.defineHttpDrain = defineHttpDrain;
+exports.enrichWithTraceContext = require_trace_helpers.enrichWithTraceContext;
 exports.estimateLLMCost = estimateLLMCost;
+exports.extractLinksFromBatch = require_sampling.extractLinksFromBatch;
+exports.finalizeSpan = require_trace_helpers.finalizeSpan;
+exports.flattenMetadata = require_trace_helpers.flattenMetadata;
+exports.flattenToAttributes = require_structured_error.flattenToAttributes;
 exports.flush = flush;
+exports.formatDuration = require_canonical_log_line_processor.formatDuration;
 exports.genAiMetricViews = genAiMetricViews;
+exports.generateCorrelationId = require_track.generateCorrelationId;
+exports.getActiveContext = require_trace_helpers.getActiveContext;
+exports.getActiveSpan = require_trace_helpers.getActiveSpan;
+exports.getAutotelTracer = require_tracer_provider.getAutotelTracer;
+exports.getAutotelTracerProvider = require_tracer_provider.getAutotelTracerProvider;
 exports.getCatalogCode = getCatalogCode;
+exports.getCorrelationId = require_track.getCorrelationId;
+exports.getCurrentWorkflowContext = require_workflow.getCurrentWorkflowContext;
+exports.getEventQueue = require_track.getEventQueue;
+exports.getEvents = require_event.getEvents;
+exports.getMeter = require_metric_helpers.getMeter;
+exports.getMetrics = require_metric.getMetrics;
+exports.getOperationContext = require_operation_context.getOperationContext;
+exports.getOrCreateCorrelationId = require_track.getOrCreateCorrelationId;
 exports.getRequestLogger = getRequestLogger;
+exports.getRequestLoggerSafe = getRequestLoggerSafe;
+exports.getStructuredErrorAttributes = require_structured_error.getStructuredErrorAttributes;
+exports.getTraceContext = require_trace_helpers.getTraceContext;
+exports.getTracer = require_trace_helpers.getTracer;
+exports.hasRequestContext = hasRequestContext;
+exports.httpClient = require_attributes.httpClient;
+exports.httpRequestHeaderAttribute = require_semantic_conventions.httpRequestHeaderAttribute;
+exports.httpResponseHeaderAttribute = require_semantic_conventions.httpResponseHeaderAttribute;
+exports.httpServer = require_attributes.httpServer;
+exports.identify = require_attributes.identify;
+exports.init = require_init.init;
+exports.instrument = require_functional.instrument;
 exports.isCatalogError = isCatalogError;
+exports.isInWorkflow = require_workflow.isInWorkflow;
+exports.isInitialized = require_init.isInitialized;
+exports.isLoggerLocked = require_init.isLoggerLocked;
+exports.isTracing = require_trace_helpers.isTracing;
 exports.llmHistogramAdvice = llmHistogramAdvice;
+exports.lockLogger = require_init.lockLogger;
+exports.markAsImmediate = require_functional.markAsImmediate;
+exports.mergeAttrs = require_attributes.mergeAttrs;
+exports.mergeServiceResource = require_attributes.mergeServiceResource;
+exports.normalizeAttributeRedactorConfig = require_attribute_redacting_processor.normalizeAttributeRedactorConfig;
+Object.defineProperty(exports, 'otelTrace', {
+  enumerable: true,
+  get: function () {
+    return _opentelemetry_api.trace;
+  }
+});
+exports.parseError = require_parse_error.parseError;
+Object.defineProperty(exports, 'propagation', {
+  enumerable: true,
+  get: function () {
+    return _opentelemetry_api.propagation;
+  }
+});
 exports.recordLLMCost = recordLLMCost;
 exports.recordPromptSent = recordPromptSent;
 exports.recordResponseReceived = recordResponseReceived;
 exports.recordRetry = recordRetry;
 exports.recordStreamFirstToken = recordStreamFirstToken;
+exports.recordStructuredError = require_structured_error.recordStructuredError;
 exports.recordToolCall = recordToolCall;
+exports.request = require_attributes.request;
+exports.resetEvents = require_event.resetEvents;
+exports.resetMetrics = require_metric.resetMetrics;
+exports.resolveSamplingPreset = require_sampling.resolveSamplingPreset;
+exports.resolveTraceUrl = require_trace_helpers.resolveTraceUrl;
+exports.runInOperationContext = require_operation_context.runInOperationContext;
+exports.runWithCorrelationId = require_track.runWithCorrelationId;
 exports.runWithRequestContext = runWithRequestContext;
+exports.runWithSpan = require_trace_helpers.runWithSpan;
+exports.safeSetAttributes = require_attributes.safeSetAttributes;
+exports.samplingPresets = require_sampling.samplingPresets;
+exports.setAutotelTracerProvider = require_tracer_provider.setAutotelTracerProvider;
+exports.setCorrelationId = require_track.setCorrelationId;
+exports.setCorrelationIdInBaggage = require_track.setCorrelationIdInBaggage;
+exports.setDevice = require_attributes.setDevice;
+exports.setError = require_attributes.setError;
+exports.setException = require_attributes.setException;
+exports.setSession = require_attributes.setSession;
+exports.setUser = require_attributes.setUser;
 exports.shutdown = shutdown;
-exports.trace = trace2;
-//# sourceMappingURL=index.cjs.map
+exports.span = require_functional.span;
+exports.structuredErrorToJSON = require_structured_error.structuredErrorToJSON;
+exports.toAttributeValue = require_structured_error.toAttributeValue;
+exports.trace = trace;
+exports.traceConsumer = require_messaging.traceConsumer;
+exports.traceDB = require_semantic_helpers.traceDB;
+exports.traceHTTP = require_semantic_helpers.traceHTTP;
+exports.traceLLM = require_semantic_helpers.traceLLM;
+exports.traceMessaging = require_semantic_helpers.traceMessaging;
+exports.traceProducer = require_messaging.traceProducer;
+exports.traceStep = require_workflow.traceStep;
+exports.traceWorkflow = require_workflow.traceWorkflow;
+exports.track = require_track.track;
+exports.validateAttribute = require_attributes.validateAttribute;
+exports.withBaggage = require_functional.withBaggage;
+exports.withNewContext = require_functional.withNewContext;
+exports.withTracing = require_functional.withTracing;
 //# sourceMappingURL=index.cjs.map