iii-browser-sdk 0.10.0

package/dist/index.mjs

@@ -0,0 +1,800 @@
+//#region src/channels.ts
+/**
+* Write end of a streaming channel. Uses native browser WebSocket.
+*
+* @example
+* ```typescript
+* const channel = await iii.createChannel()
+*
+* channel.writer.sendMessage(JSON.stringify({ type: 'event', data: 'test' }))
+* channel.writer.sendBinary(new Uint8Array([1, 2, 3]))
+* channel.writer.close()
+* ```
+*/
+var ChannelWriter = class ChannelWriter {
+	static {
+		this.FRAME_SIZE = 64 * 1024;
+	}
+	constructor(engineWsBase, ref) {
+		this.ws = null;
+		this.wsReady = false;
+		this.pendingMessages = [];
+		this.url = buildChannelUrl(engineWsBase, ref.channel_id, ref.access_key, "write");
+	}
+	ensureConnected() {
+		if (this.ws) return;
+		this.ws = new WebSocket(this.url);
+		this.ws.binaryType = "arraybuffer";
+		this.ws.addEventListener("open", () => {
+			this.wsReady = true;
+			for (const { data, resolve, reject } of this.pendingMessages) try {
+				this.ws?.send(data);
+				resolve();
+			} catch (err) {
+				reject(err instanceof Error ? err : new Error(String(err)));
+			}
+			this.pendingMessages.length = 0;
+		});
+		this.ws.addEventListener("error", () => {
+			for (const { reject } of this.pendingMessages) reject(/* @__PURE__ */ new Error("WebSocket error"));
+			this.pendingMessages.length = 0;
+		});
+	}
+	/** Send a text message through the channel. */
+	sendMessage(msg) {
+		this.ensureConnected();
+		this.sendRaw(msg);
+	}
+	/** Send binary data through the channel. */
+	sendBinary(data) {
+		this.ensureConnected();
+		let offset = 0;
+		while (offset < data.length) {
+			const end = Math.min(offset + ChannelWriter.FRAME_SIZE, data.length);
+			const chunk = data.subarray(offset, end);
+			const buffer = chunk.buffer instanceof ArrayBuffer ? chunk.buffer : new ArrayBuffer(chunk.byteLength);
+			if (!(chunk.buffer instanceof ArrayBuffer)) new Uint8Array(buffer).set(chunk);
+			this.sendRaw(buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength));
+			offset = end;
+		}
+	}
+	/** Close the channel writer. */
+	close() {
+		if (!this.ws) return;
+		const doClose = () => {
+			if (this.ws && this.ws.readyState === WebSocket.OPEN) this.ws.close(1e3, "channel_close");
+		};
+		if (this.wsReady) doClose();
+		else this.ws.addEventListener("open", () => doClose());
+	}
+	sendRaw(data) {
+		if (this.wsReady && this.ws && this.ws.readyState === WebSocket.OPEN) this.ws.send(data);
+		else {
+			this.ensureConnected();
+			this.pendingMessages.push({
+				data,
+				resolve: () => {},
+				reject: () => {}
+			});
+		}
+	}
+};
+/**
+* Read end of a streaming channel. Uses native browser WebSocket.
+*
+* @example
+* ```typescript
+* const channel = await iii.createChannel()
+*
+* channel.reader.onMessage((msg) => console.log('Got:', msg))
+* channel.reader.onBinary((data) => console.log('Binary:', data.byteLength))
+* ```
+*/
+var ChannelReader = class {
+	constructor(engineWsBase, ref) {
+		this.ws = null;
+		this.connected = false;
+		this.messageCallbacks = [];
+		this.binaryCallbacks = [];
+		this.url = buildChannelUrl(engineWsBase, ref.channel_id, ref.access_key, "read");
+	}
+	ensureConnected() {
+		if (this.connected) return;
+		this.connected = true;
+		this.ws = new WebSocket(this.url);
+		this.ws.binaryType = "arraybuffer";
+		this.ws.addEventListener("message", (event) => {
+			if (event.data instanceof ArrayBuffer) {
+				const data = new Uint8Array(event.data);
+				for (const cb of this.binaryCallbacks) cb(data);
+			} else if (typeof event.data === "string") for (const cb of this.messageCallbacks) cb(event.data);
+		});
+		this.ws.addEventListener("close", () => {
+			this.ws = null;
+		});
+		this.ws.addEventListener("error", () => {
+			this.ws = null;
+		});
+	}
+	/** Register a callback to receive text messages from the channel. */
+	onMessage(callback) {
+		this.messageCallbacks.push(callback);
+		this.ensureConnected();
+	}
+	/** Register a callback to receive binary data from the channel. */
+	onBinary(callback) {
+		this.binaryCallbacks.push(callback);
+		this.ensureConnected();
+	}
+	/** Read all binary data from the channel until it closes. */
+	async readAll() {
+		this.ensureConnected();
+		const chunks = [];
+		return new Promise((resolve) => {
+			const onData = (data) => {
+				chunks.push(data);
+			};
+			this.binaryCallbacks.push(onData);
+			const originalWs = this.ws;
+			if (originalWs) originalWs.addEventListener("close", () => {
+				const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+				const result = new Uint8Array(totalLength);
+				let offset = 0;
+				for (const chunk of chunks) {
+					result.set(chunk, offset);
+					offset += chunk.length;
+				}
+				resolve(result);
+			});
+		});
+	}
+	/** Close the channel reader. */
+	close() {
+		if (this.ws && this.ws.readyState !== WebSocket.CLOSED) this.ws.close(1e3, "channel_close");
+	}
+};
+function buildChannelUrl(engineWsBase, channelId, accessKey, direction) {
+	return `${engineWsBase.replace(/\/$/, "")}/ws/channels/${channelId}?key=${encodeURIComponent(accessKey)}&dir=${direction}`;
+}
+
+//#endregion
+//#region src/iii-constants.ts
+/**
+* Constants for the III module.
+*/
+/** Engine function paths for internal operations */
+const EngineFunctions = {
+	LIST_FUNCTIONS: "engine::functions::list",
+	LIST_WORKERS: "engine::workers::list",
+	LIST_TRIGGERS: "engine::triggers::list",
+	LIST_TRIGGER_TYPES: "engine::trigger-types::list",
+	REGISTER_WORKER: "engine::workers::register"
+};
+/** Engine trigger types */
+const EngineTriggers = { FUNCTIONS_AVAILABLE: "engine::functions-available" };
+/** Default reconnection configuration */
+const DEFAULT_BRIDGE_RECONNECTION_CONFIG = {
+	initialDelayMs: 1e3,
+	maxDelayMs: 3e4,
+	backoffMultiplier: 2,
+	jitterFactor: .3,
+	maxRetries: -1
+};
+/** Default invocation timeout in milliseconds */
+const DEFAULT_INVOCATION_TIMEOUT_MS = 3e4;
+
+//#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";
+	MessageType["RegisterTrigger"] = "registertrigger";
+	MessageType["UnregisterTrigger"] = "unregistertrigger";
+	MessageType["UnregisterTriggerType"] = "unregistertriggertype";
+	MessageType["TriggerRegistrationResult"] = "triggerregistrationresult";
+	MessageType["WorkerRegistered"] = "workerregistered";
+	return MessageType;
+}({});
+
+//#endregion
+//#region src/utils.ts
+/**
+* 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;
+	return typeof maybe.channel_id === "string" && typeof maybe.access_key === "string" && (maybe.direction === "read" || maybe.direction === "write");
+};
+
+//#endregion
+//#region src/iii.ts
+const SDK_VERSION = "0.10.0";
+function getBrowserInfo() {
+	if (typeof navigator !== "undefined" && navigator.userAgent) return navigator.userAgent;
+	return "browser (unknown)";
+}
+function getDefaultWorkerName() {
+	return `browser:${crypto.randomUUID().slice(0, 8)}`;
+}
+var Sdk = class {
+	constructor(address, options) {
+		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";
+		this.isShuttingDown = false;
+		this.registerTriggerType = (triggerType, handler) => {
+			this.sendMessage(MessageType.RegisterTriggerType, triggerType, true);
+			this.triggerTypes.set(triggerType.id, {
+				message: {
+					...triggerType,
+					message_type: MessageType.RegisterTriggerType
+				},
+				handler
+			});
+			return {
+				id: triggerType.id,
+				registerTrigger: (functionId, config) => {
+					return this.registerTrigger({
+						type: triggerType.id,
+						function_id: functionId,
+						config
+					});
+				},
+				registerFunction: (func, handler, config) => {
+					const ref = this.registerFunction(func, handler);
+					this.registerTrigger({
+						type: triggerType.id,
+						function_id: func.id,
+						config
+					});
+					return ref;
+				},
+				unregister: () => {
+					this.unregisterTriggerType(triggerType);
+				}
+			};
+		};
+		this.unregisterTriggerType = (triggerType) => {
+			this.sendMessage(MessageType.UnregisterTriggerType, triggerType, true);
+			this.triggerTypes.delete(triggerType.id);
+		};
+		this.registerTrigger = (trigger) => {
+			const id = crypto.randomUUID();
+			const fullTrigger = {
+				...trigger,
+				id,
+				message_type: MessageType.RegisterTrigger
+			};
+			this.sendMessage(MessageType.RegisterTrigger, fullTrigger, true);
+			this.triggers.set(id, fullTrigger);
+			return { unregister: () => {
+				this.sendMessage(MessageType.UnregisterTrigger, {
+					id,
+					message_type: MessageType.UnregisterTrigger,
+					type: fullTrigger.type
+				});
+				this.triggers.delete(id);
+			} };
+		};
+		this.registerFunction = (message, handlerOrInvocation) => {
+			if (!message.id || message.id.trim() === "") throw new Error("id is required");
+			if (this.functions.has(message.id)) throw new Error(`function id already registered: ${message.id}`);
+			const isHandler = typeof handlerOrInvocation === "function";
+			const fullMessage = isHandler ? {
+				...message,
+				message_type: MessageType.RegisterFunction
+			} : {
+				...message,
+				message_type: MessageType.RegisterFunction,
+				invocation: {
+					url: handlerOrInvocation.url,
+					method: handlerOrInvocation.method ?? "POST",
+					timeout_ms: handlerOrInvocation.timeout_ms,
+					headers: handlerOrInvocation.headers,
+					auth: handlerOrInvocation.auth
+				}
+			};
+			this.sendMessage(MessageType.RegisterFunction, fullMessage, true);
+			if (isHandler) {
+				const handler = handlerOrInvocation;
+				this.functions.set(message.id, {
+					message: fullMessage,
+					handler: async (input, _traceparent, _baggage) => {
+						return await handler(input);
+					}
+				});
+			} else this.functions.set(message.id, { message: fullMessage });
+			return {
+				id: message.id,
+				unregister: () => {
+					this.sendMessage(MessageType.UnregisterFunction, { id: message.id }, true);
+					this.functions.delete(message.id);
+				}
+			};
+		};
+		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",
+				payload: { buffer_size: bufferSize }
+			});
+			return {
+				writer: new ChannelWriter(this.address, result.writer),
+				reader: new ChannelReader(this.address, result.reader),
+				writerRef: result.writer,
+				readerRef: result.reader
+			};
+		};
+		this.trigger = async (request) => {
+			const { function_id, payload, action, timeoutMs } = request;
+			const effectiveTimeout = timeoutMs ?? this.invocationTimeoutMs;
+			if (action?.type === "void") {
+				this.sendMessage(MessageType.InvokeFunction, {
+					function_id,
+					data: payload,
+					action
+				});
+				return;
+			}
+			const invocation_id = crypto.randomUUID();
+			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}`));
+					}
+				}, effectiveTimeout);
+				this.invocations.set(invocation_id, {
+					resolve: (result) => {
+						clearTimeout(timeout);
+						resolve(result);
+					},
+					reject: (error) => {
+						clearTimeout(timeout);
+						reject(error);
+					},
+					timeout
+				});
+				this.sendMessage(MessageType.InvokeFunction, {
+					invocation_id,
+					function_id,
+					data: payload,
+					action
+				});
+			});
+		};
+		this.listFunctions = async () => {
+			return (await this.trigger({
+				function_id: EngineFunctions.LIST_FUNCTIONS,
+				payload: {}
+			})).functions;
+		};
+		this.listWorkers = async () => {
+			return (await this.trigger({
+				function_id: EngineFunctions.LIST_WORKERS,
+				payload: {}
+			})).workers;
+		};
+		this.listTriggers = async (includeInternal = false) => {
+			return (await this.trigger({
+				function_id: EngineFunctions.LIST_TRIGGERS,
+				payload: { include_internal: includeInternal }
+			})).triggers;
+		};
+		this.listTriggerTypes = async (includeInternal = false) => {
+			return (await this.trigger({
+				function_id: EngineFunctions.LIST_TRIGGER_TYPES,
+				payload: { include_internal: includeInternal }
+			})).trigger_types;
+		};
+		this.createStream = (streamName, stream) => {
+			this.registerFunction({ id: `stream::get(${streamName})` }, stream.get.bind(stream));
+			this.registerFunction({ id: `stream::set(${streamName})` }, stream.set.bind(stream));
+			this.registerFunction({ id: `stream::delete(${streamName})` }, stream.delete.bind(stream));
+			this.registerFunction({ id: `stream::list(${streamName})` }, stream.list.bind(stream));
+			this.registerFunction({ id: `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({ id: function_id }, async ({ functions }) => {
+					this.functionsAvailableCallbacks.forEach((handler) => {
+						handler(functions);
+					});
+					return null;
+				});
+				this.functionsAvailableTrigger = this.registerTrigger({
+					type: 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.clearReconnectTimeout();
+			for (const [_id, invocation] of this.invocations) {
+				if (invocation.timeout) clearTimeout(invocation.timeout);
+				invocation.reject(/* @__PURE__ */ new Error("iii is shutting down"));
+			}
+			this.invocations.clear();
+			if (this.ws) {
+				this.ws.onopen = null;
+				this.ws.onclose = null;
+				this.ws.onerror = null;
+				this.ws.onmessage = null;
+				this.ws.close();
+				this.ws = void 0;
+			}
+			this.setConnectionState("disconnected");
+		};
+		this.workerName = options?.workerName ?? getDefaultWorkerName();
+		this.invocationTimeoutMs = options?.invocationTimeoutMs ?? 3e4;
+		this.reconnectionConfig = {
+			...DEFAULT_BRIDGE_RECONNECTION_CONFIG,
+			...options?.reconnectionConfig
+		};
+		this.connect();
+	}
+	registerWorkerMetadata() {
+		const telemetryOpts = this.options?.telemetry;
+		const language = telemetryOpts?.language ?? (typeof navigator !== "undefined" ? navigator.language : void 0);
+		this.trigger({
+			function_id: EngineFunctions.REGISTER_WORKER,
+			payload: {
+				runtime: "browser",
+				version: SDK_VERSION,
+				name: this.workerName,
+				os: getBrowserInfo(),
+				pid: 0,
+				telemetry: {
+					language,
+					project_name: telemetryOpts?.project_name,
+					framework: telemetryOpts?.framework,
+					amplitude_api_key: telemetryOpts?.amplitude_api_key
+				}
+			},
+			action: { type: "void" }
+		});
+	}
+	setConnectionState(state) {
+		if (this.connectionState !== state) this.connectionState = state;
+	}
+	connect() {
+		if (this.isShuttingDown) return;
+		this.setConnectionState("connecting");
+		this.ws = new WebSocket(this.address);
+		this.ws.onopen = this.onSocketOpen.bind(this);
+		this.ws.onclose = this.onSocketClose.bind(this);
+		this.ws.onerror = this.onSocketError.bind(this);
+	}
+	clearReconnectTimeout() {
+		if (this.reconnectTimeout) {
+			clearTimeout(this.reconnectTimeout);
+			this.reconnectTimeout = void 0;
+		}
+	}
+	scheduleReconnect() {
+		if (this.isShuttingDown) return;
+		const { maxRetries, initialDelayMs, backoffMultiplier, maxDelayMs, jitterFactor } = this.reconnectionConfig;
+		if (maxRetries !== -1 && this.reconnectAttempt >= maxRetries) {
+			this.setConnectionState("failed");
+			console.error(`[iii] Max reconnection retries (${maxRetries}) reached, giving up`);
+			return;
+		}
+		if (this.reconnectTimeout) return;
+		const exponentialDelay = initialDelayMs * backoffMultiplier ** this.reconnectAttempt;
+		const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+		const jitter = cappedDelay * jitterFactor * (2 * Math.random() - 1);
+		const delay = Math.floor(cappedDelay + jitter);
+		this.setConnectionState("reconnecting");
+		console.debug(`[iii] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt + 1})...`);
+		this.reconnectTimeout = setTimeout(() => {
+			this.reconnectTimeout = void 0;
+			this.reconnectAttempt++;
+			this.connect();
+		}, delay);
+	}
+	onSocketError() {
+		console.error("[iii] WebSocket error");
+	}
+	onSocketClose() {
+		if (this.ws) {
+			this.ws.onopen = null;
+			this.ws.onclose = null;
+			this.ws.onerror = null;
+			this.ws.onmessage = null;
+		}
+		this.ws = void 0;
+		this.setConnectionState("disconnected");
+		this.scheduleReconnect();
+	}
+	onSocketOpen() {
+		this.clearReconnectTimeout();
+		this.reconnectAttempt = 0;
+		this.setConnectionState("connected");
+		if (this.ws) this.ws.onmessage = this.onMessage.bind(this);
+		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);
+		});
+		this.triggers.forEach((trigger) => {
+			this.sendMessage(MessageType.RegisterTrigger, trigger, true);
+		});
+		const pending = this.messagesToSend;
+		this.messagesToSend = [];
+		for (const message of pending) {
+			if (message.type === MessageType.InvokeFunction && typeof message.invocation_id === "string" && !this.invocations.has(message.invocation_id)) continue;
+			this.sendMessageRaw(JSON.stringify(message));
+		}
+		this.registerWorkerMetadata();
+	}
+	isOpen() {
+		return this.ws?.readyState === WebSocket.OPEN;
+	}
+	sendMessageRaw(data) {
+		if (this.ws && this.isOpen()) try {
+			this.ws.send(data);
+		} catch (error) {
+			console.error("[iii] Exception while sending message", error);
+		}
+	}
+	toWireFormat(messageType, message) {
+		const { message_type: _, ...rest } = message;
+		if (messageType === MessageType.RegisterTrigger && "type" in message) {
+			const { type: triggerType, ...triggerRest } = message;
+			return {
+				type: messageType,
+				...triggerRest,
+				trigger_type: triggerType
+			};
+		}
+		if (messageType === MessageType.UnregisterTrigger && "type" in message) {
+			const { type: triggerType, ...triggerRest } = message;
+			return {
+				type: messageType,
+				...triggerRest,
+				trigger_type: triggerType
+			};
+		}
+		if (messageType === MessageType.TriggerRegistrationResult && "type" in message) {
+			const { type: triggerType, ...resultRest } = message;
+			return {
+				type: messageType,
+				...resultRest,
+				trigger_type: triggerType
+			};
+		}
+		return {
+			type: messageType,
+			...rest
+		};
+	}
+	sendMessage(messageType, message, skipIfClosed = false) {
+		const wireMessage = this.toWireFormat(messageType, message);
+		if (this.isOpen()) this.sendMessageRaw(JSON.stringify(wireMessage));
+		else if (!skipIfClosed) this.messagesToSend.push(wireMessage);
+	}
+	onInvocationResult(invocation_id, result, error) {
+		const invocation = this.invocations.get(invocation_id);
+		if (invocation) {
+			if (invocation.timeout) clearTimeout(invocation.timeout);
+			error ? invocation.reject(error) : invocation.resolve(result);
+		}
+		this.invocations.delete(invocation_id);
+	}
+	resolveChannelValue(value) {
+		if (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 = {};
+			for (const [k, v] of Object.entries(value)) out[k] = this.resolveChannelValue(v);
+			return out;
+		}
+		return value;
+	}
+	async onInvokeFunction(invocation_id, function_id, input, traceparent, baggage) {
+		const fn = this.functions.get(function_id);
+		const resolvedInput = this.resolveChannelValue(input);
+		if (fn?.handler) {
+			if (!invocation_id) {
+				try {
+					await fn.handler(resolvedInput, traceparent, baggage);
+				} catch (error) {
+					console.error(`[iii] Error invoking function ${function_id}`, error);
+				}
+				return;
+			}
+			try {
+				const result = await fn.handler(resolvedInput, traceparent, baggage);
+				this.sendMessage(MessageType.InvocationResult, {
+					invocation_id,
+					function_id,
+					result,
+					traceparent,
+					baggage
+				});
+			} catch (error) {
+				const isError = error instanceof Error;
+				this.sendMessage(MessageType.InvocationResult, {
+					invocation_id,
+					function_id,
+					error: {
+						code: "invocation_failed",
+						message: isError ? error.message : String(error),
+						stacktrace: isError ? error.stack : void 0
+					},
+					traceparent,
+					baggage
+				});
+			}
+		} else {
+			const errorCode = fn ? "function_not_invokable" : "function_not_found";
+			const errorMessage = fn ? "Function is HTTP-invoked and cannot be invoked locally" : "Function not found";
+			if (invocation_id) this.sendMessage(MessageType.InvocationResult, {
+				invocation_id,
+				function_id,
+				error: {
+					code: errorCode,
+					message: errorMessage
+				},
+				traceparent,
+				baggage
+			});
+		}
+	}
+	async onRegisterTrigger(message) {
+		const { trigger_type, id, function_id, config } = message;
+		const triggerTypeData = this.triggerTypes.get(trigger_type);
+		if (triggerTypeData) try {
+			await triggerTypeData.handler.registerTrigger({
+				id,
+				function_id,
+				config
+			});
+			this.sendMessage(MessageType.TriggerRegistrationResult, {
+				id,
+				message_type: MessageType.TriggerRegistrationResult,
+				type: trigger_type,
+				function_id
+			});
+		} catch (error) {
+			this.sendMessage(MessageType.TriggerRegistrationResult, {
+				id,
+				message_type: MessageType.TriggerRegistrationResult,
+				type: trigger_type,
+				function_id,
+				error: {
+					code: "trigger_registration_failed",
+					message: error.message
+				}
+			});
+		}
+		else this.sendMessage(MessageType.TriggerRegistrationResult, {
+			id,
+			message_type: MessageType.TriggerRegistrationResult,
+			type: trigger_type,
+			function_id,
+			error: {
+				code: "trigger_type_not_found",
+				message: "Trigger type not found"
+			}
+		});
+	}
+	onMessage(event) {
+		let msgType;
+		let message;
+		try {
+			const parsed = JSON.parse(typeof event.data === "string" ? event.data : "");
+			msgType = parsed.type;
+			const { type: _, ...rest } = parsed;
+			message = rest;
+		} catch (error) {
+			console.error("[iii] Failed to parse incoming message", error);
+			return;
+		}
+		if (msgType === MessageType.InvocationResult) {
+			const { invocation_id, result, error } = message;
+			this.onInvocationResult(invocation_id, result, error);
+		} else if (msgType === MessageType.InvokeFunction) {
+			const { invocation_id, function_id, data, traceparent, baggage } = message;
+			this.onInvokeFunction(invocation_id, function_id, data, traceparent, baggage);
+		} else if (msgType === MessageType.RegisterTrigger) this.onRegisterTrigger(message);
+		else if (msgType === MessageType.WorkerRegistered) {
+			const { worker_id } = message;
+			this.workerId = worker_id;
+			console.debug("[iii] Worker registered with ID:", worker_id);
+		}
+	}
+};
+/**
+* Factory object that constructs routing actions for {@link ISdk.trigger}.
+*
+* @example
+* ```typescript
+* import { TriggerAction } from 'iii-browser-sdk'
+*
+* // Enqueue to a named queue
+* iii.trigger({
+*   function_id: 'process',
+*   payload: { data: 'hello' },
+*   action: TriggerAction.Enqueue({ queue: 'jobs' }),
+* })
+*
+* // Fire-and-forget
+* iii.trigger({
+*   function_id: 'notify',
+*   payload: {},
+*   action: TriggerAction.Void(),
+* })
+* ```
+*/
+const TriggerAction = {
+	Enqueue: (opts) => ({
+		type: "enqueue",
+		...opts
+	}),
+	Void: () => ({ type: "void" })
+};
+/**
+* Creates and returns a connected SDK instance. The WebSocket connection is
+* established automatically -- there is no separate `connect()` call.
+*
+* @param address - WebSocket URL of the III engine (e.g. `ws://localhost:49135`).
+* @param options - Optional {@link InitOptions} for worker name, timeouts, and reconnection.
+* @returns A connected {@link ISdk} instance.
+*
+* @example
+* ```typescript
+* import { registerWorker } from 'iii-browser-sdk'
+*
+* const iii = registerWorker('ws://localhost:49135', {
+*   workerName: 'my-browser-worker',
+* })
+* ```
+*/
+const registerWorker = (address, options) => new Sdk(address, options);
+
+//#endregion
+export { ChannelReader, ChannelWriter, TriggerAction, registerWorker };
+//# sourceMappingURL=index.mjs.map