iii-sdk 0.8.3 → 0.10.0

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

@@ -1,18 +1,18 @@
 const require_index = require('./index.cjs');
-let __opentelemetry_api = require("@opentelemetry/api");
 let ws = require("ws");
-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_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 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");
 
 //#region src/iii-constants.ts
 /**
@@ -22,6 +22,7 @@ let node_perf_hooks = require("node:perf_hooks");
 const EngineFunctions = {
 	LIST_FUNCTIONS: "engine::functions::list",
 	LIST_WORKERS: "engine::workers::list",
+	LIST_TRIGGERS: "engine::triggers::list",
 	REGISTER_WORKER: "engine::workers::register"
 };
 /** Engine trigger types */
@@ -47,6 +48,213 @@ const DEFAULT_BRIDGE_RECONNECTION_CONFIG = {
 /** Default invocation timeout in milliseconds */
 const DEFAULT_INVOCATION_TIMEOUT_MS = 3e4;
 
+//#endregion
+//#region src/worker-metrics.ts
+/**
+* Worker metrics collection for the III Node SDK.
+*
+* Collects CPU, memory, and event loop metrics for worker health monitoring.
+* Uses the Node.js built-in `monitorEventLoopDelay` API for accurate
+* event loop lag measurements.
+*/
+/**
+* Collects worker resource metrics including CPU, memory, and event loop lag.
+*
+* Uses the Node.js `monitorEventLoopDelay` API for high-precision event loop
+* delay measurements instead of manual `setImmediate` timing.
+*
+* @example
+* ```typescript
+* const collector = new WorkerMetricsCollector()
+*
+* // Collect metrics periodically
+* setInterval(() => {
+*   const metrics = collector.collect()
+*   console.log('CPU:', metrics.cpu_percent, '%')
+*   console.log('Event Loop Lag:', metrics.event_loop_lag_ms, 'ms')
+* }, 5000)
+*
+* // Clean up when done
+* collector.stopMonitoring()
+* ```
+*/
+var WorkerMetricsCollector = class {
+	/**
+	* Creates a new WorkerMetricsCollector instance.
+	*
+	* @param options - Configuration options
+	*/
+	constructor(options = {}) {
+		this.eventLoopHistogram = null;
+		this.startTime = Date.now();
+		this.lastCpuUsage = process.cpuUsage();
+		this.lastCpuTime = node_perf_hooks.performance.now();
+		this.startEventLoopMonitoring(options.eventLoopResolutionMs ?? 20);
+	}
+	/**
+	* Starts the event loop delay histogram monitoring.
+	*
+	* @param resolutionMs - Histogram resolution in milliseconds
+	*/
+	startEventLoopMonitoring(resolutionMs) {
+		this.eventLoopHistogram = (0, node_perf_hooks.monitorEventLoopDelay)({ resolution: Number.isFinite(resolutionMs) && resolutionMs > 0 ? Math.max(1, Math.floor(resolutionMs)) : 20 });
+		this.eventLoopHistogram.enable();
+	}
+	/**
+	* Stops the event loop monitoring and releases resources.
+	* Should be called when the collector is no longer needed.
+	*/
+	stopMonitoring() {
+		if (this.eventLoopHistogram) {
+			this.eventLoopHistogram.disable();
+			this.eventLoopHistogram = null;
+		}
+	}
+	/**
+	* Collects current worker metrics.
+	*
+	* This method calculates CPU usage since the last collection,
+	* reads memory usage, and gets event loop delay statistics.
+	* The event loop histogram is reset after each collection for
+	* accurate per-interval measurements.
+	*
+	* @returns Current worker metrics snapshot
+	*/
+	collect() {
+		const memoryUsage = process.memoryUsage();
+		const cpuUsage = process.cpuUsage();
+		const now = node_perf_hooks.performance.now();
+		const cpuDelta = {
+			user: cpuUsage.user - this.lastCpuUsage.user,
+			system: cpuUsage.system - this.lastCpuUsage.system
+		};
+		const timeDelta = (now - this.lastCpuTime) * 1e3;
+		const cpuPercent = timeDelta > 0 ? (cpuDelta.user + cpuDelta.system) / timeDelta * 100 : 0;
+		this.lastCpuUsage = cpuUsage;
+		this.lastCpuTime = now;
+		let eventLoopLagMs = 0;
+		if (this.eventLoopHistogram) {
+			eventLoopLagMs = this.eventLoopHistogram.mean / 1e6;
+			this.eventLoopHistogram.reset();
+		}
+		return {
+			memory_heap_used: memoryUsage.heapUsed,
+			memory_heap_total: memoryUsage.heapTotal,
+			memory_rss: memoryUsage.rss,
+			memory_external: memoryUsage.external,
+			cpu_user_micros: cpuUsage.user,
+			cpu_system_micros: cpuUsage.system,
+			cpu_percent: Math.min(cpuPercent, 100),
+			event_loop_lag_ms: eventLoopLagMs,
+			uptime_seconds: Math.floor((Date.now() - this.startTime) / 1e3),
+			timestamp_ms: Date.now(),
+			runtime: "node"
+		};
+	}
+};
+
+//#endregion
+//#region src/otel-worker-gauges.ts
+let registeredGauges = false;
+let metricsCollector = null;
+let registeredMeter = null;
+let registeredBatchCallback = null;
+let registeredObservables = [];
+function registerWorkerGauges(meter, options) {
+	if (registeredGauges) return;
+	const { workerId, workerName } = options;
+	const baseAttributes = {
+		"worker.id": workerId,
+		...workerName && { "worker.name": workerName }
+	};
+	metricsCollector = new WorkerMetricsCollector();
+	const memoryHeapUsed = meter.createObservableGauge("iii.worker.memory.heap_used", {
+		description: "Worker heap memory used in bytes",
+		unit: "bytes"
+	});
+	const memoryHeapTotal = meter.createObservableGauge("iii.worker.memory.heap_total", {
+		description: "Worker total heap memory in bytes",
+		unit: "bytes"
+	});
+	const memoryRss = meter.createObservableGauge("iii.worker.memory.rss", {
+		description: "Worker resident set size in bytes",
+		unit: "bytes"
+	});
+	const memoryExternal = meter.createObservableGauge("iii.worker.memory.external", {
+		description: "Worker external memory in bytes",
+		unit: "bytes"
+	});
+	const cpuPercent = meter.createObservableGauge("iii.worker.cpu.percent", {
+		description: "Worker CPU usage percentage",
+		unit: "%"
+	});
+	const cpuUserMicros = meter.createObservableGauge("iii.worker.cpu.user_micros", {
+		description: "Worker CPU user time in microseconds",
+		unit: "us"
+	});
+	const cpuSystemMicros = meter.createObservableGauge("iii.worker.cpu.system_micros", {
+		description: "Worker CPU system time in microseconds",
+		unit: "us"
+	});
+	const eventLoopLag = meter.createObservableGauge("iii.worker.event_loop.lag_ms", {
+		description: "Worker event loop lag in milliseconds",
+		unit: "ms"
+	});
+	const uptimeSeconds = meter.createObservableGauge("iii.worker.uptime_seconds", {
+		description: "Worker uptime in seconds",
+		unit: "s"
+	});
+	const batchCallback = (observableResult) => {
+		if (!metricsCollector) return;
+		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.addBatchObservableCallback(batchCallback, [
+		memoryHeapUsed,
+		memoryHeapTotal,
+		memoryRss,
+		memoryExternal,
+		cpuPercent,
+		cpuUserMicros,
+		cpuSystemMicros,
+		eventLoopLag,
+		uptimeSeconds
+	]);
+	registeredMeter = meter;
+	registeredBatchCallback = batchCallback;
+	registeredObservables = [
+		memoryHeapUsed,
+		memoryHeapTotal,
+		memoryRss,
+		memoryExternal,
+		cpuPercent,
+		cpuUserMicros,
+		cpuSystemMicros,
+		eventLoopLag,
+		uptimeSeconds
+	];
+	registeredGauges = true;
+}
+function stopWorkerGauges() {
+	if (registeredMeter && registeredBatchCallback) registeredMeter.removeBatchObservableCallback(registeredBatchCallback, registeredObservables);
+	if (metricsCollector) {
+		metricsCollector.stopMonitoring();
+		metricsCollector = null;
+	}
+	registeredMeter = null;
+	registeredBatchCallback = null;
+	registeredObservables = [];
+	registeredGauges = false;
+}
+
 //#endregion
 //#region src/telemetry-system/types.ts
 const ATTR_SERVICE_VERSION = "service.version";
@@ -253,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
 			});
 		}
