autotel 5.0.0 → 6.1.0

package/dist/init-R-gSEXkJ.js

@@ -0,0 +1,3190 @@
+import { getForceFlushableProvider } from "./tracer-provider.js";
+import { getConfig as getConfig$1 } from "./config.js";
+import { AUTOTEL_SAMPLING_RATE, resolveSamplingPreset, samplingPresets } from "./sampling.js";
+import { n as safeRequire, t as requireModule } from "./node-require-vROmTeJ8.js";
+import { TailSamplingSpanProcessor } from "./tail-sampling-processor.js";
+import { FilteringSpanProcessor } from "./filtering-span-processor.js";
+import { SpanNameNormalizingProcessor } from "./span-name-normalizer.js";
+import { AttributeRedactingProcessor, REDACTOR_PRESETS, normalizeAttributeRedactorConfig } from "./attribute-redacting-processor.js";
+import { t as PrettyConsoleExporter } from "./pretty-console-exporter-DqKl_q9z.js";
+import { loadYamlConfig } from "./yaml-config.js";
+import { t as CanonicalLogLineProcessor } from "./canonical-log-line-processor-mKABvGP0.js";
+import { r as recordStructuredError } from "./structured-error-9--cxBay.js";
+import { resetMetrics } from "./metric.js";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { AlwaysOffSampler, AlwaysOnSampler, BatchSpanProcessor, ConsoleSpanExporter, ParentBasedSampler, SamplingDecision, SimpleSpanProcessor, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { context, propagation, trace } from "@opentelemetry/api";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { constants } from "node:os";
+import * as nodeAsyncHooks from "node:async_hooks";
+
+//#region src/posthog-logs.ts
+var RedactingLogRecordProcessor = class {
+	wrapped;
+	redact;
+	constructor(wrapped, redact) {
+		this.wrapped = wrapped;
+		this.redact = redact;
+	}
+	onEmit(logRecord, context) {
+		if (logRecord.body && typeof logRecord.body === "string") logRecord.body = this.redact(logRecord.body);
+		if (logRecord.attributes) {
+			for (const [key, value] of Object.entries(logRecord.attributes)) if (typeof value === "string") logRecord.attributes[key] = this.redact(value);
+			else if (Array.isArray(value)) logRecord.attributes[key] = value.map((item) => typeof item === "string" ? this.redact(item) : item);
+		}
+		this.wrapped.onEmit(logRecord, context);
+	}
+	shutdown() {
+		return this.wrapped.shutdown();
+	}
+	forceFlush() {
+		return this.wrapped.forceFlush();
+	}
+};
+/**
+* Build log record processors for PostHog OTLP logs integration.
+*
+* Resolution order:
+* 1. config.url if provided
+* 2. POSTHOG_LOGS_URL env var
+* 3. Empty array (disabled)
+*/
+function buildPostHogLogProcessors(config, stringRedactor) {
+	const url = config?.url || process.env.POSTHOG_LOGS_URL;
+	if (!url) return [];
+	const sdkLogs = safeRequire("@opentelemetry/sdk-logs");
+	const exporterModule = safeRequire("@opentelemetry/exporter-logs-otlp-http");
+	if (!sdkLogs || !exporterModule) return [];
+	const exporter = new exporterModule.OTLPLogExporter({ url });
+	let processor = new sdkLogs.BatchLogRecordProcessor({ exporter });
+	if (stringRedactor) processor = new RedactingLogRecordProcessor(processor, stringRedactor);
+	return [processor];
+}
+
+//#endregion
+//#region src/baggage-span-processor.ts
+/**
+* Span processor that automatically copies baggage entries to span attributes
+*
+* This makes baggage visible in trace UIs (Jaeger, Grafana, DataDog, etc.)
+* without manually calling ctx.setAttribute() for each baggage entry.
+*
+* @example Enable in init()
+* ```typescript
+* init({
+*   service: 'my-app',
+*   baggage: true // Uses default 'baggage.' prefix
+* });
+*
+* // Now baggage automatically appears as span attributes
+* await withBaggage({
+*   baggage: { 'tenant.id': 't1', 'user.id': 'u1' },
+*   fn: async () => {
+*     // Span has baggage.tenant.id and baggage.user.id attributes!
+*   }
+* });
+* ```
+*
+* @example Custom prefix
+* ```typescript
+* init({
+*   service: 'my-app',
+*   baggage: 'ctx' // Uses 'ctx.' prefix
+* });
+* // Creates attributes: ctx.tenant.id, ctx.user.id
+* ```
+*/
+var BaggageSpanProcessor = class {
+	prefix;
+	constructor(options = {}) {
+		this.prefix = options.prefix ?? "baggage.";
+	}
+	onStart(span, parentContext) {
+		let baggage = propagation.getBaggage(parentContext);
+		if (!baggage) baggage = propagation.getBaggage(context.active());
+		if (!baggage) try {
+			const { getActiveContextWithBaggage } = requireModule("./trace-context");
+			const storedContext = getActiveContextWithBaggage();
+			baggage = propagation.getBaggage(storedContext);
+		} catch {}
+		if (!baggage) return;
+		for (const [key, entry] of baggage.getAllEntries()) span.setAttribute(`${this.prefix}${key}`, entry.value);
+	}
+	onEnd(_span) {}
+	async shutdown() {}
+	async forceFlush() {}
+};
+
+//#endregion
+//#region src/redact-values.ts
+/** Standalone string redaction for use outside the span processor pipeline. */
+function createStringRedactor(config) {
+	const resolved = typeof config === "string" ? REDACTOR_PRESETS[config] : config;
+	const valuePatterns = resolved.valuePatterns ?? [];
+	const defaultReplacement = resolved.replacement ?? "[REDACTED]";
+	return (value) => {
+		let result = value;
+		for (const { pattern, replacement, mask } of valuePatterns) {
+			pattern.lastIndex = 0;
+			result = mask ? result.replaceAll(pattern, (match) => mask(match)) : result.replaceAll(pattern, replacement ?? defaultReplacement);
+		}
+		return result;
+	};
+}
+
+//#endregion
+//#region src/env-config.ts
+/**
+* Validate URL format
+*/
+function isValidUrl(urlString) {
+	try {
+		const url = new URL(urlString);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve OpenTelemetry environment variables from process.env
+*/
+function resolveOtelEnv() {
+	const env = {};
+	if (process.env.OTEL_SERVICE_NAME) {
+		const value = process.env.OTEL_SERVICE_NAME.trim();
+		if (value) env.OTEL_SERVICE_NAME = value;
+	}
+	if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+		const value = process.env.OTEL_EXPORTER_OTLP_ENDPOINT.trim();
+		if (value && isValidUrl(value)) env.OTEL_EXPORTER_OTLP_ENDPOINT = value;
+	}
+	if (process.env.OTEL_EXPORTER_OTLP_HEADERS) {
+		const value = process.env.OTEL_EXPORTER_OTLP_HEADERS.trim();
+		if (value) env.OTEL_EXPORTER_OTLP_HEADERS = value;
+	}
+	if (process.env.OTEL_RESOURCE_ATTRIBUTES) {
+		const value = process.env.OTEL_RESOURCE_ATTRIBUTES.trim();
+		if (value) env.OTEL_RESOURCE_ATTRIBUTES = value;
+	}
+	if (process.env.OTEL_EXPORTER_OTLP_PROTOCOL) {
+		const value = process.env.OTEL_EXPORTER_OTLP_PROTOCOL.trim().toLowerCase();
+		if (value === "http" || value === "grpc") env.OTEL_EXPORTER_OTLP_PROTOCOL = value;
+	}
+	if (process.env.OTEL_TRACES_SAMPLER) {
+		const value = process.env.OTEL_TRACES_SAMPLER.trim();
+		if (value) env.OTEL_TRACES_SAMPLER = value;
+	}
+	if (process.env.OTEL_TRACES_SAMPLER_ARG) {
+		const value = process.env.OTEL_TRACES_SAMPLER_ARG.trim();
+		if (value) env.OTEL_TRACES_SAMPLER_ARG = value;
+	}
+	return env;
+}
+function parseRatioSamplerArg(samplerName, samplerArg) {
+	if (samplerArg === void 0) return 1;
+	const ratio = Number(samplerArg);
+	if (!Number.isFinite(ratio) || ratio < 0 || ratio > 1) {
+		console.error(`[autotel] Invalid OTEL_TRACES_SAMPLER_ARG="${samplerArg}" for ${samplerName}. Expected a number in [0..1]. Falling back to 1.0.`);
+		return 1;
+	}
+	return ratio;
+}
+function warnOnUnusedSamplerArg(samplerName, samplerArg) {
+	if (samplerArg !== void 0) console.error(`[autotel] OTEL_TRACES_SAMPLER_ARG is not used by OTEL_TRACES_SAMPLER="${samplerName}". Ignoring value "${samplerArg}".`);
+}
+function createSamplerFromEnv(env) {
+	const samplerName = env.OTEL_TRACES_SAMPLER;
+	if (!samplerName) return;
+	switch (samplerName) {
+		case "always_on":
+			warnOnUnusedSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG);
+			return new AlwaysOnSampler();
+		case "always_off":
+			warnOnUnusedSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG);
+			return new AlwaysOffSampler();
+		case "traceidratio": return new TraceIdRatioBasedSampler(parseRatioSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG));
+		case "parentbased_always_on":
+			warnOnUnusedSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG);
+			return new ParentBasedSampler({ root: new AlwaysOnSampler() });
+		case "parentbased_always_off":
+			warnOnUnusedSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG);
+			return new ParentBasedSampler({ root: new AlwaysOffSampler() });
+		case "parentbased_traceidratio": return new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(parseRatioSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG)) });
+		case "jaeger_remote":
+		case "parentbased_jaeger_remote":
+		case "xray":
+			console.error(`[autotel] OTEL_TRACES_SAMPLER="${samplerName}" is not supported yet by autotel. Falling back to the next sampler source.`);
+			return;
+		default:
+			console.error(`[autotel] Unknown OTEL_TRACES_SAMPLER="${samplerName}". Falling back to the next sampler source.`);
+			return;
+	}
+}
+/**
+* Parse OTEL_RESOURCE_ATTRIBUTES from comma-separated key=value pairs
+* Example: "service.version=1.0.0,deployment.environment=production"
+*/
+function parseResourceAttributes(input) {
+	if (!input || input.trim() === "") return {};
+	const attributes = {};
+	const pairs = input.split(",");
+	for (const pair of pairs) {
+		const trimmedPair = pair.trim();
+		if (!trimmedPair) continue;
+		const equalIndex = trimmedPair.indexOf("=");
+		if (equalIndex === -1) continue;
+		const key = trimmedPair.slice(0, equalIndex).trim();
+		const value = trimmedPair.slice(equalIndex + 1).trim();
+		if (key && value) attributes[key] = value;
+	}
+	return attributes;
+}
+/**
+* Parse OTEL_EXPORTER_OTLP_HEADERS from comma-separated key=value pairs
+* Example: "api-key=secret123,x-custom-header=value"
+*/
+function parseOtlpHeaders(input) {
+	if (!input || input.trim() === "") return {};
+	const headers = {};
+	const pairs = input.split(",");
+	for (const pair of pairs) {
+		const trimmedPair = pair.trim();
+		if (!trimmedPair) continue;
+		const equalIndex = trimmedPair.indexOf("=");
+		if (equalIndex === -1) continue;
+		const key = trimmedPair.slice(0, equalIndex).trim();
+		const value = trimmedPair.slice(equalIndex + 1).trim();
+		if (key && value) headers[key] = value;
+	}
+	return headers;
+}
+/**
+* Convert resolved environment variables to config
+*/
+function envToConfig(env) {
+	const config = {};
+	if (env.OTEL_SERVICE_NAME) config.service = env.OTEL_SERVICE_NAME;
+	if (env.OTEL_EXPORTER_OTLP_ENDPOINT) config.endpoint = env.OTEL_EXPORTER_OTLP_ENDPOINT;
+	if (env.OTEL_EXPORTER_OTLP_PROTOCOL) config.protocol = env.OTEL_EXPORTER_OTLP_PROTOCOL;
+	if (env.OTEL_EXPORTER_OTLP_HEADERS) config.headers = parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_HEADERS);
+	const resourceAttrs = parseResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES);
+	if (Object.keys(resourceAttrs).length > 0) config.resourceAttributes = resourceAttrs;
+	const sampler = createSamplerFromEnv(env);
+	if (sampler) config.otelSampler = sampler;
+	return config;
+}
+/**
+* Main function to resolve config from environment variables
+*/
+function resolveConfigFromEnv() {
+	return envToConfig(resolveOtelEnv());
+}
+
+//#endregion
+//#region src/devtools.ts
+const defaultHost = "127.0.0.1";
+const defaultPort = 4318;
+function resolveDevtoolsConfig(config) {
+	if (!config) return {
+		enabled: false,
+		endpoint: void 0,
+		embedded: false,
+		host: defaultHost,
+		port: defaultPort,
+		verbose: false
+	};
+	if (config === true) return {
+		enabled: true,
+		endpoint: `http://${defaultHost}:${defaultPort}`,
+		embedded: false,
+		host: defaultHost,
+		port: defaultPort,
+		verbose: false
+	};
+	const enabled = config.enabled ?? true;
+	const host = config.host ?? defaultHost;
+	const port = config.port ?? defaultPort;
+	const endpoint = config.endpoint ?? `http://${host}:${port}`;
+	return {
+		enabled,
+		endpoint: enabled ? endpoint : void 0,
+		embedded: enabled && (config.embedded ?? false),
+		host,
+		port,
+		verbose: config.verbose ?? false
+	};
+}
+
+//#endregion
+//#region src/process-handlers.ts
+let removeOwnedHandlers = [];
+const DEFAULT_SIGNALS = ["SIGTERM", "SIGINT"];
+function signalExitCode(signal) {
+	return 128 + constants.signals[signal];
+}
+/**
+* Surface a fatal error before shutting down.
+*
+* Registering an `uncaughtException` / `unhandledRejection` listener overrides
+* Node's default of printing the stack to stderr, so without this a crash under
+* `fatalErrors` would exit silently. Autotel's own logger is silent by default,
+* so we print to stderr directly to guarantee the crash stays visible.
+*/
+function reportFatalError(error, event) {
+	const err = error instanceof Error ? error : new Error(String(error));
+	console.error(`[autotel] ${event}, flushing telemetry then exiting`, err);
+}
+function installProcessHandlers(config, shutdown) {
+	uninstallProcessHandlers();
+	let shutdownInFlight;
+	const runShutdownOnce = () => {
+		if (shutdownInFlight) return shutdownInFlight;
+		const timeoutMs = config.shutdownTimeoutMs ?? 2e3;
+		let timeoutHandle;
+		const shutdownAttempt = Promise.resolve().then(shutdown).catch(() => void 0);
+		const timeout = new Promise((resolve) => {
+			timeoutHandle = setTimeout(resolve, timeoutMs);
+			timeoutHandle.unref();
+		});
+		shutdownInFlight = Promise.race([shutdownAttempt, timeout]).then(() => {
+			if (timeoutHandle) clearTimeout(timeoutHandle);
+		});
+		return shutdownInFlight;
+	};
+	let exitScheduled = false;
+	let resolvedExitCode = 0;
+	let fatalLatched = false;
+	const shutdownAndExit = (exitCode, fatal) => {
+		if (fatal) {
+			if (!fatalLatched) {
+				resolvedExitCode = exitCode;
+				fatalLatched = true;
+			}
+		} else if (!exitScheduled && !fatalLatched) resolvedExitCode = exitCode;
+		if (exitScheduled) return;
+		exitScheduled = true;
+		runShutdownOnce().then(() => {
+			process.exit(resolvedExitCode);
+		});
+	};
+	for (const signal of config.signals ?? DEFAULT_SIGNALS) {
+		const listener = () => {
+			shutdownAndExit(signalExitCode(signal), false);
+		};
+		process.on(signal, listener);
+		removeOwnedHandlers.push(() => {
+			process.removeListener(signal, listener);
+		});
+	}
+	if (config.fatalErrors ?? true) {
+		const uncaughtExceptionListener = (error) => {
+			reportFatalError(error, "uncaughtException");
+			shutdownAndExit(1, true);
+		};
+		const unhandledRejectionListener = (reason) => {
+			reportFatalError(reason, "unhandledRejection");
+			shutdownAndExit(1, true);
+		};
+		process.on("uncaughtException", uncaughtExceptionListener);
+		process.on("unhandledRejection", unhandledRejectionListener);
+		removeOwnedHandlers.push(() => {
+			process.removeListener("uncaughtException", uncaughtExceptionListener);
+		}, () => {
+			process.removeListener("unhandledRejection", unhandledRejectionListener);
+		});
+	}
+}
+function uninstallProcessHandlers() {
+	for (const removeHandler of removeOwnedHandlers) removeHandler();
+	removeOwnedHandlers = [];
+}
+
+//#endregion
+//#region src/rate-limiter.ts
+/**
+* Token bucket rate limiter
+*
+* Allows bursts up to burstCapacity, then smooths to maxEventsPerSecond.
+* Thread-safe for async operations.
+*/
+var TokenBucketRateLimiter = class {
+	tokens;
+	maxTokens;
+	refillRate;
+	lastRefill;
+	constructor(config) {
+		this.maxTokens = config.burstCapacity || config.maxEventsPerSecond * 2;
+		this.tokens = this.maxTokens;
+		this.refillRate = config.maxEventsPerSecond / 1e3;
+		this.lastRefill = Date.now();
+	}
+	/**
+	* Try to consume a token (allow an event)
+	* Returns true if allowed, false if rate limit exceeded
+	*/
+	tryConsume(count = 1) {
+		this.refill();
+		if (this.tokens >= count) {
+			this.tokens -= count;
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Wait until a token is available (async rate limiting)
+	* Returns a promise that resolves when the event can be processed
+	*/
+	async waitForToken(count = 1) {
+		this.refill();
+		if (this.tokens >= count) {
+			this.tokens -= count;
+			return;
+		}
+		const tokensNeeded = count - this.tokens;
+		const waitMs = Math.ceil(tokensNeeded / this.refillRate);
+		await new Promise((resolve) => setTimeout(resolve, waitMs));
+		return this.waitForToken(count);
+	}
+	/**
+	* Refill tokens based on elapsed time
+	*/
+	refill() {
+		const now = Date.now();
+		const tokensToAdd = (now - this.lastRefill) * this.refillRate;
+		this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
+		this.lastRefill = now;
+	}
+	/**
+	* Get current available tokens (for testing/debugging)
+	*/
+	getAvailableTokens() {
+		this.refill();
+		return Math.floor(this.tokens);
+	}
+	/**
+	* Reset the rate limiter (for testing)
+	*/
+	reset() {
+		this.tokens = this.maxTokens;
+		this.lastRefill = Date.now();
+	}
+};
+
+//#endregion
+//#region src/trace-context.ts
+/**
+* AsyncLocalStorage for storing the active context with baggage
+* This allows setters to update the context and have it persist
+*/
+const contextStorage = new nodeAsyncHooks.AsyncLocalStorage();
+/**
+* Get the context storage instance (for initialization in functional.ts)
+*/
+function getContextStorage() {
+	return contextStorage;
+}
+/**
+* Get the active context, checking our stored context first
+* This ensures baggage setters work with OpenTelemetry's propagation
+*/
+function getActiveContextWithBaggage() {
+	return contextStorage.getStore()?.value ?? context.active();
+}
+/**
+* Set a value in AsyncLocalStorage, preferring enterWith() when available
+* (Node.js) and falling back to run() for environments that only support
+* run() (e.g. Cloudflare Workers).
+*
+* On runtimes without enterWith() we mutate the existing run() scope when one
+* exists. This is what allows baggage/correlation updates to remain visible
+* for the rest of the traced callback in Workers.
+*/
+function enterOrRun(storage, value) {
+	const existingStore = storage.getStore();
+	if (existingStore) {
+		existingStore.value = value;
+		return;
+	}
+	const boxedValue = { value };
+	try {
+		storage.enterWith(boxedValue);
+	} catch {
+		storage.run(boxedValue, () => {});
+	}
+}
+function updateActiveContext(newContext) {
+	enterOrRun(contextStorage, newContext);
+	const manager = context._getContextManager?.();
+	if (!manager) return;
+	const asyncLocal = manager._asyncLocalStorage ?? void 0;
+	if (asyncLocal?.enterWith) {
+		asyncLocal.enterWith(newContext);
+		return;
+	}
+	if (typeof manager.with === "function") manager.with(newContext, () => {});
+}
+/**
+* Create a TraceContext from an OpenTelemetry Span
+*
+* This utility extracts trace context information from a span
+* and provides span manipulation methods and baggage operations in a consistent format.
+*
+* Note: Baggage methods always operate on the currently active context,
+* which may differ from the context when createTraceContext was called.
+*/
+function createTraceContext(span) {
+	const spanContext = span.spanContext();
+	if (!contextStorage.getStore()?.value) {
+		const activeContext = context.active();
+		enterOrRun(contextStorage, activeContext);
+	}
+	const traceCtx = {
+		traceId: spanContext.traceId,
+		spanId: spanContext.spanId,
+		correlationId: spanContext.traceId.slice(0, 16),
+		setAttribute: span.setAttribute.bind(span),
+		setAttributes: span.setAttributes.bind(span),
+		setStatus: span.setStatus.bind(span),
+		recordException: span.recordException.bind(span),
+		addEvent: span.addEvent.bind(span),
+		addLink: span.addLink.bind(span),
+		addLinks: span.addLinks.bind(span),
+		updateName: span.updateName.bind(span),
+		isRecording: span.isRecording.bind(span),
+		recordError: (error) => {
+			const err = error instanceof Error ? error : new Error(String(error));
+			recordStructuredError(traceCtx, err);
+		},
+		track: (event, data) => {
+			track(event, data);
+		},
+		getBaggage(key) {
+			const activeCtx = context.active();
+			let baggage = propagation.getBaggage(activeCtx);
+			if (!baggage) {
+				const storedContext = contextStorage.getStore()?.value;
+				if (storedContext) baggage = propagation.getBaggage(storedContext);
+			}
+			return baggage?.getEntry(key)?.value;
+		},
+		setBaggage(key, value) {
+			const activeCtx = context.active();
+			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const updated = (propagation.getBaggage(currentContext) ?? propagation.createBaggage()).setEntry(key, { value });
+			updateActiveContext(propagation.setBaggage(currentContext, updated));
+			return value;
+		},
+		deleteBaggage(key) {
+			const activeCtx = context.active();
+			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const baggage = propagation.getBaggage(currentContext);
+			if (baggage) {
+				const updated = baggage.removeEntry(key);
+				updateActiveContext(propagation.setBaggage(currentContext, updated));
+			}
+		},
+		getAllBaggage() {
+			const activeCtx = context.active();
+			let baggage = propagation.getBaggage(activeCtx);
+			if (!baggage) {
+				const storedContext = contextStorage.getStore()?.value;
+				if (storedContext) baggage = propagation.getBaggage(storedContext);
+			}
+			if (!baggage) return /* @__PURE__ */ new Map();
+			const entries = /* @__PURE__ */ new Map();
+			for (const [key, entry] of baggage.getAllEntries()) entries.set(key, entry);
+			return entries;
+		},
+		getTypedBaggage: ((namespace) => {
+			const activeCtx = context.active();
+			let baggage = propagation.getBaggage(activeCtx);
+			if (!baggage) {
+				const storedContext = contextStorage.getStore()?.value;
+				if (storedContext) baggage = propagation.getBaggage(storedContext);
+			}
+			if (!baggage) return;
+			const prefix = namespace ? `${namespace}.` : "";
+			const result = {};
+			for (const [key, entry] of baggage.getAllEntries()) if (namespace && key.startsWith(prefix)) {
+				const fieldName = key.slice(prefix.length);
+				result[fieldName] = entry.value;
+			} else if (!namespace) result[key] = entry.value;
+			return Object.keys(result).length > 0 ? result : void 0;
+		}),
+		setTypedBaggage: ((namespace, value) => {
+			const activeCtx = context.active();
+			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			let baggage = propagation.getBaggage(currentContext) ?? propagation.createBaggage();
+			const prefix = namespace ? `${namespace}.` : "";
+			for (const [key, val] of Object.entries(value)) if (val !== void 0) {
+				const baggageKey = `${prefix}${key}`;
+				baggage = baggage.setEntry(baggageKey, { value: String(val) });
+			}
+			updateActiveContext(propagation.setBaggage(currentContext, baggage));
+		})
+	};
+	return traceCtx;
+}
+/**
+* Define a typed baggage schema for type-safe baggage operations
+*
+* This helper provides a type-safe API for working with baggage entries.
+* The namespace parameter is optional and prefixes all keys to avoid collisions.
+*
+* @template T - The baggage schema type (all fields are treated as optional)
+* @param namespace - Optional namespace to prefix baggage keys
+*
+* @example Basic usage
+* ```typescript
+* type TenantBaggage = { tenantId: string; region?: string };
+* const tenantBaggage = defineBaggageSchema<TenantBaggage>('tenant');
+*
+* export const handler = trace<TenantBaggage>((ctx) => async () => {
+*   // Get typed baggage
+*   const tenant = tenantBaggage.get(ctx);
+*   if (tenant?.tenantId) {
+*     console.log('Tenant:', tenant.tenantId);
+*   }
+*
+*   // Set typed baggage
+*   tenantBaggage.set(ctx, { tenantId: 't1', region: 'us-east-1' });
+* });
+* ```
+*
+* @example With withBaggage helper
+* ```typescript
+* const tenantBaggage = defineBaggageSchema<TenantBaggage>('tenant');
+*
+* export const handler = trace<TenantBaggage>((ctx) => async () => {
+*   return await tenantBaggage.with(ctx, { tenantId: 't1' }, async () => {
+*     // Baggage is available here and in child spans
+*     const tenant = tenantBaggage.get(ctx);
+*   });
+* });
+* ```
+*/
+function defineBaggageSchema(namespace) {
+	return {
+		/**
+		* Get typed baggage from context
+		* @param ctx - Trace context
+		* @returns Partial baggage object or undefined if no baggage is set
+		*/
+		get: (ctx) => {
+			if (!ctx.getTypedBaggage) return void 0;
+			return ctx.getTypedBaggage(namespace);
+		},
+		/**
+		* Set typed baggage in context
+		*
+		* Note: For proper scoping across async boundaries, use the `with` method instead
+		*
+		* @param ctx - Trace context
+		* @param value - Partial baggage object to set
+		*/
+		set: (ctx, value) => {
+			if (!ctx.setTypedBaggage) return;
+			ctx.setTypedBaggage(namespace, value);
+		},
+		/**
+		* Run a function with typed baggage properly scoped
+		*
+		* This is the recommended way to set baggage as it ensures proper
+		* scoping across async boundaries.
+		*
+		* @param ctx - Trace context (can be omitted, will use active context)
+		* @param value - Partial baggage object to set
+		* @param fn - Function to execute with the baggage
+		*/
+		with: (ctxOrValue, valueOrFn, maybeFn) => {
+			const value = maybeFn ? valueOrFn : ctxOrValue;
+			const fn = maybeFn || valueOrFn;
+			const prefix = namespace ? `${namespace}.` : "";
+			const flatBaggage = {};
+			for (const [key, val] of Object.entries(value)) if (val !== void 0) flatBaggage[`${prefix}${key}`] = String(val);
+			const currentContext = context.active();
+			let baggage = propagation.getBaggage(currentContext) ?? propagation.createBaggage();
+			for (const [key, val] of Object.entries(flatBaggage)) baggage = baggage.setEntry(key, { value: val });
+			const newContext = propagation.setBaggage(currentContext, baggage);
+			return context.with(newContext, fn);
+		}
+	};
+}
+
+//#endregion
+//#region src/correlation-id.ts
+/**
+* Correlation ID utilities for event-driven observability
+*
+* Provides a stable join key across events, logs, and spans even when traces fragment.
+* Format: 16 hex chars (64 bits), crypto-random, URL-safe.
+*
+* Lifecycle:
+* 1. Generated at boundary root (HTTP server span, message process span, cron job span)
+* 2. Reused within context (nested work shares it via AsyncLocalStorage)
+* 3. Propagated via baggage (optional, default OFF to avoid header bloat)
+*
+* @example Basic usage
+* ```typescript
+* import { generateCorrelationId, getCorrelationId } from 'autotel/correlation-id';
+*
+* // Generate a new correlation ID
+* const id = generateCorrelationId();
+* // Returns: 'a1b2c3d4e5f67890'
+*
+* // Get current correlation ID from context
+* const currentId = getCorrelationId();
+* ```
+*/
+/**
+* AsyncLocalStorage for storing correlation ID
+* This allows correlation IDs to persist across async boundaries
+*/
+const correlationStorage = new nodeAsyncHooks.AsyncLocalStorage();
+/**
+* Baggage key for correlation ID propagation
+*/
+const CORRELATION_ID_BAGGAGE_KEY = "autotel.correlation_id";
+/**
+* Generate a new correlation ID
+*
+* Format: 16 hex chars (64 bits), crypto-random, URL-safe
+*
+* @returns A new correlation ID
+*
+* @example
+* ```typescript
+* const id = generateCorrelationId();
+* // Returns: 'a1b2c3d4e5f67890'
+* ```
+*/
+function generateCorrelationId() {
+	const bytes = /* @__PURE__ */ new Uint8Array(8);
+	crypto.getRandomValues(bytes);
+	return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Get the current correlation ID from context
+*
+* Resolution order:
+* 1. AsyncLocalStorage (from explicit setCorrelationId or runWithCorrelationId)
+* 2. Baggage (if propagated from upstream)
+* 3. Active span's trace ID (first 16 chars as fallback)
+* 4. undefined (if not in any context)
+*
+* @returns Current correlation ID or undefined
+*
+* @example
+* ```typescript
+* const id = getCorrelationId();
+* if (id) {
+*   console.log('Correlation ID:', id);
+* }
+* ```
+*/
+function getCorrelationId() {
+	const storedId = correlationStorage.getStore()?.value;
+	if (storedId) return storedId;
+	const activeContext = context.active();
+	const baggageEntry = propagation.getBaggage(activeContext)?.getEntry(CORRELATION_ID_BAGGAGE_KEY);
+	if (baggageEntry?.value) return baggageEntry.value;
+	const span = trace.getActiveSpan();
+	if (span) return span.spanContext().traceId.slice(0, 16);
+}
+/**
+* Get or create a correlation ID
+*
+* If a correlation ID exists in the current context, returns it.
+* Otherwise, generates a new one.
+*
+* @returns Existing or new correlation ID
+*
+* @example
+* ```typescript
+* const id = getOrCreateCorrelationId();
+* // Always returns a valid correlation ID
+* ```
+*/
+function getOrCreateCorrelationId() {
+	return getCorrelationId() ?? generateCorrelationId();
+}
+/**
+* Run a function with a specific correlation ID in context
+*
+* The correlation ID will be available via getCorrelationId() throughout
+* the execution of the function and any async operations it spawns.
+*
+* @param correlationId - Correlation ID to use
+* @param fn - Function to execute
+* @returns The return value of the function
+*
+* @example
+* ```typescript
+* await runWithCorrelationId('abc123', async () => {
+*   // getCorrelationId() returns 'abc123' here
+*   await processRequest();
+* });
+* ```
+*/
+function runWithCorrelationId(correlationId, fn) {
+	return correlationStorage.run({ value: correlationId }, fn);
+}
+/**
+* Set correlation ID in the current context (mutates context)
+*
+* Note: This updates the AsyncLocalStorage context. For proper scoping
+* across async boundaries, prefer runWithCorrelationId() instead.
+*
+* @param correlationId - Correlation ID to set
+*
+* @example
+* ```typescript
+* setCorrelationId('abc123');
+* // Now getCorrelationId() returns 'abc123'
+* ```
+*/
+function setCorrelationId(correlationId) {
+	enterOrRun(correlationStorage, correlationId);
+}
+/**
+* Set correlation ID in baggage for propagation
+*
+* This adds the correlation ID to the W3C baggage header, allowing it
+* to be propagated to downstream services.
+*
+* Note: Only use this when you explicitly want cross-service propagation.
+* Default is OFF to avoid header bloat.
+*
+* @param correlationId - Correlation ID to propagate
+* @returns New context with baggage set
+*
+* @example
+* ```typescript
+* const newContext = setCorrelationIdInBaggage('abc123');
+* context.with(newContext, () => {
+*   // Baggage will be propagated in outgoing requests
+* });
+* ```
+*/
+function setCorrelationIdInBaggage(correlationId) {
+	const activeContext = context.active();
+	let baggage = propagation.getBaggage(activeContext) ?? propagation.createBaggage();
+	baggage = baggage.setEntry(CORRELATION_ID_BAGGAGE_KEY, { value: correlationId });
+	return propagation.setBaggage(activeContext, baggage);
+}
+/**
+* Get the correlation storage instance (for internal use in init/shutdown)
+*/
+function getCorrelationStorage() {
+	return correlationStorage;
+}
+
+//#endregion
+//#region src/event-queue.ts
+const DEFAULT_CONFIG$2 = {
+	maxSize: 5e4,
+	batchSize: 100,
+	flushInterval: 1e4,
+	maxRetries: 3,
+	rateLimit: {
+		maxEventsPerSecond: 100,
+		burstCapacity: 200
+	}
+};
+/**
+* Get subscriber name for metrics (stable, low-cardinality)
+*
+* Priority:
+* 1. Explicit config: subscriber.name
+* 2. Class static property (if available)
+* 3. Fallback: lowercase class name without "Subscriber" suffix
+*/
+function getSubscriberName(subscriber) {
+	if (subscriber.name) return subscriber.name.toLowerCase();
+	return (subscriber.constructor?.name || "unknown").replace(/Subscriber$/i, "").toLowerCase();
+}
+/**
+* Events queue with batching and backpressure
+*
+* Features:
+* - Batches events for efficient sending
+* - Bounded queue with drop-oldest policy (prod) or blocking (dev)
+* - Exponential backoff retry
+* - Rate limiting to prevent overwhelming subscribers
+* - Graceful flush on shutdown
+*/
+var EventQueue = class {
+	queue = [];
+	flushTimer = null;
+	config;
+	subscribers;
+	rateLimiter;
+	flushPromise = null;
+	isShuttingDown = false;
+	metrics = null;
+	observableCleanups = [];
+	subscriberHealthy = /* @__PURE__ */ new Map();
+	constructor(subscribers, config) {
+		this.subscribers = subscribers;
+		this.config = {
+			...DEFAULT_CONFIG$2,
+			...config
+		};
+		this.rateLimiter = this.config.rateLimit ? new TokenBucketRateLimiter(this.config.rateLimit) : null;
+		for (const subscriber of subscribers) {
+			const name = getSubscriberName(subscriber);
+			this.subscriberHealthy.set(name, true);
+		}
+		this.initMetrics();
+	}
+	/**
+	* Initialize OTel metrics for queue observability
+	*/
+	initMetrics() {
+		const meter = getConfig$1().meter;
+		const queueSize = meter.createObservableGauge("autotel.event_delivery.queue.size", {
+			description: "Current number of events in the delivery queue",
+			unit: "count"
+		});
+		const queueSizeCallback = (observableResult) => {
+			observableResult.observe(this.queue.length);
+		};
+		queueSize.addCallback(queueSizeCallback);
+		this.observableCleanups.push(() => queueSize.removeCallback(queueSizeCallback));
+		const oldestAge = meter.createObservableGauge("autotel.event_delivery.queue.oldest_age_ms", {
+			description: "Age of the oldest event in the queue in milliseconds",
+			unit: "ms"
+		});
+		const oldestAgeCallback = (observableResult) => {
+			if (this.queue.length > 0) {
+				const oldest = this.queue[0];
+				const ageMs = Date.now() - oldest.timestamp;
+				observableResult.observe(ageMs);
+			} else observableResult.observe(0);
+		};
+		oldestAge.addCallback(oldestAgeCallback);
+		this.observableCleanups.push(() => oldestAge.removeCallback(oldestAgeCallback));
+		const delivered = meter.createCounter("autotel.event_delivery.queue.delivered", {
+			description: "Number of events successfully delivered to subscribers",
+			unit: "count"
+		});
+		const failed = meter.createCounter("autotel.event_delivery.queue.failed", {
+			description: "Number of events that failed delivery after all retry attempts",
+			unit: "count"
+		});
+		const dropped = meter.createCounter("autotel.event_delivery.queue.dropped", {
+			description: "Number of events dropped from the queue",
+			unit: "count"
+		});
+		const latency = meter.createHistogram("autotel.event_delivery.queue.latency_ms", {
+			description: "Event delivery latency from enqueue to successful send",
+			unit: "ms"
+		});
+		const subscriberHealth = meter.createObservableGauge("autotel.event_delivery.subscriber.health", {
+			description: "Subscriber health status (1=healthy, 0=unhealthy)",
+			unit: "1"
+		});
+		const subscriberHealthCallback = (observableResult) => {
+			for (const [subscriberName, isHealthy] of this.subscriberHealthy) observableResult.observe(isHealthy ? 1 : 0, { subscriber: subscriberName });
+		};
+		subscriberHealth.addCallback(subscriberHealthCallback);
+		this.observableCleanups.push(() => subscriberHealth.removeCallback(subscriberHealthCallback));
+		this.metrics = {
+			queueSize,
+			oldestAge,
+			delivered,
+			failed,
+			dropped,
+			latency,
+			subscriberHealth
+		};
+	}
+	/**
+	* Record a dropped event with reason and emit debug breadcrumb
+	*/
+	recordDropped(reason, event, subscriberName) {
+		const attrs = { reason };
+		if (subscriberName) attrs.subscriber = subscriberName;
+		this.metrics?.dropped.add(1, attrs);
+		const logLevel = reason === "payload_invalid" ? "error" : "warn";
+		const logger = getLogger();
+		if (logLevel === "error") logger.error({
+			eventName: event?.name,
+			subscriber: subscriberName,
+			reason,
+			correlationId: event?._correlationId,
+			traceId: event?._traceId
+		}, `[autotel] Event dropped: ${reason}`);
+		else logger.warn({
+			eventName: event?.name,
+			subscriber: subscriberName,
+			reason,
+			correlationId: event?._correlationId,
+			traceId: event?._traceId
+		}, `[autotel] Event dropped: ${reason}`);
+	}
+	/**
+	* Record permanent delivery failure (after all retries exhausted)
+	* Increments failed counter and logs error
+	*/
+	recordFailed(event, subscriberName, error) {
+		this.metrics?.failed.add(1, { subscriber: subscriberName });
+		this.subscriberHealthy.set(subscriberName, false);
+		getLogger().error({
+			eventName: event.name,
+			subscriber: subscriberName,
+			correlationId: event._correlationId,
+			traceId: event._traceId,
+			err: error
+		}, `[autotel] Event delivery failed after all retries`);
+	}
+	/**
+	* Mark subscriber as unhealthy on transient failure (without incrementing failed counter)
+	* Used during retry attempts - only recordFailed should increment the counter
+	*/
+	markSubscriberUnhealthy(subscriberName) {
+		this.subscriberHealthy.set(subscriberName, false);
+	}
+	/**
+	* Record successful delivery
+	*/
+	recordDelivered(event, subscriberName, startTime) {
+		const latencyMs = Date.now() - startTime;
+		this.metrics?.delivered.add(1, { subscriber: subscriberName });
+		this.metrics?.latency.record(latencyMs, { subscriber: subscriberName });
+		this.subscriberHealthy.set(subscriberName, true);
+	}
+	/**
+	* Enqueue an event for sending
+	*
+	* Backpressure policy:
+	* - Drops oldest event and logs warning if queue is full (same behavior in all environments)
+	*/
+	enqueue(event) {
+		if (this.isShuttingDown) {
+			this.recordDropped("shutdown", event);
+			return;
+		}
+		if (this.queue.length >= this.config.maxSize) {
+			const droppedEvent = this.queue.shift();
+			this.recordDropped("rate_limit", droppedEvent);
+			getLogger().warn({ droppedEvent: droppedEvent?.name }, `[autotel] Events queue full (${this.config.maxSize} events). Dropping oldest event. Events are being produced faster than they can be sent. Check your subscribers or reduce tracking frequency.`);
+		}
+		const enrichedEvent = {
+			...event,
+			_correlationId: event._correlationId || getOrCreateCorrelationId()
+		};
+		this.queue.push(enrichedEvent);
+		this.scheduleBatchFlush();
+	}
+	/**
+	* Schedule a batch flush if not already scheduled
+	*/
+	scheduleBatchFlush() {
+		if (this.flushTimer || this.flushPromise) return;
+		this.flushTimer = setTimeout(() => {
+			this.flushTimer = null;
+			this.flushBatch();
+		}, this.config.flushInterval);
+	}
+	/**
+	* Flush a batch of events
+	* Uses promise-based concurrency control to prevent race conditions
+	*/
+	async flushBatch() {
+		if (this.queue.length === 0) return;
+		if (this.flushPromise) {
+			await this.flushPromise;
+			return;
+		}
+		this.flushPromise = this.doFlushBatch();
+		try {
+			await this.flushPromise;
+		} finally {
+			this.flushPromise = null;
+			if (this.queue.length > 0) this.scheduleBatchFlush();
+		}
+	}
+	/**
+	* Internal flush implementation
+	*/
+	async doFlushBatch() {
+		const batch = this.queue.splice(0, this.config.batchSize);
+		await this.sendWithRetry(batch, this.config.maxRetries);
+	}
+	/**
+	* Send events with exponential backoff retry
+	* Tracks per-event, per-subscriber failures so failed counter reflects actual failed deliveries.
+	* On retry, only failed (event, subscriber) pairs are re-sent to avoid double-counting delivered.
+	*/
+	async sendWithRetry(events, retriesLeft, subscribersByEventIndex) {
+		const failedDeliveries = await this.sendToSubscribers(events, subscribersByEventIndex);
+		if (failedDeliveries.length > 0) if (retriesLeft > 0) {
+			const failedEventIndicesOrdered = [...new Set(failedDeliveries.map((f) => f.eventIndex))].toSorted((a, b) => a - b);
+			const eventsToRetry = failedEventIndicesOrdered.map((i) => events[i]);
+			const failedSubscribersByRetryIndex = /* @__PURE__ */ new Map();
+			for (const [j, origIndex] of failedEventIndicesOrdered.entries()) {
+				const set = /* @__PURE__ */ new Set();
+				for (const { eventIndex, subscriberName } of failedDeliveries) if (eventIndex === origIndex) set.add(subscriberName);
+				failedSubscribersByRetryIndex.set(j, set);
+			}
+			const delay = Math.pow(2, this.config.maxRetries - retriesLeft) * 1e3;
+			await new Promise((resolve) => setTimeout(resolve, delay));
+			return this.sendWithRetry(eventsToRetry, retriesLeft - 1, failedSubscribersByRetryIndex);
+		} else {
+			for (const { eventIndex, subscriberName, error } of failedDeliveries) {
+				const event = events[eventIndex];
+				if (event) this.recordFailed(event, subscriberName, error);
+			}
+			const failedSubscriberNames = [...new Set(failedDeliveries.map((f) => f.subscriberName))];
+			getLogger().error({
+				failedSubscribers: failedSubscriberNames,
+				retriesAttempted: this.config.maxRetries
+			}, "[autotel] Failed to send events after retries");
+		}
+	}
+	/**
+	* Send events to configured subscribers with rate limiting and metrics.
+	* When subscribersByEventIndex is provided (retry path), only those subscribers are tried per event.
+	* Returns per-event, per-subscriber failures (empty if all succeeded).
+	*/
+	async sendToSubscribers(events, subscribersByEventIndex) {
+		const failedDeliveries = [];
+		const sendOne = async (event, eventIndex) => {
+			const subscriberNames = subscribersByEventIndex?.get(eventIndex);
+			const failures = await this.sendEventToSubscribers(event, subscriberNames ?? void 0);
+			for (const failure of failures) failedDeliveries.push({
+				eventIndex,
+				subscriberName: failure.subscriberName,
+				error: failure.error
+			});
+		};
+		if (!this.rateLimiter) {
+			for (const [i, event] of events.entries()) if (event) await sendOne(event, i);
+			return failedDeliveries;
+		}
+		for (const [i, event] of events.entries()) {
+			await this.rateLimiter.waitForToken();
+			if (event) await sendOne(event, i);
+		}
+		return failedDeliveries;
+	}
+	/**
+	* Send a single event to subscribers.
+	* - When subscriberNames is undefined (initial attempt): send to all subscribers.
+	* - When subscriberNames is provided (retry): send only to those subscribers (never re-send to healthy ones).
+	* Returns list of subscribers that failed (empty if all succeeded).
+	*/
+	async sendEventToSubscribers(event, subscriberNames) {
+		const startTime = event.timestamp;
+		const failures = [];
+		const subscribersToTry = subscriberNames === void 0 ? this.subscribers : this.subscribers.filter((s) => subscriberNames.has(getSubscriberName(s)));
+		const results = await Promise.allSettled(subscribersToTry.map(async (subscriber) => {
+			const subscriberName = getSubscriberName(subscriber);
+			try {
+				await subscriber.trackEvent(event.name, event.attributes, {
+					autotel: event.autotel,
+					schema: event.schema
+				});
+				this.recordDelivered(event, subscriberName, startTime);
+				return {
+					subscriberName,
+					success: true
+				};
+			} catch (error) {
+				this.markSubscriberUnhealthy(subscriberName);
+				return {
+					subscriberName,
+					success: false,
+					error: error instanceof Error ? error : void 0
+				};
+			}
+		}));
+		for (const result of results) if (result.status === "fulfilled" && !result.value.success) failures.push({
+			subscriberName: result.value.subscriberName,
+			error: result.value.error
+		});
+		return failures;
+	}
+	/**
+	* Flush all remaining events. Queue remains usable after flush (e.g. for
+	* auto-flush at root span end). Use shutdown() when tearing down the queue.
+	*/
+	async flush() {
+		if (this.flushTimer) {
+			clearTimeout(this.flushTimer);
+			this.flushTimer = null;
+		}
+		if (this.flushPromise) await this.flushPromise;
+		while (this.queue.length > 0) await this.doFlushBatch();
+	}
+	/**
+	* Flush remaining events and permanently disable the queue (reject new events).
+	* Use for process/SDK shutdown; use flush() for periodic or span-end drain.
+	*/
+	async shutdown() {
+		this.isShuttingDown = true;
+		await this.flush();
+	}
+	/**
+	* Cleanup observable metric callbacks to prevent memory leaks
+	* Call this when destroying the EventQueue instance
+	*/
+	cleanup() {
+		for (const cleanupFn of this.observableCleanups) try {
+			cleanupFn();
+		} catch {}
+		this.observableCleanups = [];
+	}
+	/**
+	* Get queue size (for testing/debugging)
+	*/
+	size() {
+		return this.queue.length;
+	}
+	/**
+	* Get subscriber health status (for testing/debugging)
+	*/
+	getSubscriberHealth() {
+		return new Map(this.subscriberHealthy);
+	}
+	/**
+	* Check if a specific subscriber is healthy
+	*/
+	isSubscriberHealthy(subscriberName) {
+		return this.subscriberHealthy.get(subscriberName.toLowerCase()) ?? true;
+	}
+	/**
+	* Manually mark a subscriber as healthy or unhealthy
+	* (used for circuit breaker integration)
+	*/
+	setSubscriberHealth(subscriberName, healthy) {
+		this.subscriberHealthy.set(subscriberName.toLowerCase(), healthy);
+	}
+};
+
+//#endregion
+//#region src/validation.ts
+const DEFAULT_CONFIG$1 = {
+	maxEventNameLength: 100,
+	maxAttributeKeyLength: 100,
+	maxAttributeValueLength: 1e3,
+	maxAttributeCount: 50,
+	maxNestingDepth: 3,
+	sensitivePatterns: [
+		/password/i,
+		/secret/i,
+		/token/i,
+		/api[_-]?key/i,
+		/access[_-]?key/i,
+		/private[_-]?key/i,
+		/auth/i,
+		/credential/i,
+		/ssn/i,
+		/credit[_-]?card/i
+	]
+};
+var ValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ValidationError";
+	}
+};
+/**
+* Validate and sanitize event name
+* Throws ValidationError if invalid
+*/
+function validateEventName(eventName, config = DEFAULT_CONFIG$1) {
+	if (typeof eventName !== "string") throw new ValidationError(`Event name must be a string, got ${typeof eventName}`);
+	const trimmed = eventName.trim();
+	if (trimmed.length === 0) throw new ValidationError("Event name cannot be empty");
+	if (trimmed.length > config.maxEventNameLength) throw new ValidationError(`Event name too long (${trimmed.length} chars). Max: ${config.maxEventNameLength}`);
+	if (!/^[a-zA-Z0-9._-]+$/.test(trimmed)) throw new ValidationError(`Event name contains invalid characters: "${trimmed}". Use only letters, numbers, dots, underscores, and hyphens.`);
+	return trimmed;
+}
+/**
+* Validate and sanitize attributes
+* Returns sanitized attributes (sensitive data redacted)
+*/
+function validateAttributes(attributes, config = DEFAULT_CONFIG$1) {
+	if (attributes === void 0 || attributes === null) return;
+	if (typeof attributes !== "object" || Array.isArray(attributes)) throw new ValidationError("Attributes must be an object");
+	const keys = Object.keys(attributes);
+	if (keys.length > config.maxAttributeCount) throw new ValidationError(`Too many attributes (${keys.length}). Max: ${config.maxAttributeCount}`);
+	const sanitized = {};
+	for (const key of keys) {
+		if (key.length > config.maxAttributeKeyLength) throw new ValidationError(`Attribute key too long: "${key.slice(0, 20)}..." (${key.length} chars). Max: ${config.maxAttributeKeyLength}`);
+		const value = attributes[key];
+		if (typeof value === "string" && config.sensitivePatterns.some((pattern) => pattern.test(key))) {
+			sanitized[key] = "[REDACTED]";
+			continue;
+		}
+		sanitized[key] = sanitizeValue(value, config, 1);
+	}
+	return sanitized;
+}
+/**
+* Sanitize attribute value (recursive)
+*/
+function sanitizeValue(value, config, depth) {
+	if (depth > config.maxNestingDepth) return "[MAX_DEPTH_EXCEEDED]";
+	if (value === null || value === void 0) return value;
+	if (typeof value === "string") {
+		if (value.length > config.maxAttributeValueLength) return value.slice(0, config.maxAttributeValueLength) + "...";
+		return value;
+	}
+	if (typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) return value.map((item) => sanitizeValue(item, config, depth + 1));
+	if (typeof value === "object") try {
+		JSON.stringify(value);
+		const sanitized = {};
+		for (const key in value) if (Object.prototype.hasOwnProperty.call(value, key)) {
+			const nested = value[key];
+			sanitized[key] = typeof nested === "string" && config.sensitivePatterns.some((pattern) => pattern.test(key)) ? "[REDACTED]" : sanitizeValue(nested, config, depth + 1);
+		}
+		return sanitized;
+	} catch {
+		return "[CIRCULAR]";
+	}
+	return `[${typeof value}]`;
+}
+/**
+* Validate and sanitize an events event
+* Returns { eventName, attributes } with sanitized values
+*/
+function validateEvent(eventName, attributes, config) {
+	const fullConfig = {
+		...DEFAULT_CONFIG$1,
+		...config
+	};
+	return {
+		eventName: validateEventName(eventName, fullConfig),
+		attributes: validateAttributes(attributes, fullConfig)
+	};
+}
+
+//#endregion
+//#region src/track.ts
+/**
+* Global track() function for business events
+*
+* Simple, no instantiation needed, auto-attaches trace context
+*/
+let eventsQueue = null;
+/**
+* Build autotel event context for trace correlation
+*
+* Works in multiple contexts:
+* 1. Inside a span → use current span's trace_id + span_id
+* 2. Outside span → use correlation_id only
+* 3. With trace URL config → include clickable trace URL
+*/
+function buildAutotelContext(span) {
+	const eventsConfig = getEventsConfig();
+	const config = getConfig();
+	const correlationId = getOrCreateCorrelationId();
+	if (!eventsConfig?.includeTraceContext) return { correlation_id: correlationId };
+	const autotelContext = { correlation_id: correlationId };
+	const spanContext = span?.spanContext();
+	if (spanContext) {
+		autotelContext.trace_id = spanContext.traceId;
+		autotelContext.span_id = spanContext.spanId;
+		autotelContext.trace_flags = spanContext.traceFlags.toString(16).padStart(2, "0");
+		const traceState = spanContext.traceState;
+		if (traceState) try {
+			if (typeof traceState.serialize === "function") {
+				const traceStateStr = traceState.serialize();
+				if (traceStateStr) autotelContext.trace_state = traceStateStr;
+			}
+		} catch {}
+		if (eventsConfig.traceUrl && config) {
+			const traceUrl = eventsConfig.traceUrl({
+				traceId: spanContext.traceId,
+				spanId: spanContext.spanId,
+				correlationId,
+				serviceName: config.service,
+				environment: config.environment
+			});
+			if (traceUrl) autotelContext.trace_url = traceUrl;
+		}
+	} else if (eventsConfig.traceUrl && config) {
+		const traceUrl = eventsConfig.traceUrl({
+			correlationId,
+			serviceName: config.service,
+			environment: config.environment
+		});
+		if (traceUrl) autotelContext.trace_url = traceUrl;
+	}
+	return autotelContext;
+}
+/**
+* Initialize events queue lazily
+*/
+function getOrCreateQueue() {
+	if (!isInitialized()) {
+		warnIfNotInitialized("track()");
+		return null;
+	}
+	if (!eventsQueue) {
+		const config = getConfig();
+		if (!config?.subscribers || config.subscribers.length === 0) return null;
+		eventsQueue = new EventQueue(config.subscribers);
+	}
+	return eventsQueue;
+}
+/**
+* Track a business events event
+*
+* Features:
+* - Auto-attaches traceId and spanId if in active span
+* - Batched sending with retry
+* - Type-safe with optional generic
+* - No-op if init() not called or no subscribers configured
+*
+* @example Basic usage
+* ```typescript
+* track('user.signup', { userId: '123', plan: 'pro' })
+* ```
+*
+* @example With type safety
+* ```typescript
+* interface EventDatas {
+*   'user.signup': { userId: string; plan: string }
+*   'plan.upgraded': { userId: string; revenue: number }
+* }
+*
+* track<EventDatas>('user.signup', { userId: '123', plan: 'pro' })
+* ```
+*
+* @example Trace correlation (automatic)
+* ```typescript
+* @Instrumented()
+* class UserService {
+*   async createUser(data: CreateUserData) {
+*     // This track call automatically includes traceId + spanId
+*     track('user.signup', { userId: data.id })
+*   }
+* }
+* ```
+*/
+function track(event, data, options) {
+	const queue = getOrCreateQueue();
+	if (!queue) return;
+	const validated = validateEvent(event, data, getValidationConfig() || void 0);
+	const span = trace.getActiveSpan();
+	const enrichedData = span ? {
+		...validated.attributes,
+		traceId: span.spanContext().traceId,
+		spanId: span.spanContext().spanId
+	} : validated.attributes;
+	const autotelContext = buildAutotelContext(span);
+	queue.enqueue({
+		name: validated.eventName,
+		attributes: enrichedData,
+		timestamp: Date.now(),
+		autotel: autotelContext,
+		schema: options?.schema
+	});
+}
+/**
+* Get events queue (for flush/shutdown)
+* @internal
+*/
+function getEventQueue() {
+	return eventsQueue;
+}
+/**
+* Reset events queue (for shutdown/cleanup)
+* @internal
+*/
+function resetEventQueue() {
+	eventsQueue = null;
+}
+
+//#endregion
+//#region src/circuit-breaker.ts
+const DEFAULT_CONFIG = {
+	failureThreshold: 5,
+	resetTimeout: 3e4,
+	windowSize: 6e4
+};
+const CircuitState = {
+	CLOSED: "CLOSED",
+	OPEN: "OPEN",
+	HALF_OPEN: "HALF_OPEN"
+};
+/**
+* Circuit breaker implementation
+*
+* Tracks failures and automatically opens the circuit to prevent
+* overwhelming failing subscribers.
+*/
+var CircuitBreaker = class {
+	state = CircuitState.CLOSED;
+	failures = [];
+	lastFailureTime = 0;
+	config;
+	name;
+	constructor(name, config) {
+		this.name = name;
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Execute a function with circuit breaker protection
+	* Throws CircuitOpenError if circuit is open
+	*/
+	async execute(fn) {
+		if (this.state === CircuitState.OPEN) {
+			const now = Date.now();
+			if (now - this.lastFailureTime >= this.config.resetTimeout) this.state = CircuitState.HALF_OPEN;
+			else throw new CircuitOpenError(`Circuit breaker is OPEN for ${this.name}. Will retry in ${Math.ceil((this.config.resetTimeout - (now - this.lastFailureTime)) / 1e3)}s`);
+		}
+		try {
+			const result = await fn();
+			if (this.state === CircuitState.HALF_OPEN) this.reset();
+			return result;
+		} catch (error) {
+			this.recordFailure(error);
+			throw error;
+		}
+	}
+	/**
+	* Record a failure and potentially open the circuit
+	*/
+	recordFailure(error) {
+		const now = Date.now();
+		this.failures = this.failures.filter((f) => now - f.timestamp < this.config.windowSize);
+		this.failures.push({
+			timestamp: now,
+			error: error instanceof Error ? error.message : String(error)
+		});
+		this.lastFailureTime = now;
+		if (this.failures.length >= this.config.failureThreshold) {
+			if (this.state === CircuitState.HALF_OPEN) this.state = CircuitState.OPEN;
+			else if (this.state === CircuitState.CLOSED) this.state = CircuitState.OPEN;
+		}
+	}
+	/**
+	* Reset the circuit breaker (on success)
+	*/
+	reset() {
+		this.state = CircuitState.CLOSED;
+		this.failures = [];
+		this.lastFailureTime = 0;
+	}
+	/**
+	* Get current state (for monitoring)
+	*/
+	getState() {
+		return this.state;
+	}
+	/**
+	* Get failure count in current window
+	*/
+	getFailureCount() {
+		const now = Date.now();
+		this.failures = this.failures.filter((f) => now - f.timestamp < this.config.windowSize);
+		return this.failures.length;
+	}
+	/**
+	* Get recent failures (for debugging)
+	*/
+	getRecentFailures() {
+		const now = Date.now();
+		return this.failures.filter((f) => now - f.timestamp < this.config.windowSize);
+	}
+	/**
+	* Manually reset the circuit breaker (for testing or manual intervention)
+	*/
+	forceReset() {
+		this.reset();
+	}
+	/**
+	* Manually open the circuit (for testing or manual intervention)
+	*/
+	forceOpen() {
+		this.state = CircuitState.OPEN;
+		this.lastFailureTime = Date.now();
+	}
+};
+/**
+* Error thrown when circuit is open
+*/
+var CircuitOpenError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CircuitOpenError";
+	}
+};
+
+//#endregion
+//#region src/operation-context.ts
+/**
+* Operation context tracking using AsyncLocalStorage
+*
+* This module provides a way to track operation names across async boundaries
+* so they can be automatically captured in events events.
+*
+* We cannot read span attributes from OpenTelemetry's API (it's write-only),
+* so we maintain our own async context storage.
+*/
+/**
+* AsyncLocalStorage instance for tracking operation context
+*/
+const operationStorage = new nodeAsyncHooks.AsyncLocalStorage();
+/**
+* Get the current operation context (if any)
+*
+* @returns The current operation context, or undefined if not in an operation
+*
+* @example
+* ```typescript
+* const ctx = getOperationContext();
+* if (ctx) {
+*   console.log('Current operation:', ctx.name);
+* }
+* ```
+*/
+function getOperationContext() {
+	return operationStorage.getStore();
+}
+/**
+* Run a function within an operation context
+*
+* This sets the operation name for the duration of the function execution,
+* including all async operations spawned from it.
+*
+* @param name - The operation name to set
+* @param fn - The function to execute within the context
+* @returns The result of the function
+*
+* @example
+* ```typescript
+* const result = await runInOperationContext('user.create', async () => {
+*   // Any events.trackEvent() calls here will automatically capture
+*   // 'operation.name': 'user.create'
+*   await createUser();
+*   return 'success';
+* });
+* ```
+*/
+function runInOperationContext(name, fn) {
+	return operationStorage.run({ name }, fn);
+}
+
+//#endregion
+//#region src/events-config.ts
+/**
+* Hash a string value for PII protection
+*
+* Uses a simple, fast hash function suitable for correlation.
+* NOT cryptographically secure - use for PII masking, not security.
+*/
+function hashValue(value) {
+	let hash = 0;
+	for (let i = 0; i < value.length; i++) {
+		const char = value.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+//#endregion
+//#region src/event.ts
+/**
+* Events API for product events platforms
+*
+* Track user behavior, business events, and critical actions.
+* Sends to product events platforms (PostHog, Mixpanel, Amplitude) via subscribers.
+* For business people who think in events/funnels.
+*
+* For OpenTelemetry metrics (Prometheus/Grafana), use the Metrics class instead.
+*
+* @example Recommended: Configure subscribers in init(), use track() function
+* ```typescript
+* import { init, track } from 'autotel';
+* import { PostHogSubscriber } from 'autotel-subscribers/posthog';
+*
+* init({
+*   service: 'my-app',
+*   subscribers: [new PostHogSubscriber({ apiKey: 'phc_...' })]
+* });
+*
+* // Track events - uses subscribers from init()
+* track('application.submitted', { jobId: '123', userId: '456' });
+* ```
+*
+* @example Create Event instance (inherits subscribers from init)
+* ```typescript
+* import { Event } from 'autotel/event';
+*
+* // Uses subscribers configured in init()
+* const event = new Event('job-application');
+* event.trackEvent('application.submitted', { jobId: '123' });
+* ```
+*
+* @example Override subscribers for specific Event instance
+* ```typescript
+* import { Event } from 'autotel/event';
+* import { PostHogSubscriber } from 'autotel-subscribers/posthog';
+*
+* // Override: use different subscribers for this instance
+* const event = new Event('job-application', {
+*   subscribers: [new PostHogSubscriber({ apiKey: 'phc_different_project' })]
+* });
+*
+* event.trackEvent('application.submitted', { jobId: '123' });
+* ```
+*/
+var Event = class {
+	serviceName;
+	logger;
+	collector;
+	subscribers;
+	hasSubscribers;
+	circuitBreakers;
+	/**
+	* Create a new Event instance
+	*
+	* **Note**: Most users should use `init()` + `track()` instead of creating Event instances directly.
+	*
+	* **Subscriber Resolution**:
+	* - If `subscribers` provided in options → uses those (instance override)
+	* - If `subscribers` not provided → falls back to subscribers from `init()` (global config)
+	* - If neither → no subscribers (events logged only)
+	*
+	* @param serviceName - Service name for identifying events
+	* @param options - Optional configuration (logger, collector, subscribers)
+	*
+	* @example Recommended: Use track() with init()
+	* ```typescript
+	* import { init, track } from 'autotel';
+	* import { PostHogSubscriber } from 'autotel-subscribers/posthog';
+	*
+	* init({
+	*   service: 'checkout',
+	*   subscribers: [new PostHogSubscriber({ apiKey: 'phc_...' })]
+	* });
+	*
+	* track('purchase.completed', { amount: 99.99 });
+	* ```
+	*
+	* @example Inherit subscribers from init()
+	* ```typescript
+	* // Uses subscribers configured in init()
+	* const event = new Event('checkout');
+	* event.trackEvent('purchase.completed', { amount: 99.99 });
+	* ```
+	*
+	* @example Override subscribers for this instance
+	* ```typescript
+	* import { Event } from 'autotel/event';
+	* import { PostHogSubscriber } from 'autotel-subscribers/posthog';
+	*
+	* // Override: use different subscribers for this instance only
+	* const event = new Event('checkout', {
+	*   subscribers: [new PostHogSubscriber({ apiKey: 'phc_different_project' })]
+	* });
+	* ```
+	*/
+	constructor(serviceName, options = {}) {
+		this.serviceName = serviceName;
+		this.logger = options.logger;
+		this.collector = options.collector;
+		this.subscribers = options.subscribers === void 0 ? getConfig()?.subscribers || [] : options.subscribers;
+		this.hasSubscribers = this.subscribers.length > 0;
+		this.circuitBreakers = /* @__PURE__ */ new Map();
+		for (const subscriber of this.subscribers) {
+			const subscriberName = subscriber.name || "Unknown";
+			this.circuitBreakers.set(subscriber, new CircuitBreaker(subscriberName, {
+				failureThreshold: 5,
+				resetTimeout: 3e4,
+				windowSize: 6e4
+			}));
+		}
+	}
+	/**
+	* Automatically enrich attributes with all available telemetry context
+	*
+	* Auto-captures:
+	* - Resource attributes: service.version, deployment.environment
+	* - Trace context: traceId, spanId, correlationId
+	* - Operation context: operation.name
+	*/
+	enrichWithTelemetryContext(attributes = {}) {
+		const enriched = {
+			service: this.serviceName,
+			...attributes
+		};
+		const config = getConfig();
+		if (config) {
+			if (config.version) enriched["service.version"] = config.version;
+			if (config.environment) enriched["deployment.environment"] = config.environment;
+		}
+		const spanContext = trace.getActiveSpan()?.spanContext();
+		if (spanContext) {
+			enriched.traceId = spanContext.traceId;
+			enriched.spanId = spanContext.spanId;
+			enriched.correlationId = spanContext.traceId.slice(0, 16);
+		}
+		const operationContext = getOperationContext();
+		if (operationContext) enriched["operation.name"] = operationContext.name;
+		return enriched;
+	}
+	/**
+	* Build autotel event context for trace correlation
+	*
+	* Works in 4 contexts:
+	* 1. Inside a span → use current span's trace_id + span_id
+	* 2. Outside span but in AsyncLocalStorage context → use trace_id + correlation_id
+	* 3. Totally standalone → use correlation_id + service/env/version
+	* 4. Batch/fan-in (multiple linked parents) → use count + hash or full array
+	*
+	* @returns AutotelEventContext or undefined if trace context is disabled
+	*/
+	buildAutotelContext() {
+		const eventsConfig = getEventsConfig();
+		if (!eventsConfig?.includeTraceContext) return { correlation_id: getOrCreateCorrelationId() };
+		const config = getConfig();
+		const spanContext = trace.getActiveSpan()?.spanContext();
+		const correlationId = getOrCreateCorrelationId();
+		const autotelContext = { correlation_id: correlationId };
+		if (spanContext) {
+			autotelContext.trace_id = spanContext.traceId;
+			autotelContext.span_id = spanContext.spanId;
+			autotelContext.trace_flags = spanContext.traceFlags.toString(16).padStart(2, "0");
+			const traceState = spanContext.traceState;
+			if (traceState) {
+				let traceStateStr = "";
+				try {
+					if (typeof traceState.serialize === "function") traceStateStr = traceState.serialize();
+				} catch {}
+				if (traceStateStr) autotelContext.trace_state = traceStateStr;
+			}
+			if (eventsConfig.traceUrl) {
+				const traceUrl = eventsConfig.traceUrl({
+					traceId: spanContext.traceId,
+					spanId: spanContext.spanId,
+					correlationId,
+					serviceName: config?.service || this.serviceName,
+					environment: config?.environment
+				});
+				if (traceUrl) autotelContext.trace_url = traceUrl;
+			}
+		} else if (eventsConfig.traceUrl && config) {
+			const traceUrl = eventsConfig.traceUrl({
+				correlationId,
+				serviceName: config.service,
+				environment: config.environment
+			});
+			if (traceUrl) autotelContext.trace_url = traceUrl;
+		}
+		return autotelContext;
+	}
+	/**
+	* Enrich event attributes from baggage with guardrails
+	*
+	* @param attributes - Current event attributes
+	* @returns Enriched attributes with baggage values
+	*/
+	enrichFromBaggage(attributes) {
+		const enrichConfig = getEventsConfig()?.enrichFromBaggage;
+		if (!enrichConfig) return attributes;
+		const enriched = { ...attributes };
+		const activeContext = context.active();
+		const baggage = propagation.getBaggage(activeContext);
+		if (!baggage) return enriched;
+		let keyCount = 0;
+		let byteCount = 0;
+		const maxKeys = enrichConfig.maxKeys ?? 10;
+		const maxBytes = enrichConfig.maxBytes ?? 1024;
+		const prefix = enrichConfig.prefix ?? "";
+		for (const [key, entry] of baggage.getAllEntries()) {
+			if (!this.isBaggageKeyAllowed(key, enrichConfig)) continue;
+			if (keyCount >= maxKeys) break;
+			const value = entry.value;
+			const transform = enrichConfig.transform?.[key];
+			let transformedValue;
+			if (transform === "hash") transformedValue = hashValue(value);
+			else if (transform === "plain" || !transform) transformedValue = value;
+			else if (typeof transform === "function") transformedValue = transform(value);
+			else transformedValue = value;
+			const valueBytes = new TextEncoder().encode(transformedValue).length;
+			if (byteCount + valueBytes > maxBytes) continue;
+			const enrichedKey = `${prefix}${key}`;
+			enriched[enrichedKey] = transformedValue;
+			keyCount++;
+			byteCount += valueBytes;
+		}
+		return enriched;
+	}
+	/**
+	* Check if a baggage key is allowed based on config
+	*/
+	isBaggageKeyAllowed(key, config) {
+		if (config.deny) {
+			for (const pattern of config.deny) if (this.matchesBaggagePattern(key, pattern)) return false;
+		}
+		for (const pattern of config.allow) if (this.matchesBaggagePattern(key, pattern)) return true;
+		return false;
+	}
+	/**
+	* Check if a key matches a baggage pattern
+	* Supports exact matches and wildcard patterns (e.g., 'tenant.*')
+	*/
+	matchesBaggagePattern(key, pattern) {
+		if (pattern.endsWith(".*")) {
+			const prefix = pattern.slice(0, -2);
+			return key.startsWith(prefix + ".");
+		}
+		return key === pattern;
+	}
+	/**
+	* Track a business event
+	*
+	* Use this for tracking user actions, business events, product usage:
+	* - "user.signup"
+	* - "order.completed"
+	* - "feature.used"
+	*
+	* Events are sent to configured subscribers (PostHog, Mixpanel, etc.).
+	*
+	* @example
+	* ```typescript
+	* // Track user signup
+	* events.trackEvent('user.signup', {
+	*   userId: '123',
+	*   plan: 'pro'
+	* })
+	*
+	* // Track order
+	* events.trackEvent('order.completed', {
+	*   orderId: 'ord_123',
+	*   amount: 99.99
+	* })
+	* ```
+	*/
+	trackEvent(eventName, attributes) {
+		const validated = validateEvent(eventName, attributes, getValidationConfig() || void 0);
+		const enrichedAttributes = this.enrichWithTelemetryContext(validated.attributes);
+		this.logger?.info({
+			event: validated.eventName,
+			attributes: enrichedAttributes
+		}, "Event tracked");
+		this.collector?.recordEvent({
+			event: validated.eventName,
+			attributes: enrichedAttributes,
+			service: this.serviceName,
+			timestamp: Date.now()
+		});
+		if (this.hasSubscribers) {
+			const autotelContext = this.buildAutotelContext();
+			const finalAttributes = this.enrichFromBaggage(enrichedAttributes);
+			this.notifySubscribers((subscriber) => subscriber.trackEvent(validated.eventName, finalAttributes, { autotel: autotelContext }));
+		}
+	}
+	/**
+	* Notify all subscribers concurrently without blocking
+	* Uses circuit breakers to protect against failing subscribers
+	* Uses Promise.allSettled to prevent subscriber errors from affecting other subscribers
+	*/
+	async notifySubscribers(fn) {
+		const promises = this.subscribers.map(async (subscriber) => {
+			const circuitBreaker = this.circuitBreakers.get(subscriber);
+			if (!circuitBreaker) return;
+			try {
+				await circuitBreaker.execute(() => fn(subscriber));
+			} catch (error) {
+				if (error instanceof CircuitOpenError) {
+					getLogger().warn({ subscriberName: subscriber.name || "Unknown" }, `[Events] ${error.message}`);
+					return;
+				}
+				getLogger().error({
+					err: error instanceof Error ? error : void 0,
+					subscriberName: subscriber.name || "Unknown"
+				}, `[Events] Subscriber ${subscriber.name || "Unknown"} failed`);
+			}
+		});
+		await Promise.allSettled(promises);
+	}
+	/**
+	* Track conversion funnel steps
+	*
+	* Monitor where users drop off in multi-step processes.
+	*
+	* @example
+	* ```typescript
+	* // Track signup funnel
+	* events.trackFunnelStep('signup', 'started', { userId: '123' })
+	* events.trackFunnelStep('signup', 'email_verified', { userId: '123' })
+	* events.trackFunnelStep('signup', 'completed', { userId: '123' })
+	*
+	* // Track checkout flow
+	* events.trackFunnelStep('checkout', 'started', { cartValue: 99.99 })
+	* events.trackFunnelStep('checkout', 'payment_info', { cartValue: 99.99 })
+	* events.trackFunnelStep('checkout', 'completed', { cartValue: 99.99 })
+	* ```
+	*/
+	trackFunnelStep(funnelName, status, attributes) {
+		const enrichedAttributes = this.enrichWithTelemetryContext(attributes);
+		this.logger?.info({
+			funnel: funnelName,
+			status,
+			attributes: enrichedAttributes
+		}, "Funnel step tracked");
+		this.collector?.recordFunnelStep({
+			funnel: funnelName,
+			status,
+			attributes: enrichedAttributes,
+			service: this.serviceName,
+			timestamp: Date.now()
+		});
+		if (this.hasSubscribers) {
+			const autotelContext = this.buildAutotelContext();
+			const finalAttributes = this.enrichFromBaggage(enrichedAttributes);
+			this.notifySubscribers((subscriber) => subscriber.trackFunnelStep(funnelName, status, finalAttributes, { autotel: autotelContext }));
+		}
+	}
+	/**
+	* Track outcomes (success/failure/partial)
+	*
+	* Monitor success rates of critical operations.
+	*
+	* @example
+	* ```typescript
+	* // Track email delivery
+	* events.trackOutcome('email.delivery', 'success', {
+	*   recipientType: 'user',
+	*   emailType: 'welcome'
+	* })
+	*
+	* events.trackOutcome('email.delivery', 'failure', {
+	*   recipientType: 'user',
+	*   errorCode: 'invalid_email'
+	* })
+	*
+	* // Track payment processing
+	* events.trackOutcome('payment.process', 'success', { amount: 99.99 })
+	* events.trackOutcome('payment.process', 'failure', { error: 'insufficient_funds' })
+	* ```
+	*/
+	trackOutcome(operationName, status, attributes) {
+		const enrichedAttributes = this.enrichWithTelemetryContext(attributes);
+		this.logger?.info({
+			operation: operationName,
+			status,
+			attributes: enrichedAttributes
+		}, "Outcome tracked");
+		this.collector?.recordOutcome({
+			operation: operationName,
+			status,
+			attributes: enrichedAttributes,
+			service: this.serviceName,
+			timestamp: Date.now()
+		});
+		if (this.hasSubscribers) {
+			const autotelContext = this.buildAutotelContext();
+			const finalAttributes = this.enrichFromBaggage(enrichedAttributes);
+			this.notifySubscribers((subscriber) => subscriber.trackOutcome(operationName, status, finalAttributes, { autotel: autotelContext }));
+		}
+	}
+	/**
+	* Track value metrics
+	*
+	* Record numerical values like revenue, transaction amounts,
+	* item counts, processing times, engagement scores, etc.
+	*
+	* @example
+	* ```typescript
+	* // Track revenue
+	* events.trackValue('order.revenue', 149.99, {
+	*   currency: 'USD',
+	*   productCategory: 'electronics'
+	* })
+	*
+	* // Track items per cart
+	* events.trackValue('cart.item_count', 5, {
+	*   userId: '123'
+	* })
+	*
+	* // Track processing time
+	* events.trackValue('api.response_time', 250, {
+	*   unit: 'ms',
+	*   endpoint: '/api/checkout'
+	* })
+	* ```
+	*/
+	trackValue(metricName, value, attributes) {
+		const enrichedAttributes = this.enrichWithTelemetryContext({
+			metric: metricName,
+			...attributes
+		});
+		this.logger?.debug({
+			metric: metricName,
+			value,
+			attributes: enrichedAttributes
+		}, "Value tracked");
+		this.collector?.recordValue({
+			metric: metricName,
+			value,
+			attributes: enrichedAttributes,
+			service: this.serviceName,
+			timestamp: Date.now()
+		});
+		if (this.hasSubscribers) {
+			const autotelContext = this.buildAutotelContext();
+			const finalAttributes = this.enrichFromBaggage(enrichedAttributes);
+			this.notifySubscribers((subscriber) => subscriber.trackValue(metricName, value, finalAttributes, { autotel: autotelContext }));
+		}
+	}
+	/**
+	* Flush all subscribers and wait for pending events
+	*
+	* Call this before shutdown to ensure all events are delivered.
+	*
+	* @example
+	* ```typescript
+	* const event =new Event('app', { subscribers: [...] });
+	*
+	* // Before shutdown
+	* await events.flush();
+	* ```
+	*/
+	async flush() {
+		if (!this.hasSubscribers) return;
+		const shutdownPromises = this.subscribers.map(async (subscriber) => {
+			if (subscriber.shutdown) try {
+				await subscriber.shutdown();
+			} catch (error) {
+				getLogger().error({
+					err: error instanceof Error ? error : void 0,
+					subscriberName: subscriber.name || "Unknown"
+				}, `[Events] Failed to shutdown subscriber ${subscriber.name || "Unknown"}`);
+			}
+		});
+		await Promise.allSettled(shutdownPromises);
+	}
+	/**
+	* Shutdown the Event instance and all subscribers
+	*
+	* Unlike `flush()`, this method:
+	* - Shuts down all subscribers
+	* - Prevents further event tracking (hasSubscribers becomes false)
+	* - Should only be called once at application shutdown
+	*
+	* @example
+	* ```typescript
+	* // In Next.js API route with after()
+	* import { after } from 'next/server';
+	*
+	* export async function POST(req: Request) {
+	*   const event = new Event('checkout', { subscribers: [...] });
+	*   event.trackEvent('order.completed', { orderId: '123' });
+	*
+	*   after(async () => {
+	*     await event.shutdown();
+	*   });
+	*
+	*   return Response.json({ success: true });
+	* }
+	* ```
+	*/
+	async shutdown() {
+		if (!this.hasSubscribers) return;
+		await Promise.allSettled(this.subscribers.map(async (subscriber) => {
+			if (subscriber.shutdown) try {
+				await subscriber.shutdown();
+			} catch (error) {
+				getLogger().error({
+					err: error instanceof Error ? error : void 0,
+					subscriberName: subscriber.name || "Unknown"
+				}, `[Events] Failed to shutdown subscriber ${subscriber.name || "Unknown"}`);
+			}
+		}));
+		this.hasSubscribers = false;
+	}
+	/**
+	* Track funnel progression with custom step names
+	*
+	* Unlike trackFunnelStep which uses FunnelStatus enum values,
+	* this method allows any string as the step name for flexible funnel tracking.
+	*
+	* @param funnelName - Name of the funnel (e.g., "checkout", "onboarding")
+	* @param stepName - Custom step name (e.g., "cart_viewed", "payment_entered")
+	* @param stepNumber - Optional numeric position in the funnel
+	* @param attributes - Optional event attributes
+	*
+	* @example
+	* ```typescript
+	* // Track custom checkout steps
+	* event.trackFunnelProgression('checkout', 'cart_viewed', 1);
+	* event.trackFunnelProgression('checkout', 'shipping_selected', 2);
+	* event.trackFunnelProgression('checkout', 'payment_entered', 3);
+	* event.trackFunnelProgression('checkout', 'order_confirmed', 4);
+	* ```
+	*/
+	trackFunnelProgression(funnelName, stepName, stepNumber, attributes) {
+		const enrichedAttributes = this.enrichWithTelemetryContext(attributes);
+		this.logger?.info({
+			funnel: funnelName,
+			stepName,
+			stepNumber,
+			attributes: enrichedAttributes
+		}, "Funnel progression tracked");
+		this.collector?.recordFunnelStep({
+			funnel: funnelName,
+			status: stepName,
+			attributes: {
+				...enrichedAttributes,
+				step_name: stepName,
+				...stepNumber === void 0 ? {} : { step_number: stepNumber }
+			},
+			service: this.serviceName,
+			timestamp: Date.now()
+		});
+		if (this.hasSubscribers) {
+			const autotelContext = this.buildAutotelContext();
+			const finalAttributes = this.enrichFromBaggage(enrichedAttributes);
+			this.notifySubscribers(async (subscriber) => {
+				await (subscriber.trackFunnelProgression ? subscriber.trackFunnelProgression(funnelName, stepName, stepNumber, finalAttributes, { autotel: autotelContext }) : subscriber.trackFunnelStep(funnelName, stepName, {
+					...finalAttributes,
+					step_name: stepName,
+					...stepNumber === void 0 ? {} : { step_number: stepNumber }
+				}, { autotel: autotelContext }));
+			});
+		}
+	}
+	/**
+	* Track multiple events in a batch
+	*
+	* Useful for bulk event tracking with consistent timestamps.
+	* Events are sent to subscribers individually but processed together.
+	*
+	* @param events - Array of events to track
+	*
+	* @example
+	* ```typescript
+	* event.trackBatch([
+	*   { name: 'item.viewed', attributes: { itemId: '1' } },
+	*   { name: 'item.viewed', attributes: { itemId: '2' } },
+	*   { name: 'cart.updated', attributes: { itemCount: 2 } },
+	* ]);
+	* ```
+	*/
+	trackBatch(events) {
+		for (const event of events) {
+			const filteredAttributes = event.attributes ? Object.fromEntries(Object.entries(event.attributes).filter(([, v]) => v !== void 0 && v !== null)) : void 0;
+			this.trackEvent(event.name, filteredAttributes);
+		}
+	}
+};
+/**
+* Global events instances (singleton pattern)
+*/
+const eventsInstances = /* @__PURE__ */ new Map();
+/**
+* Get or create an Events instance for a service
+*
+* @param serviceName - Service name for identifying events
+* @param logger - Optional logger
+* @returns Events instance
+*
+* @example
+* ```typescript
+* const event =getEvents('job-application')
+* events.trackEvent('application.submitted', { jobId: '123' })
+* ```
+*/
+function getEvents(serviceName, logger) {
+	if (!eventsInstances.has(serviceName)) eventsInstances.set(serviceName, new Event(serviceName, { logger }));
+	return eventsInstances.get(serviceName);
+}
+/**
+* Reset all events instances (mainly for testing)
+*/
+function resetEvents() {
+	eventsInstances.clear();
+}
+
+//#endregion
+//#region src/shutdown.ts
+/**
+* Graceful shutdown with flush and cleanup
+*/
+/**
+* Error codes that mean "the OTLP endpoint wasn't reachable" — expected and
+* harmless when no collector is configured. Deliberately limited to
+* connection-establishment failures (refused / DNS), not post-connection
+* errors like ECONNRESET or ETIMEDOUT, which can indicate a real problem
+* talking to a configured backend and should surface.
+*/
+const UNREACHABLE_ENDPOINT_CODES = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ENOTFOUND",
+	"EAI_AGAIN"
+]);
+function errorCode(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		const code = error.code;
+		if (typeof code === "string") return code;
+	}
+}
+/**
+* True when the error (or every error it wraps) is an unreachable-endpoint
+* failure. Traverses `AggregateError.errors` and the `cause` chain, since the
+* SDK often wraps the underlying network error.
+*/
+function isUnreachableEndpointError(error, depth = 0) {
+	if (depth > 5 || error === null || typeof error !== "object") return false;
+	if (error instanceof AggregateError) return error.errors.length > 0 && error.errors.every((e) => isUnreachableEndpointError(e, depth + 1));
+	const code = errorCode(error);
+	if (code && UNREACHABLE_ENDPOINT_CODES.has(code)) return true;
+	const cause = error.cause;
+	return cause !== void 0 && cause !== error ? isUnreachableEndpointError(cause, depth + 1) : false;
+}
+/**
+* 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 = getEventQueue();
+		if (eventsQueue) await (forShutdown ? eventsQueue.shutdown() : eventsQueue.flush());
+		try {
+			const tracerProvider = getForceFlushableProvider(getSdk());
+			if (tracerProvider) 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);
+		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 = 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 = getSdk();
+		if (sdk) await sdk.shutdown();
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		if (!isUnreachableEndpointError(error)) {
+			if (!shutdownError) shutdownError = err;
+			logger.error({ err }, "[autotel] SDK shutdown failed");
+		}
+	} finally {
+		uninstallProcessHandlers();
+		await _closeEmbeddedDevtools();
+		const eventsQueue = getEventQueue();
+		if (eventsQueue && typeof eventsQueue.cleanup === "function") eventsQueue.cleanup();
+		resetEvents();
+		resetMetrics();
+		resetEventQueue();
+	}
+	if (shutdownError) throw shutdownError;
+}
+
+//#endregion
+//#region src/init.ts
+/**
+* Simplified initialization for autotel
+*
+* Single init() function with sensible defaults.
+* Replaces initInstrumentation() and separate events config.
+*/
+/**
+* Silent logger (no-op) - used as default when user doesn't provide one.
+* Internal autotel logs are silent by default to avoid spam.
+* Users can import { autotelLogger } from 'autotel/logger' to create their own.
+*/
+const silentLogger = {
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	debug: () => {}
+};
+/**
+* Adapts an Autotel Sampler to the OTel SDK Sampler interface.
+*/
+function toOtelSampler(sampler) {
+	return {
+		shouldSample(_context, _traceId, spanName, _spanKind, _attributes, links) {
+			const samplingContext = {
+				operationName: spanName,
+				args: [],
+				links
+			};
+			const shouldTrace = sampler.shouldSample(samplingContext);
+			const rate = sampler.sampleRate?.(samplingContext);
+			return {
+				decision: shouldTrace ? SamplingDecision.RECORD_AND_SAMPLED : SamplingDecision.NOT_RECORD,
+				...shouldTrace && rate !== void 0 && rate > 1 ? { attributes: { [AUTOTEL_SAMPLING_RATE]: rate } } : {}
+			};
+		},
+		toString() {
+			return `AutotelSamplerAdapter`;
+		}
+	};
+}
+let OTLPTraceExporterGRPC;
+let OTLPMetricExporterGRPC;
+let OTLPLogExporterGRPC;
+/**
+* Helper: Lazy-load gRPC trace exporter
+*/
+function loadGRPCTraceExporter() {
+	if (OTLPTraceExporterGRPC) return OTLPTraceExporterGRPC;
+	try {
+		OTLPTraceExporterGRPC = requireModule("@opentelemetry/exporter-trace-otlp-grpc").OTLPTraceExporter;
+		return OTLPTraceExporterGRPC;
+	} catch {
+		throw new Error("gRPC trace exporter not found. Install @opentelemetry/exporter-trace-otlp-grpc");
+	}
+}
+/**
+* Helper: Lazy-load gRPC metric exporter
+*/
+function loadGRPCMetricExporter() {
+	if (OTLPMetricExporterGRPC) return OTLPMetricExporterGRPC;
+	try {
+		OTLPMetricExporterGRPC = requireModule("@opentelemetry/exporter-metrics-otlp-grpc").OTLPMetricExporter;
+		return OTLPMetricExporterGRPC;
+	} catch {
+		throw new Error("gRPC metric exporter not found. Install @opentelemetry/exporter-metrics-otlp-grpc");
+	}
+}
+/**
+* Helper: Create trace exporter based on protocol
+*/
+function createTraceExporter(protocol, config) {
+	if (protocol === "grpc") return new (loadGRPCTraceExporter())(config);
+	return new OTLPTraceExporter(config);
+}
+/**
+* Helper: Create metric exporter based on protocol
+*/
+function createMetricExporter(protocol, config) {
+	if (protocol === "grpc") return new (loadGRPCMetricExporter())(config);
+	return new OTLPMetricExporter(config);
+}
+/**
+* Helper: Lazy-load gRPC log exporter
+*/
+function loadGRPCLogExporter() {
+	if (OTLPLogExporterGRPC) return OTLPLogExporterGRPC;
+	try {
+		OTLPLogExporterGRPC = requireModule("@opentelemetry/exporter-logs-otlp-grpc").OTLPLogExporter;
+		return OTLPLogExporterGRPC;
+	} catch {
+		throw new Error("gRPC log exporter not found. Install @opentelemetry/exporter-logs-otlp-grpc");
+	}
+}
+/**
+* Helper: Create log exporter based on protocol
+*/
+function createLogExporter(protocol, config) {
+	if (protocol === "grpc") return new (loadGRPCLogExporter())(config);
+	return new OTLPLogExporter(config);
+}
+/**
+* Helper: Resolve protocol from config and environment
+*/
+function resolveProtocol(configProtocol) {
+	if (configProtocol === "grpc" || configProtocol === "http") return configProtocol;
+	const envProtocol = process.env.OTEL_EXPORTER_OTLP_PROTOCOL;
+	if (envProtocol === "grpc") return "grpc";
+	if (envProtocol === "http/protobuf" || envProtocol === "http") return "http";
+	return "http";
+}
+/**
+* Helper: Adjust endpoint URL for protocol
+* gRPC exporters don't need the /v1/traces or /v1/metrics path
+* HTTP exporters need the full path
+*/
+function formatEndpointUrl(endpoint, signal, protocol) {
+	if (protocol === "grpc") return endpoint.replace(/\/(v1\/)?(traces|metrics|logs)$/, "");
+	if (!endpoint.endsWith(`/v1/${signal}`)) return `${endpoint}/v1/${signal}`;
+	return endpoint;
+}
+let initialized = false;
+let locked = false;
+let config = null;
+let sdk = null;
+let warnedOnce = false;
+let logger = silentLogger;
+let validationConfig = null;
+let eventsConfig = null;
+let _stringRedactor = null;
+function acceptsStringRedactor(subscriber) {
+	return typeof subscriber === "object" && subscriber !== null && "setStringRedactor" in subscriber && typeof subscriber.setStringRedactor === "function";
+}
+let _optionalRequire = safeRequire;
+let _devtoolsClose = null;
+const LOG_LEVELS = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+/**
+* Lock the logger to prevent further `init()` calls.
+* Use this when framework plugins set up instrumentation and you want
+* to prevent accidental re-initialization from user code.
+*/
+function lockLogger() {
+	locked = true;
+}
+/**
+* Check if the logger has been locked.
+*/
+function isLoggerLocked() {
+	return locked;
+}
+function createSilentLogger() {
+	return {
+		info: () => {},
+		warn: () => {},
+		error: () => {},
+		debug: () => {}
+	};
+}
+function wrapLogger(base, silent, minLevel) {
+	if (silent) return createSilentLogger();
+	const threshold = LOG_LEVELS[minLevel];
+	const wrap = (fn, level) => {
+		if (LOG_LEVELS[level] < threshold) return (() => {});
+		return ((...args) => fn(...args));
+	};
+	return {
+		debug: wrap(base.debug, "debug"),
+		info: wrap(base.info, "info"),
+		warn: wrap(base.warn, "warn"),
+		error: wrap(base.error, "error")
+	};
+}
+/**
+* Resolve the effective attribute redactor. Explicit config wins (`false`
+* disables). Otherwise the `AUTOTEL_REDACT_PII` env var controls it, and as a
+* final default PII redaction is auto-enabled in production.
+*/
+function resolveAttributeRedactor(explicit, environment) {
+	if (explicit === false) return void 0;
+	if (explicit !== void 0) return explicit;
+	const flag = process.env.AUTOTEL_REDACT_PII?.trim().toLowerCase();
+	if (flag) {
+		if ([
+			"off",
+			"false",
+			"0",
+			"none",
+			"disabled"
+		].includes(flag)) return;
+		if (flag === "default" || flag === "strict" || flag === "pci-dss") return flag;
+		if ([
+			"on",
+			"true",
+			"1",
+			"enabled"
+		].includes(flag)) return "default";
+	}
+	return environment === "production" ? "default" : void 0;
+}
+function detectEnvironmentAttributes() {
+	const attrs = {};
+	const commitSha = process.env.COMMIT_SHA || process.env.GITHUB_SHA || process.env.VERCEL_GIT_COMMIT_SHA || process.env.CF_PAGES_COMMIT_SHA || process.env.AWS_CODEPIPELINE_EXECUTION_ID;
+	if (commitSha) attrs["service.commit.sha"] = commitSha;
+	const region = process.env.VERCEL_REGION || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || process.env.FLY_REGION || process.env.CF_REGION || process.env.GOOGLE_CLOUD_REGION;
+	if (region) attrs["service.region"] = region;
+	const version = process.env.APP_VERSION || process.env.HEROKU_RELEASE_VERSION || process.env.VERCEL_GIT_COMMIT_REF;
+	if (version) attrs["service.deploy.version"] = version;
+	return attrs;
+}
+/**
+* Resolve metrics flag with env var override support
+*/
+function resolveMetricsFlag(configFlag = "auto") {
+	const envFlag = process.env.AUTOTEL_METRICS;
+	if (envFlag === "on" || envFlag === "true") return true;
+	if (envFlag === "off" || envFlag === "false") return false;
+	if (configFlag === true) return true;
+	if (configFlag === false) return false;
+	return true;
+}
+/**
+* Resolve logs flag with env var override support.
+* Defaults to disabled (opt-in only) to avoid unexpected log export
+* and to preserve the upstream SDK's OTEL_LOGS_EXPORTER handling.
+*/
+function resolveLogsFlag(configFlag = "auto") {
+	const envFlag = process.env.AUTOTEL_LOGS;
+	if (envFlag === "on" || envFlag === "true") return true;
+	if (envFlag === "off" || envFlag === "false") return false;
+	if (configFlag === true) return true;
+	if (configFlag === false) return false;
+	return false;
+}
+/**
+* Resolve debug flag with env var override support
+*
+* Supports:
+* - `'pretty'`: Colorized, hierarchical output (PrettyConsoleExporter)
+* - `true` / `'true'` / `'1'`: Raw JSON output (ConsoleSpanExporter)
+* - `false` / `'false'` / `'0'`: Disabled
+*/
+function resolveDebugFlag(configFlag) {
+	const envFlag = process.env.AUTOTEL_DEBUG;
+	if (envFlag === "pretty") return "pretty";
+	if (envFlag === "true" || envFlag === "1") return true;
+	if (envFlag === "false" || envFlag === "0") return false;
+	return configFlag ?? false;
+}
+function normalizeOtlpHeaders(headers) {
+	if (!headers) return void 0;
+	if (typeof headers !== "string") return headers;
+	const parsed = {};
+	for (const pair of headers.split(",")) {
+		const [key, ...valueParts] = pair.split("=");
+		if (!key || valueParts.length === 0) continue;
+		parsed[key.trim()] = valueParts.join("=").trim();
+	}
+	return parsed;
+}
+function resolveOtlpDestinations(config, fallbackEndpoint) {
+	return (config.destinations === void 0 ? fallbackEndpoint ? [{
+		endpoint: fallbackEndpoint,
+		headers: config.headers,
+		protocol: config.protocol
+	}] : [] : config.destinations).map((destination) => ({
+		endpoint: destination.endpoint,
+		protocol: resolveProtocol(destination.protocol ?? config.protocol),
+		headers: normalizeOtlpHeaders(destination.headers ?? config.headers),
+		signals: destination.signals ? new Set(destination.signals) : void 0
+	}));
+}
+function destinationSupportsSignal(destination, signal) {
+	return destination.signals ? destination.signals.has(signal) : true;
+}
+/**
+* Initialize autotel - Write Once, Observe Everywhere
+*
+* Follows OpenTelemetry standards: opinionated defaults with full flexibility
+* Idempotent: multiple calls are safe, last one wins
+*
+* @example Minimal setup (OTLP default)
+* ```typescript
+* init({ service: 'my-app' })
+* ```
+*
+* @example With events (observe in PostHog, Mixpanel, etc.)
+* ```typescript
+* import { PostHogSubscriber } from 'autotel-subscribers/posthog';
+*
+* init({
+*   service: 'my-app',
+*   subscribers: [new PostHogSubscriber({ apiKey: '...' })]
+* })
+* ```
+*
+* @example Observe in Jaeger
+* ```typescript
+* import { JaegerExporter } from '@opentelemetry/exporter-jaeger'
+*
+* init({
+*   service: 'my-app',
+*   spanExporter: new JaegerExporter({ endpoint: 'http://localhost:14268/api/traces' })
+* })
+* ```
+*
+* @example Observe in Zipkin
+* ```typescript
+* import { ZipkinExporter } from '@opentelemetry/exporter-zipkin'
+*
+* init({
+*   service: 'my-app',
+*   spanExporter: new ZipkinExporter({ url: 'http://localhost:9411/api/v2/spans' })
+* })
+* ```
+*
+* @example Observe in Datadog
+* ```typescript
+* import { DatadogSpanProcessor } from '@opentelemetry/exporter-datadog'
+*
+* init({
+*   service: 'my-app',
+*   spanProcessor: new DatadogSpanProcessor({ ... })
+* })
+* ```
+*
+* @example Console output (dev)
+* ```typescript
+* import { ConsoleSpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
+*
+* init({
+*   service: 'my-app',
+*   spanProcessor: new SimpleSpanProcessor(new ConsoleSpanExporter())
+* })
+* ```
+*/
+function init(cfg) {
+	if (locked) return;
+	const envConfig = resolveConfigFromEnv();
+	const yamlConfig = loadYamlConfig() ?? {};
+	const mergedConfig = {
+		...envConfig,
+		...yamlConfig,
+		...cfg,
+		resourceAttributes: {
+			...envConfig.resourceAttributes,
+			...yamlConfig.resourceAttributes,
+			...detectEnvironmentAttributes(),
+			...cfg.resourceAttributes
+		},
+		headers: cfg.headers ?? yamlConfig.headers ?? envConfig.headers
+	};
+	const resolvedRedactor = resolveAttributeRedactor(mergedConfig.attributeRedactor, mergedConfig.environment || process.env.NODE_ENV || "development");
+	if (resolvedRedactor === void 0) mergedConfig.attributeRedactor = void 0;
+	else {
+		const normalizedRedactor = normalizeAttributeRedactorConfig(resolvedRedactor);
+		if (!normalizedRedactor) throw new Error("Invalid attributeRedactor config");
+		mergedConfig.attributeRedactor = normalizedRedactor;
+	}
+	const devtoolsConfig = resolveDevtoolsConfig(mergedConfig.devtools);
+	if (devtoolsConfig.enabled && mergedConfig.logs === void 0) mergedConfig.logs = true;
+	const silent = mergedConfig.silent ?? false;
+	const minLevel = mergedConfig.minLevel ?? "info";
+	logger = wrapLogger(mergedConfig.logger || silentLogger, silent, minLevel);
+	if (initialized) logger.warn({}, "[autotel] init() called again - last config wins. This may cause unexpected behavior.");
+	config = mergedConfig;
+	validationConfig = mergedConfig.validation || null;
+	eventsConfig = mergedConfig.events || null;
+	let endpoint = mergedConfig.endpoint ?? devtoolsConfig.endpoint;
+	const version = mergedConfig.version || detectVersion();
+	const environment = mergedConfig.environment || process.env.NODE_ENV || "development";
+	const metricsEnabled = resolveMetricsFlag(mergedConfig.metrics);
+	const logsEnabled = resolveLogsFlag(mergedConfig.logs);
+	if (devtoolsConfig.enabled && devtoolsConfig.embedded) {
+		const devtoolsModule = _optionalRequire("autotel-devtools");
+		if (devtoolsModule?.createDevtools) {
+			const devtoolsInstance = devtoolsModule.createDevtools({
+				port: devtoolsConfig.port,
+				host: devtoolsConfig.host,
+				verbose: devtoolsConfig.verbose
+			});
+			_devtoolsClose = devtoolsInstance.close;
+			endpoint = `http://${devtoolsConfig.host}:${devtoolsInstance.port}`;
+			logger.info({}, `[autotel] autotel-devtools embedded server started at ${endpoint}`);
+		} else logger.warn({}, "[autotel] devtools.embedded requested but autotel-devtools is not installed. Falling back to endpoint-only mode.");
+	}
+	const hostname = detectHostname();
+	let resource = resourceFromAttributes({
+		[ATTR_SERVICE_NAME]: mergedConfig.service,
+		[ATTR_SERVICE_VERSION]: version,
+		"deployment.environment": environment,
+		"deployment.environment.name": environment
+	});
+	if (hostname) resource = resource.merge(resourceFromAttributes({
+		"host.name": hostname,
+		"datadog.host.name": hostname
+	}));
+	if (mergedConfig.resource) resource = resource.merge(mergedConfig.resource);
+	if (mergedConfig.resourceAttributes) resource = resource.merge(resourceFromAttributes(mergedConfig.resourceAttributes));
+	const otlpDestinations = resolveOtlpDestinations(mergedConfig, endpoint);
+	const configuredSpanProcessors = mergedConfig.spanProcessors && mergedConfig.spanProcessors.length > 0 ? mergedConfig.spanProcessors : mergedConfig.spanProcessor ? [mergedConfig.spanProcessor] : void 0;
+	const configuredSpanExporters = mergedConfig.spanExporters && mergedConfig.spanExporters.length > 0 ? mergedConfig.spanExporters : mergedConfig.spanExporter ? [mergedConfig.spanExporter] : void 0;
+	const configuredMetricReaders = mergedConfig.metricReaders && mergedConfig.metricReaders.length > 0 ? mergedConfig.metricReaders : mergedConfig.metricReader ? [mergedConfig.metricReader] : void 0;
+	const configuredLogRecordProcessors = mergedConfig.logRecordProcessors && mergedConfig.logRecordProcessors.length > 0 ? mergedConfig.logRecordProcessors : mergedConfig.logRecordProcessor ? [mergedConfig.logRecordProcessor] : void 0;
+	let spanProcessors = [];
+	if (configuredSpanProcessors && configuredSpanProcessors.length > 0) spanProcessors.push(...configuredSpanProcessors);
+	else if (configuredSpanExporters && configuredSpanExporters.length > 0) for (const exporter of configuredSpanExporters) spanProcessors.push(new TailSamplingSpanProcessor(new BatchSpanProcessor(exporter)));
+	else for (const destination of otlpDestinations) {
+		if (!destinationSupportsSignal(destination, "traces")) continue;
+		const traceExporter = createTraceExporter(destination.protocol, {
+			url: formatEndpointUrl(destination.endpoint, "traces", destination.protocol),
+			headers: destination.headers
+		});
+		spanProcessors.push(new TailSamplingSpanProcessor(new BatchSpanProcessor(traceExporter)));
+	}
+	if (mergedConfig.baggage) {
+		const prefix = typeof mergedConfig.baggage === "string" ? mergedConfig.baggage ? `${mergedConfig.baggage}.` : "" : "baggage.";
+		spanProcessors.push(new BaggageSpanProcessor({ prefix }));
+	}
+	const debugMode = resolveDebugFlag(mergedConfig.debug);
+	if (debugMode === "pretty") spanProcessors.push(new SimpleSpanProcessor(new PrettyConsoleExporter()));
+	else if (debugMode === true) spanProcessors.push(new SimpleSpanProcessor(new ConsoleSpanExporter()));
+	if (mergedConfig.canonicalLogLines?.enabled) {
+		const canonicalOptions = {
+			logger: mergedConfig.canonicalLogLines.logger || mergedConfig.logger,
+			rootSpansOnly: mergedConfig.canonicalLogLines.rootSpansOnly,
+			minLevel: mergedConfig.canonicalLogLines.minLevel,
+			messageFormat: mergedConfig.canonicalLogLines.messageFormat,
+			includeResourceAttributes: mergedConfig.canonicalLogLines.includeResourceAttributes,
+			shouldEmit: mergedConfig.canonicalLogLines.shouldEmit,
+			keep: mergedConfig.canonicalLogLines.keep,
+			drain: mergedConfig.canonicalLogLines.drain,
+			onDrainError: mergedConfig.canonicalLogLines.onDrainError,
+			pretty: mergedConfig.canonicalLogLines.pretty
+		};
+		spanProcessors.push(new CanonicalLogLineProcessor(canonicalOptions));
+	}
+	if (mergedConfig.attributeRedactor && spanProcessors.length > 0) {
+		const redactor = mergedConfig.attributeRedactor;
+		spanProcessors = spanProcessors.map((processor) => new AttributeRedactingProcessor(processor, { redactor }));
+	}
+	if (mergedConfig.attributeRedactor) _stringRedactor = createStringRedactor(mergedConfig.attributeRedactor);
+	if (_stringRedactor && mergedConfig.subscribers) {
+		for (const subscriber of mergedConfig.subscribers) if (acceptsStringRedactor(subscriber)) subscriber.setStringRedactor(_stringRedactor);
+	}
+	if (mergedConfig.spanNameNormalizer && spanProcessors.length > 0) spanProcessors = spanProcessors.map((processor) => new SpanNameNormalizingProcessor(processor, { normalizer: mergedConfig.spanNameNormalizer }));
+	if (mergedConfig.spanFilter && spanProcessors.length > 0) spanProcessors = spanProcessors.map((processor) => new FilteringSpanProcessor(processor, { filter: mergedConfig.spanFilter }));
+	const metricReaders = [];
+	if (configuredMetricReaders && configuredMetricReaders.length > 0) metricReaders.push(...configuredMetricReaders);
+	else if (metricsEnabled) for (const destination of otlpDestinations) {
+		if (!destinationSupportsSignal(destination, "metrics")) continue;
+		const metricExporter = createMetricExporter(destination.protocol, {
+			url: formatEndpointUrl(destination.endpoint, "metrics", destination.protocol),
+			headers: destination.headers
+		});
+		metricReaders.push(new PeriodicExportingMetricReader({ exporter: metricExporter }));
+	}
+	let logRecordProcessors;
+	if (configuredLogRecordProcessors && configuredLogRecordProcessors.length > 0) logRecordProcessors = [...configuredLogRecordProcessors];
+	if (logsEnabled) {
+		for (const destination of otlpDestinations) {
+			if (!destinationSupportsSignal(destination, "logs")) continue;
+			let processor = new BatchLogRecordProcessor({ exporter: createLogExporter(destination.protocol, {
+				url: formatEndpointUrl(destination.endpoint, "logs", destination.protocol),
+				headers: destination.headers
+			}) });
+			if (_stringRedactor) processor = new RedactingLogRecordProcessor(processor, _stringRedactor);
+			if (!logRecordProcessors) logRecordProcessors = [];
+			logRecordProcessors.push(processor);
+		}
+		if (otlpDestinations.some((destination) => destinationSupportsSignal(destination, "logs"))) logger.info({}, "[autotel] OTLP log exporter configured");
+	}
+	const posthogProcessors = buildPostHogLogProcessors(mergedConfig.posthog, _stringRedactor);
+	if (posthogProcessors.length > 0) {
+		if (!logRecordProcessors) logRecordProcessors = [];
+		logRecordProcessors.push(...posthogProcessors);
+		logger.info({}, "[autotel] PostHog OTLP logs configured");
+	}
+	let finalInstrumentations = mergedConfig.instrumentations ? [...mergedConfig.instrumentations] : [];
+	if (mergedConfig.autoInstrumentations !== void 0 && mergedConfig.autoInstrumentations !== false) {
+		if (isESMMode()) logger.info({}, "[autotel] ESM mode detected. For auto-instrumentation to work:\n  1. Install @opentelemetry/auto-instrumentations-node as a direct dependency\n  2. Import autotel/register FIRST in your instrumentation file\n  3. Use getNodeAutoInstrumentations() directly instead of autoInstrumentations\n  See: https://github.com/jagreehal/autotel#esm-setup");
+		try {
+			const manualInstrumentationNames = getInstrumentationNames(mergedConfig.instrumentations ?? []);
+			if (manualInstrumentationNames.size > 0) {
+				const manualNames = [...manualInstrumentationNames].join(", ");
+				logger.info({}, `[autotel] Detected manual instrumentations (${manualNames}). These will take precedence over auto-instrumentations. Tip: Set autoInstrumentations:false if you want full manual control, or remove manual configs to use auto-instrumentations.`);
+			}
+			const autoInstrumentations = getAutoInstrumentations(mergedConfig.autoInstrumentations, manualInstrumentationNames);
+			if (autoInstrumentations && autoInstrumentations.length > 0) finalInstrumentations = [...finalInstrumentations, ...autoInstrumentations];
+		} catch (error) {
+			logger.warn({}, `[autotel] Failed to configure auto-instrumentations: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	const autotelSampler = mergedConfig.sampler ?? (mergedConfig.sampling ? resolveSamplingPreset(mergedConfig.sampling) : void 0);
+	if (autotelSampler) mergedConfig.sampler = autotelSampler;
+	const sampler = autotelSampler ? toOtelSampler(autotelSampler) : envConfig.otelSampler ?? toOtelSampler(samplingPresets.production());
+	const sdkOptions = {
+		resource,
+		serviceName: mergedConfig.service,
+		sampler,
+		instrumentations: finalInstrumentations
+	};
+	if (spanProcessors.length > 0) sdkOptions.spanProcessors = spanProcessors;
+	if (metricReaders.length > 0) sdkOptions.metricReaders = metricReaders;
+	if (logRecordProcessors && logRecordProcessors.length > 0) sdkOptions.logRecordProcessors = logRecordProcessors;
+	sdk = mergedConfig.sdkFactory ? mergedConfig.sdkFactory(sdkOptions) : new NodeSDK(sdkOptions);
+	if (!sdk) throw new Error("[autotel] sdkFactory must return a NodeSDK instance");
+	sdk.start();
+	if (mergedConfig.openllmetry?.enabled) {
+		const traceloop = _optionalRequire("@traceloop/node-server-sdk");
+		if (traceloop) {
+			const initOptions = { ...mergedConfig.openllmetry.options };
+			try {
+				initOptions.tracerProvider = sdk.getTracerProvider();
+			} catch {}
+			if (configuredSpanExporters?.[0]) initOptions.exporter = configuredSpanExporters[0];
+			if (typeof traceloop.initialize === "function") {
+				traceloop.initialize(initOptions);
+				logger.info({}, "[autotel] OpenLLMetry initialized successfully");
+			} else logger.warn({}, "[autotel] OpenLLMetry initialize function not found. Check @traceloop/node-server-sdk version.");
+		} else logger.warn({}, "[autotel] OpenLLMetry enabled but @traceloop/node-server-sdk is not installed. Install it as a peer dependency to use OpenLLMetry integration.");
+	}
+	initialized = true;
+	const processHandlers = mergedConfig.processHandlers;
+	if (processHandlers) installProcessHandlers(processHandlers === true ? {} : processHandlers, shutdown);
+	else uninstallProcessHandlers();
+}
+/**
+* Extract instrumentation class names from instrumentation instances
+* Used to detect duplicates between manual and auto instrumentations
+*/
+function getInstrumentationNames(instrumentations) {
+	const names = /* @__PURE__ */ new Set();
+	if (!instrumentations) return names;
+	for (const instrumentation of instrumentations) if (instrumentation && typeof instrumentation === "object") names.add(instrumentation.constructor.name);
+	return names;
+}
+/**
+* Map common instrumentation class names to their package names
+* Used to disable auto-instrumentations when user provides manual configs
+*/
+const INSTRUMENTATION_CLASS_TO_PACKAGE = {
+	HttpInstrumentation: "@opentelemetry/instrumentation-http",
+	HttpsInstrumentation: "@opentelemetry/instrumentation-http",
+	ExpressInstrumentation: "@opentelemetry/instrumentation-express",
+	FastifyInstrumentation: "@opentelemetry/instrumentation-fastify",
+	MongoDBInstrumentation: "@opentelemetry/instrumentation-mongodb",
+	MongooseInstrumentation: "@opentelemetry/instrumentation-mongoose",
+	PrismaInstrumentation: "@opentelemetry/instrumentation-prisma",
+	PinoInstrumentation: "@opentelemetry/instrumentation-pino",
+	WinstonInstrumentation: "@opentelemetry/instrumentation-winston",
+	RedisInstrumentation: "@opentelemetry/instrumentation-redis",
+	GraphQLInstrumentation: "@opentelemetry/instrumentation-graphql",
+	GrpcInstrumentation: "@opentelemetry/instrumentation-grpc",
+	IORedisInstrumentation: "@opentelemetry/instrumentation-ioredis",
+	KnexInstrumentation: "@opentelemetry/instrumentation-knex",
+	NestJsInstrumentation: "@opentelemetry/instrumentation-nestjs-core",
+	PgInstrumentation: "@opentelemetry/instrumentation-pg",
+	MySQLInstrumentation: "@opentelemetry/instrumentation-mysql",
+	MySQL2Instrumentation: "@opentelemetry/instrumentation-mysql2"
+};
+/**
+* Detect if we're running in ESM mode
+*/
+function isESMMode() {
+	try {
+		const fs = requireModule("node:fs");
+		try {
+			return JSON.parse(fs.readFileSync(`${process.cwd()}/package.json`, "utf8")).type === "module";
+		} catch {
+			return false;
+		}
+	} catch {
+		return false;
+	}
+}
+/**
+* Lazy-load auto-instrumentations (optional peer dependency)
+* Only loads when integrations config is truthy, avoiding ~40+ package imports at startup.
+*/
+function loadNodeAutoInstrumentations() {
+	try {
+		return requireModule("@opentelemetry/auto-instrumentations-node").getNodeAutoInstrumentations;
+	} catch {
+		const isESM = isESMMode();
+		const baseMessage = "@opentelemetry/auto-instrumentations-node not found.";
+		if (isESM) throw new Error(`${baseMessage}\n\nESM Setup Required:
+1. Install as a direct dependency: pnpm add @opentelemetry/auto-instrumentations-node
+2. Create instrumentation.mjs with:
+   import 'autotel/register';  // MUST be first!
+   import { init } from 'autotel';
+   import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+   init({ service: "my-app", instrumentations: getNodeAutoInstrumentations() });
+3. Run with: tsx --import ./instrumentation.mjs src/index.ts
+
+See: https://github.com/jagreehal/autotel#esm-setup`);
+		throw new Error(`${baseMessage} Install it: pnpm add @opentelemetry/auto-instrumentations-node`);
+	}
+}
+/**
+* Injectable loader for testing. Set to override the default loader.
+* @internal
+*/
+let _autoInstrumentationsLoader = null;
+/**
+* Get auto-instrumentations based on simple integration names
+* Excludes instrumentations that are manually provided to avoid conflicts
+*/
+function getAutoInstrumentations(integrations, manualInstrumentationNames = /* @__PURE__ */ new Set()) {
+	if (integrations === false) return [];
+	const getNodeAutoInstrumentations = _autoInstrumentationsLoader ? _autoInstrumentationsLoader() : loadNodeAutoInstrumentations();
+	const exclusionConfig = {};
+	for (const className of manualInstrumentationNames) {
+		const packageName = INSTRUMENTATION_CLASS_TO_PACKAGE[className];
+		if (packageName) exclusionConfig[packageName] = { enabled: false };
+	}
+	if (integrations === true) {
+		if (Object.keys(exclusionConfig).length > 0) return getNodeAutoInstrumentations(exclusionConfig);
+		return getNodeAutoInstrumentations();
+	}
+	if (Array.isArray(integrations)) {
+		const config = { ...exclusionConfig };
+		for (const name of integrations) {
+			const packageName = `@opentelemetry/instrumentation-${name}`;
+			if (!exclusionConfig[packageName]) config[packageName] = { enabled: true };
+		}
+		return getNodeAutoInstrumentations(config);
+	}
+	const config = {
+		...exclusionConfig,
+		...integrations
+	};
+	for (const packageName of Object.keys(exclusionConfig)) if (Object.keys(integrations).find((key) => packageName.includes(key))) config[packageName] = { enabled: false };
+	return getNodeAutoInstrumentations(config);
+}
+/**
+* Check if autotel has been initialized
+*/
+function isInitialized() {
+	return initialized;
+}
+/**
+* Get current config (internal use)
+*/
+function getConfig() {
+	return config;
+}
+/**
+* Get current logger (internal use)
+*/
+function getLogger() {
+	return logger;
+}
+/**
+* Get validation config (internal use)
+*/
+function getValidationConfig() {
+	return validationConfig;
+}
+/**
+* Get events config (internal use)
+*/
+function getEventsConfig() {
+	return eventsConfig;
+}
+/**
+* Warn once if not initialized (same behavior in all environments)
+*/
+function warnIfNotInitialized(context) {
+	if (!initialized && !warnedOnce) {
+		logger.warn({}, `[autotel] ${context} used before init() called. Call init({ service: "..." }) first. See: https://docs.autotel.dev/quickstart`);
+		warnedOnce = true;
+	}
+}
+/**
+* Auto-detect version from package.json
+*/
+function detectVersion() {
+	try {
+		const fs = requireModule("node:fs");
+		return JSON.parse(fs.readFileSync(`${process.cwd()}/package.json`, "utf8")).version || "1.0.0";
+	} catch {
+		return "1.0.0";
+	}
+}
+/**
+* Detect hostname for resource attributes.
+* Supports Datadog conventions (DD_HOSTNAME) and falls back to system hostname.
+*
+* Priority order:
+* 1. DD_HOSTNAME environment variable (Datadog convention)
+* 2. HOSTNAME environment variable (common Unix convention)
+* 3. os.hostname() (system hostname)
+*
+* @returns hostname string or undefined if detection fails
+*/
+function detectHostname() {
+	if (process.env.DD_HOSTNAME) return process.env.DD_HOSTNAME;
+	if (process.env.HOSTNAME) return process.env.HOSTNAME;
+	try {
+		return requireModule("node:os").hostname();
+	} catch {
+		return;
+	}
+}
+/**
+* @internal Close embedded devtools if running.
+*/
+async function _closeEmbeddedDevtools() {
+	if (_devtoolsClose) {
+		await _devtoolsClose();
+		_devtoolsClose = null;
+	}
+}
+/**
+* Get SDK instance (for shutdown)
+*/
+function getSdk() {
+	return sdk;
+}
+
+//#endregion
+export { BaggageSpanProcessor as A, setCorrelationId as C, getActiveContextWithBaggage as D, defineBaggageSchema as E, getContextStorage as O, runWithCorrelationId as S, createTraceContext as T, CORRELATION_ID_BAGGAGE_KEY as _, isInitialized as a, getCorrelationStorage as b, flush as c, getEvents as d, resetEvents as f, track as g, getEventQueue as h, init as i, createStringRedactor as k, shutdown as l, runInOperationContext as m, getLogger as n, isLoggerLocked as o, getOperationContext as p, getSdk as r, lockLogger as s, getConfig as t, Event as u, generateCorrelationId as v, setCorrelationIdInBaggage as w, getOrCreateCorrelationId as x, getCorrelationId as y };
+//# sourceMappingURL=init-R-gSEXkJ.js.map