iii-sdk 0.9.0 → 0.10.0

package/dist/{utils-bsZVduQi.cjs → utils-C6yTT4Js.cjs}

@@ -1,18 +1,18 @@
 const require_index = require('./index.cjs');
 let ws = require("ws");
-let __opentelemetry_api = require("@opentelemetry/api");
+let _opentelemetry_api = require("@opentelemetry/api");
 let node_perf_hooks = require("node:perf_hooks");
-let __opentelemetry_resources = require("@opentelemetry/resources");
-let __opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
+let _opentelemetry_resources = require("@opentelemetry/resources");
+let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
 let node_crypto = require("node:crypto");
-let __opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
-let __opentelemetry_sdk_metrics = require("@opentelemetry/sdk-metrics");
-let __opentelemetry_core = require("@opentelemetry/core");
-let __opentelemetry_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
-let __opentelemetry_instrumentation = require("@opentelemetry/instrumentation");
-let __opentelemetry_sdk_logs = require("@opentelemetry/sdk-logs");
-let __opentelemetry_api_logs = require("@opentelemetry/api-logs");
-let __opentelemetry_otlp_transformer = require("@opentelemetry/otlp-transformer");
+let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+let _opentelemetry_sdk_metrics = require("@opentelemetry/sdk-metrics");
+let _opentelemetry_core = require("@opentelemetry/core");
+let _opentelemetry_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+let _opentelemetry_instrumentation = require("@opentelemetry/instrumentation");
+let _opentelemetry_sdk_logs = require("@opentelemetry/sdk-logs");
+let _opentelemetry_api_logs = require("@opentelemetry/api-logs");
+let _opentelemetry_otlp_transformer = require("@opentelemetry/otlp-transformer");
 
 //#region src/iii-constants.ts
 /**
@@ -160,7 +160,7 @@ let metricsCollector = null;
 let registeredMeter = null;
 let registeredBatchCallback = null;
 let registeredObservables = [];
-function registerWorkerGauges(meter$1, options) {
+function registerWorkerGauges(meter, options) {
 	if (registeredGauges) return;
 	const { workerId, workerName } = options;
 	const baseAttributes = {
@@ -168,56 +168,56 @@ function registerWorkerGauges(meter$1, options) {
 		...workerName && { "worker.name": workerName }
 	};
 	metricsCollector = new WorkerMetricsCollector();
-	const memoryHeapUsed = meter$1.createObservableGauge("iii.worker.memory.heap_used", {
+	const memoryHeapUsed = meter.createObservableGauge("iii.worker.memory.heap_used", {
 		description: "Worker heap memory used in bytes",
 		unit: "bytes"
 	});
-	const memoryHeapTotal = meter$1.createObservableGauge("iii.worker.memory.heap_total", {
+	const memoryHeapTotal = meter.createObservableGauge("iii.worker.memory.heap_total", {
 		description: "Worker total heap memory in bytes",
 		unit: "bytes"
 	});
-	const memoryRss = meter$1.createObservableGauge("iii.worker.memory.rss", {
+	const memoryRss = meter.createObservableGauge("iii.worker.memory.rss", {
 		description: "Worker resident set size in bytes",
 		unit: "bytes"
 	});
-	const memoryExternal = meter$1.createObservableGauge("iii.worker.memory.external", {
+	const memoryExternal = meter.createObservableGauge("iii.worker.memory.external", {
 		description: "Worker external memory in bytes",
 		unit: "bytes"
 	});
-	const cpuPercent = meter$1.createObservableGauge("iii.worker.cpu.percent", {
+	const cpuPercent = meter.createObservableGauge("iii.worker.cpu.percent", {
 		description: "Worker CPU usage percentage",
 		unit: "%"
 	});
-	const cpuUserMicros = meter$1.createObservableGauge("iii.worker.cpu.user_micros", {
+	const cpuUserMicros = meter.createObservableGauge("iii.worker.cpu.user_micros", {
 		description: "Worker CPU user time in microseconds",
 		unit: "us"
 	});
-	const cpuSystemMicros = meter$1.createObservableGauge("iii.worker.cpu.system_micros", {
+	const cpuSystemMicros = meter.createObservableGauge("iii.worker.cpu.system_micros", {
 		description: "Worker CPU system time in microseconds",
 		unit: "us"
 	});
-	const eventLoopLag = meter$1.createObservableGauge("iii.worker.event_loop.lag_ms", {
+	const eventLoopLag = meter.createObservableGauge("iii.worker.event_loop.lag_ms", {
 		description: "Worker event loop lag in milliseconds",
 		unit: "ms"
 	});
-	const uptimeSeconds = meter$1.createObservableGauge("iii.worker.uptime_seconds", {
+	const uptimeSeconds = meter.createObservableGauge("iii.worker.uptime_seconds", {
 		description: "Worker uptime in seconds",
 		unit: "s"
 	});
 	const batchCallback = (observableResult) => {
 		if (!metricsCollector) return;
-		const metrics$1 = metricsCollector.collect();
-		if (metrics$1.memory_heap_used !== void 0) observableResult.observe(memoryHeapUsed, metrics$1.memory_heap_used, baseAttributes);
-		if (metrics$1.memory_heap_total !== void 0) observableResult.observe(memoryHeapTotal, metrics$1.memory_heap_total, baseAttributes);
-		if (metrics$1.memory_rss !== void 0) observableResult.observe(memoryRss, metrics$1.memory_rss, baseAttributes);
-		if (metrics$1.memory_external !== void 0) observableResult.observe(memoryExternal, metrics$1.memory_external, baseAttributes);
-		if (metrics$1.cpu_percent !== void 0) observableResult.observe(cpuPercent, metrics$1.cpu_percent, baseAttributes);
-		if (metrics$1.cpu_user_micros !== void 0) observableResult.observe(cpuUserMicros, metrics$1.cpu_user_micros, baseAttributes);
-		if (metrics$1.cpu_system_micros !== void 0) observableResult.observe(cpuSystemMicros, metrics$1.cpu_system_micros, baseAttributes);
-		if (metrics$1.event_loop_lag_ms !== void 0) observableResult.observe(eventLoopLag, metrics$1.event_loop_lag_ms, baseAttributes);
-		if (metrics$1.uptime_seconds !== void 0) observableResult.observe(uptimeSeconds, metrics$1.uptime_seconds, baseAttributes);
+		const metrics = metricsCollector.collect();
+		if (metrics.memory_heap_used !== void 0) observableResult.observe(memoryHeapUsed, metrics.memory_heap_used, baseAttributes);
+		if (metrics.memory_heap_total !== void 0) observableResult.observe(memoryHeapTotal, metrics.memory_heap_total, baseAttributes);
+		if (metrics.memory_rss !== void 0) observableResult.observe(memoryRss, metrics.memory_rss, baseAttributes);
+		if (metrics.memory_external !== void 0) observableResult.observe(memoryExternal, metrics.memory_external, baseAttributes);
+		if (metrics.cpu_percent !== void 0) observableResult.observe(cpuPercent, metrics.cpu_percent, baseAttributes);
+		if (metrics.cpu_user_micros !== void 0) observableResult.observe(cpuUserMicros, metrics.cpu_user_micros, baseAttributes);
+		if (metrics.cpu_system_micros !== void 0) observableResult.observe(cpuSystemMicros, metrics.cpu_system_micros, baseAttributes);
+		if (metrics.event_loop_lag_ms !== void 0) observableResult.observe(eventLoopLag, metrics.event_loop_lag_ms, baseAttributes);
+		if (metrics.uptime_seconds !== void 0) observableResult.observe(uptimeSeconds, metrics.uptime_seconds, baseAttributes);
 	};
-	meter$1.addBatchObservableCallback(batchCallback, [
+	meter.addBatchObservableCallback(batchCallback, [
 		memoryHeapUsed,
 		memoryHeapTotal,
 		memoryRss,
@@ -228,7 +228,7 @@ function registerWorkerGauges(meter$1, options) {
 		eventLoopLag,
 		uptimeSeconds
 	]);
-	registeredMeter = meter$1;
+	registeredMeter = meter;
 	registeredBatchCallback = batchCallback;
 	registeredObservables = [
 		memoryHeapUsed,
@@ -461,24 +461,24 @@ var EngineSpanExporter = class EngineSpanExporter {
 	}
 	sendExport(spans, resultCallback) {
 		try {
-			const serialized = __opentelemetry_otlp_transformer.JsonTraceSerializer.serializeRequest(spans);
+			const serialized = _opentelemetry_otlp_transformer.JsonTraceSerializer.serializeRequest(spans);
 			if (!serialized) {
-				resultCallback?.({ code: __opentelemetry_core.ExportResultCode.SUCCESS });
+				resultCallback?.({ code: _opentelemetry_core.ExportResultCode.SUCCESS });
 				return;
 			}
 			this.connection.send(PREFIX_TRACES, serialized, (err) => {
 				if (err) {
 					console.error("[OTel] Failed to send spans:", err.message);
 					resultCallback?.({
-						code: __opentelemetry_core.ExportResultCode.FAILED,
+						code: _opentelemetry_core.ExportResultCode.FAILED,
 						error: err
 					});
-				} else resultCallback?.({ code: __opentelemetry_core.ExportResultCode.SUCCESS });
+				} else resultCallback?.({ code: _opentelemetry_core.ExportResultCode.SUCCESS });
 			});
 		} catch (err) {
 			console.error("[OTel] Error exporting spans:", err);
 			resultCallback?.({
-				code: __opentelemetry_core.ExportResultCode.FAILED,
+				code: _opentelemetry_core.ExportResultCode.FAILED,
 				error: err
 			});
 		}
@@ -487,7 +487,7 @@ var EngineSpanExporter = class EngineSpanExporter {
 		if (this.connection.getState() !== "connected") {
 			if (this.pendingExports.length >= EngineSpanExporter.MAX_PENDING_EXPORTS) {
 				this.pendingExports.shift()?.resultCallback?.({
-					code: __opentelemetry_core.ExportResultCode.FAILED,
+					code: _opentelemetry_core.ExportResultCode.FAILED,
 					error: /* @__PURE__ */ new Error("Queue overflow")
 				});
 				console.warn("[OTel] Spans export queue full, dropped oldest entry");
