iii-sdk 0.12.0-next.1 → 0.13.0-next.1

package/LICENSE.spdx

@@ -1,19 +1,22 @@
-SPDXVersion: SPDX-2.1
+SPDXVersion: SPDX-2.3
 DataLicense: CC0-1.0
+SPDXID: SPDXRef-DOCUMENT
+DocumentName: iii
+DocumentNamespace: https://iii.dev/spdx/iii
 PackageName: iii
-DataFormat: SPDXRef-1
+SPDXID: SPDXRef-Package
 PackageSupplier: Organization: Motia LLC
 PackageHomePage: https://iii.dev
-PackageLicenseDeclared: Elastic-2.0
-PackageLicenseDeclared: Apache-2.0
+PackageLicenseDeclared: Apache-2.0 AND Elastic-2.0
+PackageLicenseConcluded: Apache-2.0 AND Elastic-2.0
 PackageCopyrightText: 2024-present, Motia LLC
-PackageSummary: <text>iii is a single engine with three primitives (Function, Trigger, Discovery)
-that replaces API frameworks, task queues, cron schedulers, pub/sub, state stores,
-and observability pipelines.
+PackageSummary: <text>iii turns distributed backend complexity into a
+simple set of real-time, interoperable primitives called Workers,
+Triggers, and Functions. The result is coordinated execution
+that behaves as if it were a single runtime.
                 </text>
-PackageComment: <text>The engine runtime (engine/) is licensed under Elastic License 2.0.
-All other components (sdk/, cli/, console/, frameworks/, docs/, website/)
-are licensed under Apache License 2.0.
+PackageComment: <text>Inbound contributions from external
+contributors are accepted under Apache-2.0 only; see CONTRIBUTING.md.
                 </text>
 Created: 2024-01-01T00:00:00Z
 PackageDownloadLocation: git://github.com/iii-hq/iii

package/README.md

