@statelyai/sdk 0.12.2 → 0.13.0

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

@@ -1,4 +1,4 @@
-import { PREFIX } from "./protocol.mjs";
+import { INSPECTION_PROTOCOL_VERSION, PREFIX } from "./protocol.mjs";
 
 //#region src/clientUtils.ts
 const jsonResultFormats = new Set([
@@ -113,6 +113,7 @@ function toInitMessage(options) {
 		mode: options.mode,
 		theme: options.theme,
 		readOnly: options.readOnly,
+		readOnlyReason: options.readOnlyReason,
 		depth: options.depth,
 		capabilities: options.capabilities,
 		leftPanels: options.panels?.leftPanels,
@@ -198,6 +199,7 @@ function createWebSocketTransport(options) {
 			reconnectAttempts = 0;
 			ws.send(JSON.stringify({
 				type: "@statelyai.register",
+				protocolVersion: INSPECTION_PROTOCOL_VERSION,
 				role,
 				sessionId,
 				...metadata && { metadata }
@@ -265,6 +267,181 @@ function createWebSocketTransport(options) {
 		}
 	};
 }
+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;
+		},
+		get primarySessionId() {
+			return primarySessionId;
+		}
+	};
+}
 
 //#endregion
-export { toInitMessage as a, createPendingExportManager as i, createWebSocketTransport as n, createEventRegistry as r, createPostMessageTransport as t };
+export { createPendingExportManager as a, createEventRegistry as i, createPostMessageTransport as n, toInitMessage as o, createWebSocketTransport as r, createMultiplexedWebSocketConnection as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/sdk",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "license": "MIT",
   "files": [
     "dist",
@@ -58,6 +58,10 @@
       "types": "./dist/protocol.d.mts",
       "import": "./dist/protocol.mjs"
     },
+    "./relay": {
+      "types": "./dist/relay.d.mts",
+      "import": "./dist/relay.mjs"
+    },
     "./statelyai.schema.json": "./schemas/statelyai.schema.json",
     "./schemas/statelyai.schema.json": "./schemas/statelyai.schema.json",
     "./xstate.schema.json": "./schemas/xstate.schema.json",
@@ -76,7 +80,8 @@
     "jsdom": "^27.4.0",
     "tsdown": "0.21.0-beta.2",
     "vitest": "^3.2.4",
-    "@statelyai/graph-tools": "0.0.3"
+    "ws": "^8.19.0",
+    "@statelyai/graph-tools": "0.0.4"
   },
   "scripts": {
     "build": "tsdown",