iii-sdk 0.8.3 → 0.10.0

package/dist/utils-_zSeatp1.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-_zSeatp1.d.mts","names":[],"sources":["../src/iii-types.ts","../src/channels.ts","../src/iii-constants.ts","../src/telemetry-system/types.ts","../src/telemetry-system/context.ts","../src/telemetry-system/index.ts","../src/triggers.ts","../src/types.ts","../src/utils.ts"],"mappings":"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"}

package/dist/{utils-coGqiBHT.mjs → utils-xBUm8n1P.mjs}

@@ -1,5 +1,6 @@
-import { SpanKind, SpanKind as SpanKind$1, SpanStatusCode, SpanStatusCode as SpanStatusCode$1, context, metrics, propagation, trace } from "@opentelemetry/api";
 import { WebSocket } from "ws";
+import { SpanKind, SpanKind as SpanKind$1, SpanStatusCode, SpanStatusCode as SpanStatusCode$1, context, metrics, propagation, trace } from "@opentelemetry/api";
+import { monitorEventLoopDelay, performance } from "node:perf_hooks";
 import { Resource } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { randomUUID } from "node:crypto";
@@ -11,7 +12,6 @@ import { registerInstrumentations } from "@opentelemetry/instrumentation";
 import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
 import { SeverityNumber as SeverityNumber$1 } from "@opentelemetry/api-logs";
 import { JsonLogsSerializer, JsonMetricsSerializer, JsonTraceSerializer } from "@opentelemetry/otlp-transformer";
-import { monitorEventLoopDelay, performance } from "node:perf_hooks";
 
 //#region src/iii-constants.ts
 /**
@@ -21,6 +21,7 @@ import { monitorEventLoopDelay, performance } from "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 */
@@ -46,6 +47,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 = performance.now();
+		this.startEventLoopMonitoring(options.eventLoopResolutionMs ?? 20);
+	}
+	/**
+	* Starts the event loop delay histogram monitoring.
+	*
+	* @param resolutionMs - Histogram resolution in milliseconds
+	*/
+	startEventLoopMonitoring(resolutionMs) {
+		this.eventLoopHistogram = 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 = 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";
@@ -324,7 +532,7 @@ 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 {
@@ -367,8 +575,8 @@ 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);
@@ -564,7 +772,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;
@@ -597,7 +805,7 @@ 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, {
+		return tracer.startActiveSpan(spanName, {
 			kind: SpanKind.CLIENT,
 			attributes: spanAttributes
 		}, context.active(), async (span) => {
@@ -704,7 +912,7 @@ 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 ?? 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 = {
 		[ATTR_SERVICE_NAME]: serviceName,
 		[ATTR_SERVICE_VERSION]: serviceVersion,
@@ -848,213 +1056,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 = performance.now();
-		this.startEventLoopMonitoring(options.eventLoopResolutionMs ?? 20);
-	}
-	/**
-	* Starts the event loop delay histogram monitoring.
-	*
-	* @param resolutionMs - Histogram resolution in milliseconds
-	*/
-	startEventLoopMonitoring(resolutionMs) {
-		this.eventLoopHistogram = 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 = 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
 /**
@@ -1076,6 +1077,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;
@@ -1093,6 +1116,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;
@@ -1100,5 +1129,5 @@ const isChannelRef = (value) => {
 };
 
 //#endregion
-export { EngineTriggers as A, injectBaggage as C, DEFAULT_BRIDGE_RECONNECTION_CONFIG as D, setBaggageEntry as E, DEFAULT_INVOCATION_TIMEOUT_MS as O, getBaggageEntry as S, removeBaggageEntry as T, currentTraceId as _, stopWorkerGauges as a, extractTraceparent as b, SpanKind$1 as c, getMeter as d, getTracer as f, currentSpanId as g, withSpan as h, registerWorkerGauges as i, LogFunctions as j, EngineFunctions as k, SpanStatusCode$1 as l, shutdownOtel as m, isChannelRef as n, WorkerMetricsCollector as o, initOtel as p, safeStringify as r, SeverityNumber$1 as s, http as t, getLogger as u, extractBaggage as v, injectTraceparent as w, getAllBaggage as x, extractContext as y };
-//# sourceMappingURL=utils-coGqiBHT.mjs.map
+export { EngineTriggers as A, setBaggageEntry as C, DEFAULT_BRIDGE_RECONNECTION_CONFIG as D, WorkerMetricsCollector as E, DEFAULT_INVOCATION_TIMEOUT_MS as O, removeBaggageEntry as S, stopWorkerGauges as T, extractTraceparent as _, SpanKind$1 as a, injectBaggage as b, getMeter as c, shutdownOtel as d, withSpan as f, extractContext as g, extractBaggage as h, SeverityNumber$1 as i, LogFunctions as j, EngineFunctions as k, getTracer as l, currentTraceId as m, isChannelRef as n, SpanStatusCode$1 as o, currentSpanId as p, safeStringify as r, getLogger as s, http as t, initOtel as u, getAllBaggage as v, registerWorkerGauges as w, injectTraceparent as x, getBaggageEntry as y };
+//# sourceMappingURL=utils-xBUm8n1P.mjs.map