@@ -507,7 +507,7 @@ var EngineSpanExporter = class EngineSpanExporter {
 		const pending = this.pendingExports.splice(0, this.pendingExports.length);
 		const shutdownError = /* @__PURE__ */ new Error("Exporter shutdown before export completed");
 		for (const { resultCallback } of pending) resultCallback?.({
-			code: __opentelemetry_core.ExportResultCode.FAILED,
+			code: _opentelemetry_core.ExportResultCode.FAILED,
 			error: shutdownError
 		});
 	}
@@ -533,28 +533,28 @@ var EngineMetricsExporter = class EngineMetricsExporter {
 	}
 	flushPending() {
 		const pending = this.pendingExports.splice(0, this.pendingExports.length);
-		for (const { metrics: metrics$1, resultCallback } of pending) this.sendExport(metrics$1, resultCallback);
+		for (const { metrics, resultCallback } of pending) this.sendExport(metrics, resultCallback);
 	}
 	sendExport(metricsData, resultCallback) {
 		try {
-			const serialized = __opentelemetry_otlp_transformer.JsonMetricsSerializer.serializeRequest(metricsData);
+			const serialized = _opentelemetry_otlp_transformer.JsonMetricsSerializer.serializeRequest(metricsData);
 			if (!serialized) {
-				resultCallback?.({ code: __opentelemetry_core.ExportResultCode.SUCCESS });
+				resultCallback?.({ code: _opentelemetry_core.ExportResultCode.SUCCESS });
 				return;
 			}
 			this.connection.send(PREFIX_METRICS, serialized, (err) => {
 				if (err) {
 					console.error("[OTel] Failed to send metrics:", err.message);
 					resultCallback?.({
-						code: __opentelemetry_core.ExportResultCode.FAILED,
+						code: _opentelemetry_core.ExportResultCode.FAILED,
 						error: err
 					});
-				} else resultCallback?.({ code: __opentelemetry_core.ExportResultCode.SUCCESS });
+				} else resultCallback?.({ code: _opentelemetry_core.ExportResultCode.SUCCESS });
 			});
 		} catch (err) {
 			console.error("[OTel] Error exporting metrics:", err);
 			resultCallback?.({
-				code: __opentelemetry_core.ExportResultCode.FAILED,
+				code: _opentelemetry_core.ExportResultCode.FAILED,
 				error: err
 			});
 		}