@@ -279,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");
@@ -299,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
 		});
 	}
@@ -325,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
 			});
 		}
@@ -355,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");
@@ -368,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
 		});
 	}
@@ -409,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
 			});
 		}
@@ -436,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 = [];
@@ -452,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;
@@ -462,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;
@@ -473,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;
 }
 /**
@@ -481,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;
 }
 /**
@@ -496,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.
@@ -505,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;
@@ -565,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;
@@ -598,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) {
@@ -629,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);
@@ -705,40 +913,40 @@ function initOtel(config = {}) {
 	const serviceVersion = config.serviceVersion ?? process.env.SERVICE_VERSION ?? DEFAULT_OTEL_CONFIG.serviceVersion;
 	const serviceNamespace = config.serviceNamespace ?? process.env.SERVICE_NAMESPACE;
 	const serviceInstanceId = config.serviceInstanceId ?? process.env.SERVICE_INSTANCE_ID ?? (0, node_crypto.randomUUID)();
-	const engineWsUrl = config.engineWsUrl ?? process.env.III_BRIDGE_URL ?? DEFAULT_OTEL_CONFIG.engineWsUrl;
+	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
@@ -752,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
 	}));
@@ -830,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);
@@ -849,213 +1057,6 @@ async function withSpan(name, options, fn) {
 	});
 }
 
-//#endregion
-//#region src/worker-metrics.ts
-/**
-* Worker metrics collection for the III Node SDK.
-*
-* Collects CPU, memory, and event loop metrics for worker health monitoring.
-* Uses the Node.js built-in `monitorEventLoopDelay` API for accurate
-* event loop lag measurements.
-*/
-/**
-* Collects worker resource metrics including CPU, memory, and event loop lag.
-*
-* Uses the Node.js `monitorEventLoopDelay` API for high-precision event loop
-* delay measurements instead of manual `setImmediate` timing.
-*
-* @example
-* ```typescript
-* const collector = new WorkerMetricsCollector()
-*
-* // Collect metrics periodically
-* setInterval(() => {
-*   const metrics = collector.collect()
-*   console.log('CPU:', metrics.cpu_percent, '%')
-*   console.log('Event Loop Lag:', metrics.event_loop_lag_ms, 'ms')
-* }, 5000)
-*
-* // Clean up when done
-* collector.stopMonitoring()
-* ```
-*/
-var WorkerMetricsCollector = class {
-	/**
-	* Creates a new WorkerMetricsCollector instance.
-	*
-	* @param options - Configuration options
-	*/
-	constructor(options = {}) {
-		this.eventLoopHistogram = null;
-		this.startTime = Date.now();
-		this.lastCpuUsage = process.cpuUsage();
-		this.lastCpuTime = node_perf_hooks.performance.now();
-		this.startEventLoopMonitoring(options.eventLoopResolutionMs ?? 20);
-	}
-	/**
-	* Starts the event loop delay histogram monitoring.
-	*
-	* @param resolutionMs - Histogram resolution in milliseconds
-	*/
-	startEventLoopMonitoring(resolutionMs) {
-		this.eventLoopHistogram = (0, node_perf_hooks.monitorEventLoopDelay)({ resolution: Number.isFinite(resolutionMs) && resolutionMs > 0 ? Math.max(1, Math.floor(resolutionMs)) : 20 });
-		this.eventLoopHistogram.enable();
-	}
-	/**
-	* Stops the event loop monitoring and releases resources.
-	* Should be called when the collector is no longer needed.
-	*/
-	stopMonitoring() {
-		if (this.eventLoopHistogram) {
-			this.eventLoopHistogram.disable();
-			this.eventLoopHistogram = null;
-		}
-	}
-	/**
-	* Collects current worker metrics.
-	*
-	* This method calculates CPU usage since the last collection,
-	* reads memory usage, and gets event loop delay statistics.
-	* The event loop histogram is reset after each collection for
-	* accurate per-interval measurements.
-	*
-	* @returns Current worker metrics snapshot
-	*/
-	collect() {
-		const memoryUsage = process.memoryUsage();
-		const cpuUsage = process.cpuUsage();
-		const now = node_perf_hooks.performance.now();
-		const cpuDelta = {
-			user: cpuUsage.user - this.lastCpuUsage.user,
-			system: cpuUsage.system - this.lastCpuUsage.system
-		};
-		const timeDelta = (now - this.lastCpuTime) * 1e3;
-		const cpuPercent = timeDelta > 0 ? (cpuDelta.user + cpuDelta.system) / timeDelta * 100 : 0;
-		this.lastCpuUsage = cpuUsage;
-		this.lastCpuTime = now;
-		let eventLoopLagMs = 0;
-		if (this.eventLoopHistogram) {
-			eventLoopLagMs = this.eventLoopHistogram.mean / 1e6;
-			this.eventLoopHistogram.reset();
-		}
-		return {
-			memory_heap_used: memoryUsage.heapUsed,
-			memory_heap_total: memoryUsage.heapTotal,
-			memory_rss: memoryUsage.rss,
-			memory_external: memoryUsage.external,
-			cpu_user_micros: cpuUsage.user,
-			cpu_system_micros: cpuUsage.system,
-			cpu_percent: Math.min(cpuPercent, 100),
-			event_loop_lag_ms: eventLoopLagMs,
-			uptime_seconds: Math.floor((Date.now() - this.startTime) / 1e3),
-			timestamp_ms: Date.now(),
-			runtime: "node"
-		};
-	}
-};
-
-//#endregion
-//#region src/otel-worker-gauges.ts
-let registeredGauges = false;
-let metricsCollector = null;
-let registeredMeter = null;
-let registeredBatchCallback = null;
-let registeredObservables = [];
-function registerWorkerGauges(meter$1, options) {
-	if (registeredGauges) return;
-	const { workerId, workerName } = options;
-	const baseAttributes = {
-		"worker.id": workerId,
-		...workerName && { "worker.name": workerName }
-	};
-	metricsCollector = new WorkerMetricsCollector();
-	const memoryHeapUsed = meter$1.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", {
-		description: "Worker total heap memory in bytes",
-		unit: "bytes"
-	});
-	const memoryRss = meter$1.createObservableGauge("iii.worker.memory.rss", {
-		description: "Worker resident set size in bytes",
-		unit: "bytes"
-	});
-	const memoryExternal = meter$1.createObservableGauge("iii.worker.memory.external", {
-		description: "Worker external memory in bytes",
-		unit: "bytes"
-	});
-	const cpuPercent = meter$1.createObservableGauge("iii.worker.cpu.percent", {
-		description: "Worker CPU usage percentage",
-		unit: "%"
-	});
-	const cpuUserMicros = meter$1.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", {
-		description: "Worker CPU system time in microseconds",
-		unit: "us"
-	});
-	const eventLoopLag = meter$1.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", {
-		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);
-	};
-	meter$1.addBatchObservableCallback(batchCallback, [
-		memoryHeapUsed,
-		memoryHeapTotal,
-		memoryRss,
-		memoryExternal,
-		cpuPercent,
-		cpuUserMicros,
-		cpuSystemMicros,
-		eventLoopLag,
-		uptimeSeconds
-	]);
-	registeredMeter = meter$1;
-	registeredBatchCallback = batchCallback;
-	registeredObservables = [
-		memoryHeapUsed,
-		memoryHeapTotal,
-		memoryRss,
-		memoryExternal,
-		cpuPercent,
-		cpuUserMicros,
-		cpuSystemMicros,
-		eventLoopLag,
-		uptimeSeconds
-	];
-	registeredGauges = true;
-}
-function stopWorkerGauges() {
-	if (registeredMeter && registeredBatchCallback) registeredMeter.removeBatchObservableCallback(registeredBatchCallback, registeredObservables);
-	if (metricsCollector) {
-		metricsCollector.stopMonitoring();
-		metricsCollector = null;
-	}
-	registeredMeter = null;
-	registeredBatchCallback = null;
-	registeredObservables = [];
-	registeredGauges = false;
-}
-
 //#endregion
 //#region src/utils.ts
 /**
@@ -1077,6 +1078,28 @@ function safeStringify(value) {
 		return "[unserializable]";
 	}
 }
+/**
+* Helper that wraps an HTTP-style handler (with separate `req`/`res` arguments)
+* into the function handler format expected by the SDK.
+*
+* @param callback - Async handler receiving an {@link HttpRequest} and {@link HttpResponse}.
+* @returns A function handler compatible with {@link ISdk.registerFunction}.
+*
+* @example
+* ```typescript
+* import { http } from 'iii-sdk'
+*
+* iii.registerFunction(
+*   { id: 'my-api' },
+*   http(async (req, res) => {
+*     res.status(200)
+*     res.headers({ 'content-type': 'application/json' })
+*     res.stream.end(JSON.stringify({ hello: 'world' }))
+*     res.close()
+*   }),
+* )
+* ```
+*/
 const http = (callback) => {
 	return async (req) => {
 		const { response, ...request } = req;
@@ -1094,6 +1117,12 @@ const http = (callback) => {
 		});
 	};
 };
+/**
+* Type guard that checks if a value is a {@link StreamChannelRef}.
+*
+* @param value - Value to check.
+* @returns `true` if the value is a valid `StreamChannelRef`.
+*/
 const isChannelRef = (value) => {
 	if (typeof value !== "object" || value === null) return false;
 	const maybe = value;
@@ -1269,4 +1298,4 @@ Object.defineProperty(exports, 'withSpan', {
     return withSpan;
   }
 });
-//# sourceMappingURL=utils-BJTjoUdq.cjs.map
+//# sourceMappingURL=utils-C6yTT4Js.cjs.map