@statelyai/sdk 0.14.2 → 0.16.0

package/dist/{transport-D2Ud05yg.mjs → transport-B_ig9Znn.mjs}

@@ -157,9 +157,7 @@ function createPostMessageTransport(options) {
 		},
 		onMessage(handler) {
 			messageHandlers.add(handler);
-			return () => {
-				messageHandlers.delete(handler);
-			};
+			return () => messageHandlers.delete(handler);
 		},
 		destroy() {
 			if (destroyed) return;
@@ -177,31 +175,52 @@ function createPostMessageTransport(options) {
 				return () => {};
 			}
 			readyHandlers.add(handler);
-			return () => {
-				readyHandlers.delete(handler);
-			};
+			return () => readyHandlers.delete(handler);
 		}
 	};
 }
 function createWebSocketTransport(options) {
-	const { url, role, sessionId, metadata, reconnect = true, maxReconnectAttempts = 10 } = options;
+	const { url, role, producerId, metadata, reconnect = true, maxReconnectAttempts = 10 } = options;
+	if (role === "producer" && !producerId) throw new Error("A producerId is required for producer transports.");
 	let ws = null;
 	let destroyed = false;
+	let terminalFailure = false;
 	let isReady = false;
 	let reconnectAttempts = 0;
 	let reconnectTimer = null;
 	const readyHandlers = /* @__PURE__ */ new Set();
 	const messageHandlers = /* @__PURE__ */ new Set();
+	const errorHandlers = /* @__PURE__ */ new Set();
+	function fail(failure) {
+		errorHandlers.forEach((handler) => handler(failure));
+	}
+	function scheduleReconnect() {
+		if (!reconnect || reconnectAttempts >= maxReconnectAttempts) {
+			terminalFailure = true;
+			fail({
+				code: "connection_failed",
+				message: `Unable to connect to inspection relay ${url}`
+			});
+			return;
+		}
+		const delay = Math.min(1e3 * 2 ** reconnectAttempts, 3e4);
+		reconnectAttempts++;
+		reconnectTimer = setTimeout(connect, delay);
+	}
 	function connect() {
-		if (destroyed) return;
-		ws = new WebSocket(url);
+		if (destroyed || terminalFailure) return;
+		try {
+			ws = new WebSocket(url);
+		} catch {
+			scheduleReconnect();
+			return;
+		}
 		ws.onopen = () => {
-			reconnectAttempts = 0;
 			ws.send(JSON.stringify({
 				type: "@statelyai.register",
 				protocolVersion: INSPECTION_PROTOCOL_VERSION,
 				role,
-				sessionId,
+				...producerId && { producerId },
 				...metadata && { metadata }
 			}));
 		};
@@ -217,20 +236,33 @@ function createWebSocketTransport(options) {
 			if (!raw.type.startsWith(PREFIX)) return;
 			const data = raw;
 			if (data.type === "@statelyai.registered") {
+				if (data.protocolVersion !== INSPECTION_PROTOCOL_VERSION) {
+					terminalFailure = true;
+					fail({
+						code: "unsupported_protocol",
+						message: `Relay selected protocol ${data.protocolVersion}; expected ${INSPECTION_PROTOCOL_VERSION}`
+					});
+					ws?.close(1002, "Unsupported inspection protocol");
+					return;
+				}
+				reconnectAttempts = 0;
 				const wasReady = isReady;
 				isReady = true;
 				if (!wasReady) readyHandlers.forEach((fn) => fn());
+			} else if (data.type === "@statelyai.error" && !isReady) {
+				terminalFailure = true;
+				fail({
+					code: data.code,
+					message: data.message
+				});
+				ws?.close(1002, data.message.slice(0, 123));
 			}
 			messageHandlers.forEach((fn) => fn(data));
 		};
 		ws.onclose = () => {
-			if (destroyed) return;
+			if (destroyed || terminalFailure) return;
 			isReady = false;
-			if (reconnect && reconnectAttempts < maxReconnectAttempts) {
-				const delay = Math.min(1e3 * 2 ** reconnectAttempts, 3e4);
-				reconnectAttempts++;
-				reconnectTimer = setTimeout(connect, delay);
-			}
+			scheduleReconnect();
 		};
 		ws.onerror = () => {};
 	}
@@ -242,9 +274,7 @@ function createWebSocketTransport(options) {
 		},
 		onMessage(handler) {
 			messageHandlers.add(handler);
-			return () => {
-				messageHandlers.delete(handler);
-			};
+			return () => messageHandlers.delete(handler);
 		},
 		destroy() {
 			if (destroyed) return;
@@ -254,6 +284,7 @@ function createWebSocketTransport(options) {
 			ws = null;
 			messageHandlers.clear();
 			readyHandlers.clear();
+			errorHandlers.clear();
 		},
 		get ready() {
 			return isReady && !!ws && ws.readyState === WebSocket.OPEN;
@@ -261,187 +292,14 @@ function createWebSocketTransport(options) {
 		onReady(handler) {
 			readyHandlers.add(handler);
 			if (isReady) handler();
-			return () => {
-				readyHandlers.delete(handler);
-			};
-		}
-	};
-}
-function createMultiplexedWebSocketConnection(options) {
-	const { url, role, sessionId: primarySessionId, metadata: primaryMetadata, reconnect = true, maxReconnectAttempts = 10 } = options;
-	let ws = null;
-	let destroyed = false;
-	let connectionReady = false;
-	let reconnectAttempts = 0;
-	let reconnectTimer = null;
-	const pendingOutbound = [];
-	const channels = /* @__PURE__ */ new Map();
-	function ensureChannel(opts) {
-		const existing = channels.get(opts.sessionId);
-		if (existing) return existing;
-		const state = {
-			sessionId: opts.sessionId,
-			metadata: opts.metadata,
-			ready: false,
-			readyHandlers: /* @__PURE__ */ new Set(),
-			messageHandlers: /* @__PURE__ */ new Set(),
-			registered: false,
-			transport: null
-		};
-		state.transport = {
-			send(msg) {
-				if (destroyed) return;
-				const stamped = {
-					...msg,
-					sessionId: state.sessionId
-				};
-				if (ws && ws.readyState === WebSocket.OPEN && state.registered) {
-					ws.send(JSON.stringify(stamped));
-					return;
-				}
-				pendingOutbound.push(stamped);
-			},
-			onMessage(handler) {
-				state.messageHandlers.add(handler);
-				return () => {
-					state.messageHandlers.delete(handler);
-				};
-			},
-			destroy() {
-				state.messageHandlers.clear();
-				state.readyHandlers.clear();
-				channels.delete(state.sessionId);
-			},
-			get ready() {
-				return state.ready;
-			},
-			onReady(handler) {
-				state.readyHandlers.add(handler);
-				if (state.ready) handler();
-				return () => {
-					state.readyHandlers.delete(handler);
-				};
-			}
-		};
-		channels.set(state.sessionId, state);
-		if (connectionReady && ws && ws.readyState === WebSocket.OPEN) registerChannel(state);
-		return state;
-	}
-	function registerChannel(state) {
-		if (!ws || ws.readyState !== WebSocket.OPEN) return;
-		if (state.registered) return;
-		if (state.sessionId === primarySessionId) return;
-		ws.send(JSON.stringify({
-			type: "@statelyai.addSession",
-			sessionId: state.sessionId,
-			...state.metadata && { metadata: state.metadata }
-		}));
-	}
-	function markChannelReady(sessionId) {
-		const state = channels.get(sessionId);
-		if (!state || state.ready) return;
-		state.ready = true;
-		state.registered = true;
-		state.readyHandlers.forEach((fn) => fn());
-		flushPending();
-	}
-	function flushPending() {
-		if (!ws || ws.readyState !== WebSocket.OPEN) return;
-		const remaining = [];
-		for (const msg of pendingOutbound) {
-			const sessionId = msg.sessionId ?? primarySessionId;
-			const state = channels.get(sessionId);
-			if (state && state.registered) ws.send(JSON.stringify(msg));
-			else remaining.push(msg);
-		}
-		pendingOutbound.length = 0;
-		pendingOutbound.push(...remaining);
-	}
-	function connect() {
-		if (destroyed) return;
-		ws = new WebSocket(url);
-		ws.onopen = () => {
-			reconnectAttempts = 0;
-			ws.send(JSON.stringify({
-				type: "@statelyai.register",
-				protocolVersion: INSPECTION_PROTOCOL_VERSION,
-				role,
-				sessionId: primarySessionId,
-				...primaryMetadata && { metadata: primaryMetadata }
-			}));
-		};
-		ws.onmessage = (event) => {
-			if (destroyed) return;
-			let raw;
-			try {
-				raw = JSON.parse(event.data);
-			} catch {
-				return;
-			}
-			if (!raw?.type || typeof raw.type !== "string") return;
-			if (!raw.type.startsWith(PREFIX)) return;
-			const data = raw;
-			if (data.type === "@statelyai.registered") {
-				connectionReady = true;
-				markChannelReady(primarySessionId);
-				for (const state of channels.values()) if (!state.registered && state.sessionId !== primarySessionId) registerChannel(state);
-				flushPending();
-				return;
-			}
-			if (data.type === "@statelyai.sessionAdded") {
-				const added = data.sessionId;
-				if (added) markChannelReady(added);
-				return;
-			}
-			const sessionId = raw.sessionId ?? primarySessionId;
-			const state = channels.get(sessionId);
-			if (state) state.messageHandlers.forEach((fn) => fn(data));
-		};
-		ws.onclose = () => {
-			if (destroyed) return;
-			connectionReady = false;
-			for (const state of channels.values()) {
-				state.ready = false;
-				state.registered = false;
-			}
-			if (reconnect && reconnectAttempts < maxReconnectAttempts) {
-				const delay = Math.min(1e3 * 2 ** reconnectAttempts, 3e4);
-				reconnectAttempts++;
-				reconnectTimer = setTimeout(connect, delay);
-			}
-		};
-		ws.onerror = () => {};
-	}
-	ensureChannel({
-		sessionId: primarySessionId,
-		metadata: primaryMetadata
-	});
-	connect();
-	return {
-		openChannel(opts) {
-			return ensureChannel(opts).transport;
-		},
-		destroy() {
-			if (destroyed) return;
-			destroyed = true;
-			if (reconnectTimer) clearTimeout(reconnectTimer);
-			ws?.close();
-			ws = null;
-			for (const state of channels.values()) {
-				state.messageHandlers.clear();
-				state.readyHandlers.clear();
-			}
-			channels.clear();
-			pendingOutbound.length = 0;
-		},
-		get ready() {
-			return connectionReady;
+			return () => readyHandlers.delete(handler);
 		},
-		get primarySessionId() {
-			return primarySessionId;
+		onError(handler) {
+			errorHandlers.add(handler);
+			return () => errorHandlers.delete(handler);
 		}
 	};
 }
 
 //#endregion
-export { createPendingExportManager as a, createEventRegistry as i, createPostMessageTransport as n, toInitMessage as o, createWebSocketTransport as r, createMultiplexedWebSocketConnection as t };
+export { toInitMessage as a, createPendingExportManager as i, createWebSocketTransport as n, createEventRegistry as r, createPostMessageTransport as t };

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@statelyai/sdk",
-  "version": "0.14.2",
+  "version": "0.16.0",
   "license": "MIT",
+  "bin": {
+    "stately-sdk": "./dist/bin.mjs"
+  },
   "files": [
     "dist",
     "schemas"
@@ -62,6 +65,10 @@
       "types": "./dist/relay.d.mts",
       "import": "./dist/relay.mjs"
     },
+    "./node-relay": {
+      "types": "./dist/node-relay.d.mts",
+      "import": "./dist/node-relay.mjs"
+    },
     "./statelyai.schema.json": "./schemas/statelyai.schema.json",
     "./schemas/statelyai.schema.json": "./schemas/statelyai.schema.json",
     "./xstate.schema.json": "./schemas/xstate.schema.json",
@@ -73,20 +80,25 @@
     "@statelyai/graph": "^1.0.0",
     "esbuild": "^0.27.0",
     "typescript": "^5.9.3",
+    "ws": "^8.19.0",
     "xstate": "^5.0.0"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
+    "@types/ws": "^8.18.1",
     "jsdom": "^27.4.0",
     "tsdown": "0.21.0-beta.2",
     "vitest": "^3.2.4",
-    "ws": "^8.19.0",
+    "@statelyai/api-contract": "0.0.1",
     "@statelyai/graph-tools": "0.0.7"
   },
+  "engines": {
+    "node": ">=22.4"
+  },
   "scripts": {
     "build": "tsdown",
     "test": "vitest run",
-    "test:live": "vitest run src/studio.live.integration.test.ts",
+    "test:live": "vitest run --config vitest.live.config.ts",
     "test:watch": "vitest"
   }
 }