@@ -563,7 +563,7 @@ var EngineMetricsExporter = class EngineMetricsExporter {
 		if (this.connection.getState() !== "connected") {
 			if (this.pendingExports.length >= EngineMetricsExporter.MAX_PENDING_EXPORTS) {
 				this.pendingExports.shift()?.resultCallback?.({
-					code: __opentelemetry_core.ExportResultCode.FAILED,
+					code: _opentelemetry_core.ExportResultCode.FAILED,
 					error: /* @__PURE__ */ new Error("Queue overflow")
 				});
 				console.warn("[OTel] Metrics export queue full, dropped oldest entry");
@@ -576,14 +576,14 @@ var EngineMetricsExporter = class EngineMetricsExporter {
 		}
 		this.sendExport(metricsData, resultCallback);
 	}
-	export(metrics$1, resultCallback) {
-		this.doExport(metrics$1, resultCallback);
+	export(metrics, resultCallback) {
+		this.doExport(metrics, resultCallback);
 	}
 	async shutdown() {
 		const pending = this.pendingExports.splice(0, this.pendingExports.length);
 		const shutdownError = /* @__PURE__ */ new Error("Exporter shutdown before export completed");
 		for (const { resultCallback } of pending) resultCallback?.({
-			code: __opentelemetry_core.ExportResultCode.FAILED,
+			code: _opentelemetry_core.ExportResultCode.FAILED,
 			error: shutdownError
 		});
 	}
@@ -617,24 +617,24 @@ var EngineLogExporter = class {
 			return;
 		}
 		try {
-			const serialized = __opentelemetry_otlp_transformer.JsonLogsSerializer.serializeRequest(logs);
+			const serialized = _opentelemetry_otlp_transformer.JsonLogsSerializer.serializeRequest(logs);
 			if (!serialized) {
-				resultCallback({ code: __opentelemetry_core.ExportResultCode.SUCCESS });
+				resultCallback({ code: _opentelemetry_core.ExportResultCode.SUCCESS });
 				return;
 			}
 			this.connection.send(PREFIX_LOGS, serialized, (err) => {
 				if (err) {
 					console.error("[OTel] Failed to send logs:", err.message);
 					resultCallback({
-						code: __opentelemetry_core.ExportResultCode.FAILED,
+						code: _opentelemetry_core.ExportResultCode.FAILED,
 						error: err
 					});
-				} else resultCallback({ code: __opentelemetry_core.ExportResultCode.SUCCESS });
+				} else resultCallback({ code: _opentelemetry_core.ExportResultCode.SUCCESS });
 			});
 		} catch (err) {
 			console.error("[OTel] Error exporting logs:", err);
 			resultCallback({
-				code: __opentelemetry_core.ExportResultCode.FAILED,
+				code: _opentelemetry_core.ExportResultCode.FAILED,
 				error: err
 			});
 		}
@@ -644,7 +644,7 @@ var EngineLogExporter = class {
 	}
 	async shutdown() {
 		for (const { callback } of this.pendingExports) callback({
-			code: __opentelemetry_core.ExportResultCode.FAILED,
+			code: _opentelemetry_core.ExportResultCode.FAILED,
 			error: /* @__PURE__ */ new Error("Exporter shutdown")
 		});
 		this.pendingExports = [];
@@ -660,7 +660,7 @@ var EngineLogExporter = class {
 * Extract the current trace ID from the active span context.
 */
 function currentTraceId() {
-	const span = __opentelemetry_api.trace.getActiveSpan();
+	const span = _opentelemetry_api.trace.getActiveSpan();
 	if (span) {
 		const spanContext = span.spanContext();
 		if (spanContext.traceId && spanContext.traceId !== "00000000000000000000000000000000") return spanContext.traceId;
@@ -670,7 +670,7 @@ function currentTraceId() {
 * Extract the current span ID from the active span context.
 */
 function currentSpanId() {
-	const span = __opentelemetry_api.trace.getActiveSpan();
+	const span = _opentelemetry_api.trace.getActiveSpan();
 	if (span) {
 		const spanContext = span.spanContext();
 		if (spanContext.spanId && spanContext.spanId !== "0000000000000000") return spanContext.spanId;
@@ -681,7 +681,7 @@ function currentSpanId() {
 */
 function injectTraceparent() {
 	const carrier = {};
-	__opentelemetry_api.propagation.inject(__opentelemetry_api.context.active(), carrier);
+	_opentelemetry_api.propagation.inject(_opentelemetry_api.context.active(), carrier);
 	return carrier.traceparent;
 }
 /**
@@ -689,14 +689,14 @@ function injectTraceparent() {
 */
 function extractTraceparent(traceparent) {
 	const carrier = { traceparent };
-	return __opentelemetry_api.propagation.extract(__opentelemetry_api.context.active(), carrier);
+	return _opentelemetry_api.propagation.extract(_opentelemetry_api.context.active(), carrier);
 }
 /**
 * Inject the current baggage into a W3C baggage header string.
 */
 function injectBaggage() {
 	const carrier = {};
-	__opentelemetry_api.propagation.inject(__opentelemetry_api.context.active(), carrier);
+	_opentelemetry_api.propagation.inject(_opentelemetry_api.context.active(), carrier);
 	return carrier.baggage;
 }
 /**
@@ -704,7 +704,7 @@ function injectBaggage() {
 */
 function extractBaggage(baggage) {
 	const carrier = { baggage };
-	return __opentelemetry_api.propagation.extract(__opentelemetry_api.context.active(), carrier);
+	return _opentelemetry_api.propagation.extract(_opentelemetry_api.context.active(), carrier);
 }
 /**
 * Extract both trace context and baggage from their respective headers.
@@ -713,36 +713,36 @@ function extractContext(traceparent, baggage) {
 	const carrier = {};
 	if (traceparent) carrier.traceparent = traceparent;
 	if (baggage) carrier.baggage = baggage;
-	return __opentelemetry_api.propagation.extract(__opentelemetry_api.context.active(), carrier);
+	return _opentelemetry_api.propagation.extract(_opentelemetry_api.context.active(), carrier);
 }
 /**
 * Get a baggage entry from the current context.
 */
 function getBaggageEntry(key) {
-	return __opentelemetry_api.propagation.getBaggage(__opentelemetry_api.context.active())?.getEntry(key)?.value;
+	return _opentelemetry_api.propagation.getBaggage(_opentelemetry_api.context.active())?.getEntry(key)?.value;
 }
 /**
 * Set a baggage entry in the current context.
 */
 function setBaggageEntry(key, value) {
-	let bag = __opentelemetry_api.propagation.getBaggage(__opentelemetry_api.context.active()) ?? __opentelemetry_api.propagation.createBaggage();
+	let bag = _opentelemetry_api.propagation.getBaggage(_opentelemetry_api.context.active()) ?? _opentelemetry_api.propagation.createBaggage();
 	bag = bag.setEntry(key, { value });
-	return __opentelemetry_api.propagation.setBaggage(__opentelemetry_api.context.active(), bag);
+	return _opentelemetry_api.propagation.setBaggage(_opentelemetry_api.context.active(), bag);
 }
 /**
 * Remove a baggage entry from the current context.
 */
 function removeBaggageEntry(key) {
-	const bag = __opentelemetry_api.propagation.getBaggage(__opentelemetry_api.context.active());
-	if (!bag) return __opentelemetry_api.context.active();
+	const bag = _opentelemetry_api.propagation.getBaggage(_opentelemetry_api.context.active());
+	if (!bag) return _opentelemetry_api.context.active();
 	const newBag = bag.removeEntry(key);
-	return __opentelemetry_api.propagation.setBaggage(__opentelemetry_api.context.active(), newBag);
+	return _opentelemetry_api.propagation.setBaggage(_opentelemetry_api.context.active(), newBag);
 }
 /**
 * Get all baggage entries from the current context.
 */
 function getAllBaggage() {
-	const bag = __opentelemetry_api.propagation.getBaggage(__opentelemetry_api.context.active());
+	const bag = _opentelemetry_api.propagation.getBaggage(_opentelemetry_api.context.active());
 	if (!bag) return {};
 	const entries = {};
 	for (const [key, entry] of bag.getAllEntries()) entries[key] = entry.value;
@@ -773,7 +773,7 @@ let originalFetch = null;
 /**
 * Patch globalThis.fetch to create OTel CLIENT spans for every HTTP request.
 */
-function patchGlobalFetch(tracer$1) {
+function patchGlobalFetch(tracer) {
 	if (originalFetch) return;
 	originalFetch = globalThis.fetch;
 	const capturedFetch = originalFetch;
@@ -806,13 +806,13 @@ function patchGlobalFetch(tracer$1) {
 		if (port) spanAttributes["server.port"] = port;
 		if (query) spanAttributes["url.query"] = query;
 		const spanName = path ? `${method} ${path}` : method;
-		return tracer$1.startActiveSpan(spanName, {
-			kind: __opentelemetry_api.SpanKind.CLIENT,
+		return tracer.startActiveSpan(spanName, {
+			kind: _opentelemetry_api.SpanKind.CLIENT,
 			attributes: spanAttributes
-		}, __opentelemetry_api.context.active(), async (span) => {
+		}, _opentelemetry_api.context.active(), async (span) => {
 			try {
 				const carrier = {};
-				__opentelemetry_api.propagation.inject(__opentelemetry_api.context.active(), carrier);
+				_opentelemetry_api.propagation.inject(_opentelemetry_api.context.active(), carrier);
 				const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
 				for (const [key, value] of Object.entries(carrier)) headers.set(key, value);
 				for (const name of SAFE_REQUEST_HEADERS) {
@@ -837,13 +837,13 @@ function patchGlobalFetch(tracer$1) {
 				}
 				if (response.status >= 400) {
 					span.setAttribute("error.type", String(response.status));
-					span.setStatus({ code: __opentelemetry_api.SpanStatusCode.ERROR });
-				} else span.setStatus({ code: __opentelemetry_api.SpanStatusCode.OK });
+					span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+				} else span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
 				return response;
 			} catch (error) {
 				span.setAttribute("error.type", error.name ?? "Error");
 				span.setStatus({
-					code: __opentelemetry_api.SpanStatusCode.ERROR,
+					code: _opentelemetry_api.SpanStatusCode.ERROR,
 					message: error.message
 				});
 				span.recordException(error);
@@ -915,38 +915,38 @@ function initOtel(config = {}) {
 	const serviceInstanceId = config.serviceInstanceId ?? process.env.SERVICE_INSTANCE_ID ?? (0, node_crypto.randomUUID)();
 	const engineWsUrl = config.engineWsUrl ?? process.env.III_URL ?? DEFAULT_OTEL_CONFIG.engineWsUrl;
 	const resourceAttributes = {
-		[__opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
+		[_opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
 		[ATTR_SERVICE_VERSION]: serviceVersion,
 		[ATTR_SERVICE_INSTANCE_ID]: serviceInstanceId
 	};
 	if (serviceNamespace) resourceAttributes[ATTR_SERVICE_NAMESPACE] = serviceNamespace;
-	const resource = new __opentelemetry_resources.Resource(resourceAttributes);
+	const resource = new _opentelemetry_resources.Resource(resourceAttributes);
 	sharedConnection = new SharedEngineConnection(engineWsUrl, config.reconnectionConfig);
-	tracerProvider = new __opentelemetry_sdk_trace_node.NodeTracerProvider({
+	tracerProvider = new _opentelemetry_sdk_trace_node.NodeTracerProvider({
 		resource,
-		spanProcessors: [new __opentelemetry_sdk_trace_base.BatchSpanProcessor(new EngineSpanExporter(sharedConnection))]
+		spanProcessors: [new _opentelemetry_sdk_trace_base.BatchSpanProcessor(new EngineSpanExporter(sharedConnection))]
 	});
-	__opentelemetry_api.propagation.setGlobalPropagator(new __opentelemetry_core.CompositePropagator({ propagators: [new __opentelemetry_core.W3CTraceContextPropagator(), new __opentelemetry_core.W3CBaggagePropagator()] }));
+	_opentelemetry_api.propagation.setGlobalPropagator(new _opentelemetry_core.CompositePropagator({ propagators: [new _opentelemetry_core.W3CTraceContextPropagator(), new _opentelemetry_core.W3CBaggagePropagator()] }));
 	tracerProvider.register();
-	tracer = __opentelemetry_api.trace.getTracer(serviceName);
+	tracer = _opentelemetry_api.trace.getTracer(serviceName);
 	console.debug(`[OTel] Traces initialized: engine=${engineWsUrl}, service=${serviceName}`);
 	if (config.metricsEnabled ?? parseBoolEnv(process.env.OTEL_METRICS_ENABLED, DEFAULT_OTEL_CONFIG.metricsEnabled)) {
 		const metricsExporter = new EngineMetricsExporter(sharedConnection);
 		const exportIntervalMs = config.metricsExportIntervalMs ?? DEFAULT_OTEL_CONFIG.metricsExportIntervalMs;
-		meterProvider = new __opentelemetry_sdk_metrics.MeterProvider({
+		meterProvider = new _opentelemetry_sdk_metrics.MeterProvider({
 			resource,
-			readers: [new __opentelemetry_sdk_metrics.PeriodicExportingMetricReader({
+			readers: [new _opentelemetry_sdk_metrics.PeriodicExportingMetricReader({
 				exporter: metricsExporter,
 				exportIntervalMillis: exportIntervalMs
 			})]
 		});
-		__opentelemetry_api.metrics.setGlobalMeterProvider(meterProvider);
+		_opentelemetry_api.metrics.setGlobalMeterProvider(meterProvider);
 		meter = meterProvider.getMeter(serviceName);
 		console.debug(`[OTel] Metrics initialized: interval=${exportIntervalMs}ms`);
 	}
 	const instrumentations = [...config.instrumentations ?? []];
 	if (instrumentations.length > 0) {
-		(0, __opentelemetry_instrumentation.registerInstrumentations)({
+		(0, _opentelemetry_instrumentation.registerInstrumentations)({
 			instrumentations,
 			tracerProvider,
 			meterProvider: meterProvider ?? void 0
@@ -960,8 +960,8 @@ function initOtel(config = {}) {
 	const logExporter = new EngineLogExporter(sharedConnection);
 	const logsScheduledDelayMillis = config.logsFlushIntervalMs ?? parseNumberEnv(process.env.OTEL_LOGS_FLUSH_INTERVAL_MS, 0) ?? DEFAULT_OTEL_CONFIG.logsFlushIntervalMs;
 	const logsMaxExportBatchSize = config.logsBatchSize ?? parseIntegerEnv(process.env.OTEL_LOGS_BATCH_SIZE, 1) ?? DEFAULT_OTEL_CONFIG.logsBatchSize;
-	loggerProvider = new __opentelemetry_sdk_logs.LoggerProvider({ resource });
-	loggerProvider.addLogRecordProcessor(new __opentelemetry_sdk_logs.BatchLogRecordProcessor(logExporter, {
+	loggerProvider = new _opentelemetry_sdk_logs.LoggerProvider({ resource });
+	loggerProvider.addLogRecordProcessor(new _opentelemetry_sdk_logs.BatchLogRecordProcessor(logExporter, {
 		scheduledDelayMillis: logsScheduledDelayMillis,
 		maxExportBatchSize: logsMaxExportBatchSize
 	}));
@@ -1038,15 +1038,15 @@ async function withSpan(name, options, fn) {
 		};
 		return fn(noopSpan);
 	}
-	const parentContext = options.traceparent ? extractTraceparent(options.traceparent) : __opentelemetry_api.context.active();
-	return tracer.startActiveSpan(name, { kind: options.kind ?? __opentelemetry_api.SpanKind.INTERNAL }, parentContext, async (span) => {
+	const parentContext = options.traceparent ? extractTraceparent(options.traceparent) : _opentelemetry_api.context.active();
+	return tracer.startActiveSpan(name, { kind: options.kind ?? _opentelemetry_api.SpanKind.INTERNAL }, parentContext, async (span) => {
 		try {
 			const result = await fn(span);
-			span.setStatus({ code: __opentelemetry_api.SpanStatusCode.OK });
+			span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
 			return result;
 		} catch (error) {
 			span.setStatus({
-				code: __opentelemetry_api.SpanStatusCode.ERROR,
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
 				message: error.message
 			});
 			span.recordException(error);
@@ -1298,4 +1298,4 @@ Object.defineProperty(exports, 'withSpan', {
     return withSpan;
   }
 });
-//# sourceMappingURL=utils-bsZVduQi.cjs.map
+//# sourceMappingURL=utils-C6yTT4Js.cjs.map