@@ -8,7 +8,8 @@ Node.js / TypeScript SDK for the [iii engine](https://github.com/iii-hq/iii).
 ## Install
 
 ```bash
-npm install iii-sdk
+pnpm add iii-sdk
+# or: npm install iii-sdk
 ```
 
 ## Hello World
@@ -18,33 +19,34 @@ import { registerWorker } from 'iii-sdk'
 
 const iii = registerWorker('ws://localhost:49134')
 
-iii.registerFunction('greet', async (input) => {
+iii.registerFunction('hello::greet', async (input) => {
   return { message: `Hello, ${input.name}!` }
 })
 
 iii.registerTrigger({
   type: 'http',
-  function_id: 'greet',
+  function_id: 'hello::greet',
   config: { api_path: '/greet', http_method: 'POST' },
 })
 
-const result = await iii.trigger({ function_id: 'greet', payload: { name: 'world' } })
+const result = await iii.trigger({ function_id: 'hello::greet', payload: { name: 'world' } })
 ```
 
 ## API
 
-| Operation                | Signature                                            | Description                                                  |
-| ------------------------ | ---------------------------------------------------- | ------------------------------------------------------------ |
-| Initialize               | `registerWorker(url, options?)`                      | Create and connect to the engine. Returns an `ISdk` instance |
-| Register function        | `iii.registerFunction(id, handler, options?)`        | Register a function that can be invoked by name              |
-| Register trigger         | `iii.registerTrigger({ type, function_id, config })` | Bind a trigger (HTTP, cron, queue, etc.) to a function       |
-| Invoke (await)           | `await iii.trigger({ function_id, payload })`       | Invoke a function and wait for the result                    |
-| Invoke (fire-and-forget) | `iii.trigger({ function_id, payload, action: TriggerAction.Void() })` | Invoke without waiting |
+| Operation                | Signature                                                                         | Description                                                  |
+| ------------------------ | --------------------------------------------------------------------------------- | ------------------------------------------------------------ |
+| Initialize               | `registerWorker(url, options?)`                                                   | Create and connect to the engine. Returns an `ISdk` instance |
+| Register function        | `iii.registerFunction(id, handler, options?)`                                     | Register a function that can be invoked by name              |
+| Register trigger         | `iii.registerTrigger({ type, function_id, config })`                              | Bind a trigger (HTTP, cron, queue, etc.) to a function       |
+| Invoke (await)           | `await iii.trigger({ function_id, payload })`                                     | Invoke a function and wait for the result                    |
+| Invoke (fire-and-forget) | `iii.trigger({ function_id, payload, action: TriggerAction.Void() })`             | Invoke without waiting                                       |
+| Invoke (enqueue)         | `iii.trigger({ function_id, payload, action: TriggerAction.Enqueue({ queue }) })` | Route invocation through a named queue                       |
 
 ### Registering Functions
 
 ```javascript
-iii.registerFunction('orders.create', async (input) => {
+iii.registerFunction('orders::create', async (input) => {
   return { status_code: 201, body: { id: '123', item: input.body.item } }
 })
 ```
@@ -54,7 +56,7 @@ iii.registerFunction('orders.create', async (input) => {
 ```javascript
 iii.registerTrigger({
   type: 'http',
-  function_id: 'orders.create',
+  function_id: 'orders::create',
   config: { api_path: '/orders', http_method: 'POST' },
 })
 ```
@@ -66,24 +68,11 @@ import { registerWorker, TriggerAction } from 'iii-sdk'
 
 const iii = registerWorker('ws://localhost:49134')
 
-const result = await iii.trigger({ function_id: 'orders.create', payload: { item: 'widget' } })
+const result = await iii.trigger({ function_id: 'orders::create', payload: { item: 'widget' } })
 
-iii.trigger({ function_id: 'analytics.track', payload: { event: 'page_view' }, action: TriggerAction.Void() })
+iii.trigger({ function_id: 'analytics::track', payload: { event: 'page_view' }, action: TriggerAction.Void() })
 ```
 
-## Node Modules
-
-| Import              | What it provides                      |
-| ------------------- | ------------------------------------- |
-| `iii-sdk`           | Core SDK (`registerWorker`, types)    |
-| `iii-sdk/stream`    | Stream client for real-time state     |
-| `iii-sdk/state`     | State client for key-value operations |
-| `iii-sdk/telemetry` | OpenTelemetry integration             |
-
-## Removed methods
-
-`call`, `callVoid`, and `triggerVoid` have been removed. Use `trigger()` for all invocations. For fire-and-forget, use `trigger({ function_id, payload, action: TriggerAction.Void() })`.
-
 ## Resources
 
 - [Documentation](https://iii.dev/docs)

package/dist/index.cjs

@@ -1,38 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const require_utils = require('./utils-zW5CJdUp.cjs');
+const require_telemetry_system = require('./telemetry-system-BGZS9Vit.cjs');
 let node_stream = require("node:stream");
 let ws = require("ws");
 let _opentelemetry_api = require("@opentelemetry/api");
 let node_module = require("node:module");
 let node_os = require("node:os");
-node_os = __toESM(node_os);
+node_os = require_telemetry_system.__toESM(node_os);
 let _opentelemetry_api_logs = require("@opentelemetry/api-logs");
 
 //#region src/channels.ts
@@ -218,12 +191,34 @@ function buildChannelUrl(engineWsBase, channelId, accessKey, direction) {
 	return `${engineWsBase.replace(/\/$/, "")}/ws/channels/${channelId}?key=${encodeURIComponent(accessKey)}&dir=${direction}`;
 }
 
+//#endregion
+//#region src/errors.ts
+var IIIInvocationError = class extends Error {
+	constructor(init) {
+		super(`${init.code}: ${init.message}`);
+		this.name = "IIIInvocationError";
+		this.code = init.code;
+		this.function_id = init.function_id;
+		this.stacktrace = init.stacktrace;
+	}
+};
+/**
+* True when `value` looks like the wire `ErrorBody` the engine sends in
+* `InvocationResult.error`: `{ code: string, message: string, stacktrace?: string }`.
+* Used to distinguish an engine rejection (which we wrap in
+* {@link IIIInvocationError}) from a JS `Error` thrown elsewhere.
+*/
+function isErrorBody(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const v = value;
+	return typeof v.code === "string" && typeof v.message === "string" && (v.stacktrace === void 0 || typeof v.stacktrace === "string");
+}
+
 //#endregion
 //#region src/iii-types.ts
 let MessageType = /* @__PURE__ */ function(MessageType) {
 	MessageType["RegisterFunction"] = "registerfunction";
 	MessageType["UnregisterFunction"] = "unregisterfunction";
-	MessageType["RegisterService"] = "registerservice";
 	MessageType["InvokeFunction"] = "invokefunction";
 	MessageType["InvocationResult"] = "invocationresult";
 	MessageType["RegisterTriggerType"] = "registertriggertype";
@@ -249,11 +244,9 @@ var Sdk = class {
 		this.address = address;
 		this.options = options;
 		this.functions = /* @__PURE__ */ new Map();
-		this.services = /* @__PURE__ */ new Map();
 		this.invocations = /* @__PURE__ */ new Map();
 		this.triggers = /* @__PURE__ */ new Map();
 		this.triggerTypes = /* @__PURE__ */ new Map();
-		this.functionsAvailableCallbacks = /* @__PURE__ */ new Set();
 		this.messagesToSend = [];
 		this.reconnectAttempt = 0;
 		this.connectionState = "disconnected";
@@ -340,9 +333,42 @@ var Sdk = class {
 				this.functions.set(functionId, {
 					message: fullMessage,
 					handler: async (input, traceparent, baggage) => {
-						if (require_utils.getTracer()) {
-							const parentContext = require_utils.extractContext(traceparent, baggage);
-							return _opentelemetry_api.context.with(parentContext, () => require_utils.withSpan(`call ${functionId}`, { kind: _opentelemetry_api.SpanKind.SERVER }, async () => await handler(input)));
+						const tracePayloads = !(process.env.III_DISABLE_TRACE_PAYLOADS === "1" || process.env.III_DISABLE_TRACE_PAYLOADS?.toLowerCase() === "true");
+						const payloadMaxBytes = require_telemetry_system.resolveMaxBytesFromEnv();
+						const runHandler = async () => {
+							if (tracePayloads) {
+								const { json, truncated } = require_telemetry_system.redactAndTruncate(input, payloadMaxBytes);
+								require_telemetry_system.recordSpanEvent("iii.invocation.input", {
+									"iii.payload.json": json,
+									"iii.payload.truncated": truncated
+								});
+							}
+							try {
+								const result = await handler(input);
+								if (tracePayloads) {
+									const { json, truncated } = require_telemetry_system.redactAndTruncate(result, payloadMaxBytes);
+									require_telemetry_system.recordSpanEvent("iii.invocation.output", {
+										"iii.payload.json": json,
+										"iii.payload.truncated": truncated,
+										"iii.payload.ok": true
+									});
+								}
+								return result;
+							} catch (err) {
+								if (tracePayloads) {
+									const { json, truncated } = require_telemetry_system.redactAndTruncate({ error: err instanceof Error ? err.message : String(err) }, payloadMaxBytes);
+									require_telemetry_system.recordSpanEvent("iii.invocation.output", {
+										"iii.payload.json": json,
+										"iii.payload.truncated": truncated,
+										"iii.payload.ok": false
+									});
+								}
+								throw err;
+							}
+						};
+						if (require_telemetry_system.getTracer()) {
+							const parentContext = require_telemetry_system.extractContext(traceparent, baggage);
+							return _opentelemetry_api.context.with(parentContext, () => require_telemetry_system.withSpan(`call ${functionId}`, { kind: _opentelemetry_api.SpanKind.SERVER }, async () => await runHandler()));
 						}
 						const traceId = crypto.randomUUID().replace(/-/g, "");
 						const spanId = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
@@ -351,7 +377,7 @@ var Sdk = class {
 							spanId,
 							traceFlags: 1
 						});
-						return _opentelemetry_api.context.with(_opentelemetry_api.trace.setSpan(_opentelemetry_api.context.active(), syntheticSpan), async () => await handler(input));
+						return _opentelemetry_api.context.with(_opentelemetry_api.trace.setSpan(_opentelemetry_api.context.active(), syntheticSpan), async () => await runHandler());
 					}
 				});
 			} else this.functions.set(functionId, { message: fullMessage });
@@ -363,17 +389,6 @@ var Sdk = class {
 				}
 			};
 		};
-		this.registerService = (message) => {
-			const msg = {
-				...message,
-				name: message.name ?? message.id
-			};
-			this.sendMessage(MessageType.RegisterService, msg, true);
-			this.services.set(message.id, {
-				...msg,
-				message_type: MessageType.RegisterService
-			});
-		};
 		this.createChannel = async (bufferSize) => {
 			const result = await this.trigger({
 				function_id: "engine::channels::create",
@@ -390,8 +405,8 @@ var Sdk = class {
 			const { function_id, payload, action, timeoutMs } = request;
 			const effectiveTimeout = timeoutMs ?? this.invocationTimeoutMs;
 			if (action?.type === "void") {
-				const traceparent = require_utils.injectTraceparent();
-				const baggage = require_utils.injectBaggage();
+				const traceparent = require_telemetry_system.injectTraceparent();
+				const baggage = require_telemetry_system.injectBaggage();
 				this.sendMessage(MessageType.InvokeFunction, {
 					function_id,
 					data: payload,
@@ -402,13 +417,17 @@ var Sdk = class {
 				return;
 			}
 			const invocation_id = crypto.randomUUID();
-			const traceparent = require_utils.injectTraceparent();
-			const baggage = require_utils.injectBaggage();
+			const traceparent = require_telemetry_system.injectTraceparent();
+			const baggage = require_telemetry_system.injectBaggage();
 			return new Promise((resolve, reject) => {
 				const timeout = setTimeout(() => {
 					if (this.invocations.get(invocation_id)) {
 						this.invocations.delete(invocation_id);
-						reject(/* @__PURE__ */ new Error(`Invocation timeout after ${effectiveTimeout}ms: ${function_id}`));
+						reject(new IIIInvocationError({
+							code: "TIMEOUT",
+							message: `invocation timed out after ${effectiveTimeout}ms`,
+							function_id
+						}));
 					}
 				}, effectiveTimeout);
 				this.invocations.set(invocation_id, {
@@ -420,6 +439,7 @@ var Sdk = class {
 						clearTimeout(timeout);
 						reject(error);
 					},
+					function_id,
 					timeout
 				});
 				this.sendMessage(MessageType.InvokeFunction, {
@@ -432,30 +452,6 @@ var Sdk = class {
 				});
 			});
 		};
-		this.listFunctions = async () => {
-			return (await this.trigger({
-				function_id: require_utils.EngineFunctions.LIST_FUNCTIONS,
-				payload: {}
-			})).functions;
-		};
-		this.listWorkers = async () => {
-			return (await this.trigger({
-				function_id: require_utils.EngineFunctions.LIST_WORKERS,
-				payload: {}
-			})).workers;
-		};
-		this.listTriggers = async (includeInternal = false) => {
-			return (await this.trigger({
-				function_id: require_utils.EngineFunctions.LIST_TRIGGERS,
-				payload: { include_internal: includeInternal }
-			})).triggers;
-		};
-		this.listTriggerTypes = async (includeInternal = false) => {
-			return (await this.trigger({
-				function_id: require_utils.EngineFunctions.LIST_TRIGGER_TYPES,
-				payload: { include_internal: includeInternal }
-			})).trigger_types;
-		};
 		this.createStream = (streamName, stream) => {
 			this.registerFunction(`stream::get(${streamName})`, stream.get.bind(stream));
 			this.registerFunction(`stream::set(${streamName})`, stream.set.bind(stream));
@@ -463,35 +459,10 @@ var Sdk = class {
 			this.registerFunction(`stream::list(${streamName})`, stream.list.bind(stream));
 			this.registerFunction(`stream::list_groups(${streamName})`, stream.listGroups.bind(stream));
 		};
-		this.onFunctionsAvailable = (callback) => {
-			this.functionsAvailableCallbacks.add(callback);
-			if (!this.functionsAvailableTrigger) {
-				if (!this.functionsAvailableFunctionPath) this.functionsAvailableFunctionPath = `engine.on_functions_available.${crypto.randomUUID()}`;
-				const function_id = this.functionsAvailableFunctionPath;
-				if (!this.functions.has(function_id)) this.registerFunction(function_id, async ({ functions }) => {
-					this.functionsAvailableCallbacks.forEach((handler) => {
-						handler(functions);
-					});
-					return null;
-				});
-				this.functionsAvailableTrigger = this.registerTrigger({
-					type: require_utils.EngineTriggers.FUNCTIONS_AVAILABLE,
-					function_id,
-					config: {}
-				});
-			}
-			return () => {
-				this.functionsAvailableCallbacks.delete(callback);
-				if (this.functionsAvailableCallbacks.size === 0 && this.functionsAvailableTrigger) {
-					this.functionsAvailableTrigger.unregister();
-					this.functionsAvailableTrigger = void 0;
-				}
-			};
-		};
 		this.shutdown = async () => {
 			this.isShuttingDown = true;
 			this.stopMetricsReporting();
-			await require_utils.shutdownOtel();
+			await require_telemetry_system.shutdownOtel();
 			this.clearReconnectTimeout();
 			for (const [_id, invocation] of this.invocations) {
 				if (invocation.timeout) clearTimeout(invocation.timeout);
@@ -500,7 +471,10 @@ var Sdk = class {
 			this.invocations.clear();
 			if (this.ws) {
 				this.ws.removeAllListeners();
-				this.ws.close();
+				this.ws.on("error", () => {});
+				try {
+					this.ws.close();
+				} catch {}
 				this.ws = void 0;
 			}
 			this.setConnectionState("disconnected");
@@ -509,10 +483,10 @@ var Sdk = class {
 		this.metricsReportingEnabled = options?.enableMetricsReporting ?? true;
 		this.invocationTimeoutMs = options?.invocationTimeoutMs ?? 3e4;
 		this.reconnectionConfig = {
-			...require_utils.DEFAULT_BRIDGE_RECONNECTION_CONFIG,
+			...require_telemetry_system.DEFAULT_BRIDGE_RECONNECTION_CONFIG,
 			...options?.reconnectionConfig
 		};
-		require_utils.initOtel({
+		require_telemetry_system.initOtel({
 			...options?.otel,
 			engineWsUrl: this.address
 		});
@@ -522,16 +496,17 @@ var Sdk = class {
 		const telemetryOpts = this.options?.telemetry;
 		const language = telemetryOpts?.language ?? Intl.DateTimeFormat().resolvedOptions().locale ?? process.env.LANG?.split(".")[0];
 		this.trigger({
-			function_id: require_utils.EngineFunctions.REGISTER_WORKER,
+			function_id: require_telemetry_system.EngineFunctions.REGISTER_WORKER,
 			payload: {
 				runtime: "node",
 				version: SDK_VERSION,
 				name: this.workerName,
 				os: getOsInfo(),
 				pid: process.pid,
+				isolation: process.env.III_ISOLATION || null,
 				telemetry: {
 					language,
-					project_name: telemetryOpts?.project_name,
+					project_name: telemetryOpts?.project_name ?? require_telemetry_system.detectProjectName(),
 					framework: telemetryOpts?.framework?.trim() || "iii-node",
 					amplitude_api_key: telemetryOpts?.amplitude_api_key
 				}
@@ -582,18 +557,18 @@ var Sdk = class {
 	}
 	startMetricsReporting() {
 		if (!this.metricsReportingEnabled || !this.workerId) return;
-		const meter = require_utils.getMeter();
+		const meter = require_telemetry_system.getMeter();
 		if (!meter) {
 			console.warn("[iii] Worker metrics disabled: OpenTelemetry not initialized. Call initOtel() with metricsEnabled: true before creating the iii.");
 			return;
 		}
-		require_utils.registerWorkerGauges(meter, {
+		require_telemetry_system.registerWorkerGauges(meter, {
 			workerId: this.workerId,
 			workerName: this.workerName
 		});
 	}
 	stopMetricsReporting() {
-		require_utils.stopWorkerGauges();
+		require_telemetry_system.stopWorkerGauges();
 	}
 	onSocketClose() {
 		this.ws?.removeAllListeners();
@@ -611,9 +586,6 @@ var Sdk = class {
 		this.triggerTypes.forEach(({ message }) => {
 			this.sendMessage(MessageType.RegisterTriggerType, message, true);
 		});
-		this.services.forEach((service) => {
-			this.sendMessage(MessageType.RegisterService, service, true);
-		});
 		this.functions.forEach(({ message }) => {
 			this.sendMessage(MessageType.RegisterFunction, message, true);
 		});
@@ -677,7 +649,7 @@ var Sdk = class {
 		else if (!skipIfClosed) this.messagesToSend.push(wireMessage);
 	}
 	logError(message, error) {
-		const otelLogger = require_utils.getLogger();
+		const otelLogger = require_telemetry_system.getLogger();
 		const errorMessage = error instanceof Error ? error.message : String(error ?? "");
 		if (otelLogger) otelLogger.emit({
 			severityNumber: _opentelemetry_api_logs.SeverityNumber.ERROR,
@@ -689,12 +661,34 @@ var Sdk = class {
 		const invocation = this.invocations.get(invocation_id);
 		if (invocation) {
 			if (invocation.timeout) clearTimeout(invocation.timeout);
-			error ? invocation.reject(error) : invocation.resolve(result);
+			if (error) invocation.reject(this.toInvocationError(error, invocation.function_id));
+			else invocation.resolve(result);
 		}
 		this.invocations.delete(invocation_id);
 	}
+	/**
+	* Wrap a wire-format `ErrorBody` in {@link IIIInvocationError} so callers get
+	* a real `Error` with a readable `.message` and a typed `.code`. Pass-through
+	* for values that are already `Error` subclasses. Everything else is wrapped
+	* under an `UNKNOWN` code so `String(err) !== '[object Object]'` holds for
+	* every rejection path.
+	*/
+	toInvocationError(error, function_id) {
+		if (error instanceof Error) return error;
+		if (isErrorBody(error)) return new IIIInvocationError({
+			code: error.code,
+			message: error.message,
+			function_id,
+			stacktrace: error.stacktrace
+		});
+		return new IIIInvocationError({
+			code: "UNKNOWN",
+			message: typeof error === "string" ? error : JSON.stringify(error) ?? String(error),
+			function_id
+		});
+	}
 	resolveChannelValue(value) {
-		if (require_utils.isChannelRef(value)) return value.direction === "read" ? new ChannelReader(this.address, value) : new ChannelWriter(this.address, value);
+		if (require_telemetry_system.isChannelRef(value)) return value.direction === "read" ? new ChannelReader(this.address, value) : new ChannelWriter(this.address, value);
 		if (Array.isArray(value)) return value.map((item) => this.resolveChannelValue(item));
 		if (value !== null && typeof value === "object") {
 			const out = {};
@@ -705,8 +699,8 @@ var Sdk = class {
 	}
 	async onInvokeFunction(invocation_id, function_id, input, traceparent, baggage) {
 		const fn = this.functions.get(function_id);
-		const getResponseTraceparent = () => require_utils.injectTraceparent() ?? traceparent;
-		const getResponseBaggage = () => require_utils.injectBaggage() ?? baggage;
+		const getResponseTraceparent = () => require_telemetry_system.injectTraceparent() ?? traceparent;
+		const getResponseBaggage = () => require_telemetry_system.injectBaggage() ?? baggage;
 		const resolvedInput = this.resolveChannelValue(input);
 		if (fn?.handler) {
 			if (!invocation_id) {
@@ -899,7 +893,7 @@ const registerWorker = (address, options) => new Sdk(address, options);
 */
 var Logger = class {
 	get otelLogger() {
-		if (!this._otelLogger) this._otelLogger = require_utils.getLogger();
+		if (!this._otelLogger) this._otelLogger = require_telemetry_system.getLogger();
 		return this._otelLogger;
 	}
 	constructor(traceId, serviceName, spanId) {
@@ -910,8 +904,8 @@ var Logger = class {
 	}
 	emit(message, severity, data) {
 		const attributes = {};
-		const traceId = this.traceId ?? require_utils.currentTraceId();
-		const spanId = this.spanId ?? require_utils.currentSpanId();
+		const traceId = this.traceId ?? require_telemetry_system.currentTraceId();
+		const spanId = this.spanId ?? require_telemetry_system.currentSpanId();
 		if (traceId) attributes.trace_id = traceId;
 		if (spanId) attributes.span_id = spanId;
 		if (this.serviceName) attributes["service.name"] = this.serviceName;
@@ -1006,9 +1000,11 @@ var Logger = class {
 //#endregion
 exports.ChannelReader = ChannelReader;
 exports.ChannelWriter = ChannelWriter;
+exports.EngineFunctions = require_telemetry_system.EngineFunctions;
+exports.EngineTriggers = require_telemetry_system.EngineTriggers;
+exports.IIIInvocationError = IIIInvocationError;
 exports.Logger = Logger;
 exports.TriggerAction = TriggerAction;
-exports.__toESM = __toESM;
-exports.http = require_utils.http;
+exports.http = require_telemetry_system.http;
 exports.registerWorker = registerWorker;
 //# sourceMappingURL=index.cjs.map