@statelyai/sdk 0.2.0 → 0.3.1

package/dist/graph.mjs

@@ -0,0 +1,344 @@
+import { createFormatConverter, createGraph } from "@statelyai/graph";
+
+//#region src/graph.ts
+function toJsonObject(value) {
+	return value;
+}
+function toUnknownRecord(value) {
+	return value;
+}
+function normalizeStudioNodeType(type) {
+	return type === "annotation" ? void 0 : type;
+}
+function normalizeSchemas(schemas) {
+	if (!schemas) return;
+	return {
+		input: schemas.input ?? null,
+		output: schemas.output ?? null,
+		context: schemas.context ?? {},
+		events: schemas.events ?? {},
+		actions: schemas.actions ?? {},
+		guards: schemas.guards ?? {},
+		actors: schemas.actors ?? {},
+		tags: schemas.tags ?? {},
+		delays: schemas.delays ?? {}
+	};
+}
+function toCanvasColor(color) {
+	return color;
+}
+function normalizeStudioHistory(history) {
+	if (history === true) return "shallow";
+	return history || void 0;
+}
+function toActionSource(action) {
+	return {
+		type: "action",
+		id: action.id,
+		name: action.name,
+		...action.description ? { description: action.description } : {},
+		...action.icon ? { icon: action.icon } : {},
+		lang: action.code?.lang ?? "js",
+		imports: [],
+		code: action.code?.body,
+		...action.paramsSchema ? { paramsSchema: action.paramsSchema } : {}
+	};
+}
+function toGuardSource(guard) {
+	return {
+		type: "guard",
+		id: guard.id,
+		name: guard.name,
+		...guard.description ? { description: guard.description } : {},
+		...guard.icon ? { icon: guard.icon } : {},
+		lang: guard.code?.lang ?? "js",
+		imports: [],
+		code: guard.code?.body,
+		...guard.paramsSchema ? { paramsSchema: guard.paramsSchema } : {}
+	};
+}
+function toActorSource(actor) {
+	return {
+		type: "actor",
+		id: actor.id,
+		name: actor.name,
+		...actor.description ? { description: actor.description } : {},
+		...actor.icon ? { icon: actor.icon } : {},
+		lang: actor.code?.lang ?? "js",
+		imports: [],
+		code: actor.code?.body,
+		kind: "named",
+		...actor.inputSchema ? { inputSchema: actor.inputSchema } : {},
+		...actor.outputSchema ? { outputSchema: actor.outputSchema } : {}
+	};
+}
+function fromActionSource(action) {
+	return {
+		id: action.id,
+		name: action.name,
+		description: action.description ?? null,
+		...action.icon ? { icon: action.icon } : {},
+		paramsSchema: action.paramsSchema ?? null,
+		...action.code ? { code: {
+			body: action.code,
+			...action.lang ? { lang: action.lang } : {}
+		} } : {}
+	};
+}
+function fromGuardSource(guard) {
+	return {
+		id: guard.id,
+		name: guard.name,
+		description: guard.description ?? null,
+		...guard.icon ? { icon: guard.icon } : {},
+		paramsSchema: guard.paramsSchema ?? null,
+		...guard.code ? { code: {
+			body: guard.code,
+			...guard.lang ? { lang: guard.lang } : {}
+		} } : {}
+	};
+}
+function fromActorSource(actor) {
+	return {
+		id: actor.id,
+		name: actor.name,
+		description: actor.description ?? null,
+		...actor.icon ? { icon: actor.icon } : {},
+		inputSchema: actor.inputSchema ?? null,
+		outputSchema: actor.outputSchema ?? null,
+		...actor.code ? { code: {
+			body: actor.code,
+			...actor.lang ? { lang: actor.lang } : {}
+		} } : {}
+	};
+}
+function toStudioAction(action) {
+	return {
+		kind: "named",
+		action: {
+			type: action.type,
+			...action.params && Object.keys(action.params).length > 0 ? { params: toJsonObject(action.params) } : {}
+		}
+	};
+}
+function fromStudioAction(action) {
+	if (action.kind === "inline") return {
+		type: "inline",
+		params: { expr: action.action.expr }
+	};
+	if ("params" in action.action && action.action.params) return {
+		type: action.action.type,
+		params: toUnknownRecord(action.action.params)
+	};
+	return { type: action.action.type };
+}
+function toStudioEventTypeData(eventType) {
+	if (eventType === "") return { type: "always" };
+	if (eventType === "*") return { type: "wildcard" };
+	if (eventType.startsWith("xstate.after.")) return {
+		type: "after",
+		delay: eventType.slice(13).split(".")[0] ?? ""
+	};
+	return {
+		type: "named",
+		eventType
+	};
+}
+function fromStudioEventTypeData(eventTypeData) {
+	switch (eventTypeData.type) {
+		case "always": return "";
+		case "wildcard": return "*";
+		case "after": return `xstate.after.${eventTypeData.delay ?? ""}`;
+		case "named": return eventTypeData.eventType ?? "";
+		case "invocation.done": return `xstate.done.actor.${eventTypeData.invocationId}`;
+		case "invocation.error": return `xstate.error.actor.${eventTypeData.invocationId}`;
+		case "state.done": return "xstate.done.state";
+		case "init": return "xstate.init";
+		default: return "";
+	}
+}
+function toStudioNode(graph, nodeId, pathIds, parentPath) {
+	const node = graph.nodes.find((candidate) => candidate.id === nodeId);
+	if (!node) throw new Error(`Node not found: ${nodeId}`);
+	const pathId = parentPath ? `${parentPath}.${node.data.key}` : node.data.key;
+	pathIds.set(node.id, pathId);
+	const childNodes = graph.nodes.filter((candidate) => candidate.parentId === node.id).map((child) => toStudioNode(graph, child.id, pathIds, pathId));
+	const initialKey = node.data.initialId ? graph.nodes.find((candidate) => candidate.id === node.data.initialId)?.data.key : void 0;
+	return {
+		id: pathId,
+		...node.x !== void 0 && node.y !== void 0 ? { position: {
+			x: node.x,
+			y: node.y
+		} } : {},
+		...node.width !== void 0 && node.height !== void 0 ? { size: {
+			width: node.width,
+			height: node.height
+		} } : {},
+		data: {
+			key: node.data.key,
+			...normalizeStudioNodeType(node.data.type) ? { type: normalizeStudioNodeType(node.data.type) } : {},
+			...normalizeStudioHistory(node.data.history) ? { history: normalizeStudioHistory(node.data.history) } : {},
+			...initialKey ? { initial: initialKey } : {},
+			entry: (node.data.entry ?? []).map(toStudioAction),
+			exit: (node.data.exit ?? []).map(toStudioAction),
+			invoke: (node.data.invokes ?? []).map((invoke) => ({
+				src: invoke.src,
+				id: invoke.id,
+				input: toJsonObject(invoke.input),
+				settings: {},
+				kind: invoke.src.startsWith("inline:") ? "inline" : "named"
+			})),
+			tags: node.data.tags ?? [],
+			...node.data.description ? { description: node.data.description } : {},
+			...node.data.color ? { color: toCanvasColor(node.data.color) } : {},
+			...node.data.meta ? { metaEntries: Object.entries(node.data.meta) } : {}
+		},
+		nodes: childNodes
+	};
+}
+function flattenStudioNodes(studioNode, parentId, nodes, pathIdToNodeId) {
+	const nodeId = studioNode.id;
+	pathIdToNodeId.set(studioNode.id, nodeId);
+	const initialId = studioNode.data.initial ? `${studioNode.id}.${studioNode.data.initial}` : void 0;
+	nodes.push({
+		type: "node",
+		id: nodeId,
+		parentId,
+		label: studioNode.data.key,
+		...initialId ? { initialNodeId: initialId } : {},
+		...studioNode.position ? {
+			x: studioNode.position.x,
+			y: studioNode.position.y
+		} : {},
+		...studioNode.size ? {
+			width: studioNode.size.width,
+			height: studioNode.size.height
+		} : {},
+		data: {
+			key: studioNode.data.key,
+			...normalizeStudioNodeType(studioNode.data.type) ? { type: normalizeStudioNodeType(studioNode.data.type) } : {},
+			...studioNode.data.history ? { history: studioNode.data.history } : {},
+			...initialId ? { initialId } : {},
+			entry: studioNode.data.entry.map(fromStudioAction),
+			exit: studioNode.data.exit.map(fromStudioAction),
+			invokes: studioNode.data.invoke.map((invoke) => ({
+				src: invoke.src,
+				id: invoke.id,
+				input: toUnknownRecord(invoke.input)
+			})),
+			tags: studioNode.data.tags,
+			...studioNode.data.description ? { description: studioNode.data.description } : {},
+			...studioNode.data.color ? { color: studioNode.data.color } : {},
+			...studioNode.data.metaEntries ? { meta: Object.fromEntries(studioNode.data.metaEntries) } : {}
+		}
+	});
+	studioNode.nodes.forEach((child) => flattenStudioNodes(child, nodeId, nodes, pathIdToNodeId));
+}
+function toStudioMachine(graph) {
+	const rootNode = graph.nodes.find((node) => node.parentId == null);
+	if (!rootNode) throw new Error("No root node found in graph");
+	const pathIds = /* @__PURE__ */ new Map();
+	const studioRootNode = toStudioNode(graph, rootNode.id, pathIds);
+	const edgeGroupCounts = /* @__PURE__ */ new Map();
+	const studioEdges = graph.edges.map((edge) => {
+		const source = pathIds.get(edge.sourceId) ?? edge.sourceId;
+		const target = edge.targetId ? pathIds.get(edge.targetId) ?? edge.targetId : void 0;
+		const eventType = edge.data.eventType;
+		const groupKey = `${source}:${eventType}`;
+		const index = edgeGroupCounts.get(groupKey) ?? 0;
+		edgeGroupCounts.set(groupKey, index + 1);
+		return {
+			id: `${source}#${eventType}[${index}]`,
+			source,
+			target: target && edge.data.transitionType !== "targetless" ? target : void 0,
+			...edge.x !== void 0 && edge.y !== void 0 ? { position: {
+				x: edge.x,
+				y: edge.y
+			} } : {},
+			...edge.width !== void 0 && edge.height !== void 0 ? { size: {
+				width: edge.width,
+				height: edge.height
+			} } : {},
+			data: {
+				eventTypeData: toStudioEventTypeData(eventType),
+				actions: (edge.data.actions ?? []).map(toStudioAction),
+				...edge.data.guard ? { guard: {
+					kind: edge.data.guard.code ? "inline" : "named",
+					type: edge.data.guard.type,
+					params: toJsonObject(edge.data.guard.params ?? {})
+				} } : {},
+				...edge.data.description ? { description: edge.data.description } : {},
+				...edge.data.transitionType === "reenter" ? { internal: false } : {},
+				...edge.data.color ? { color: toCanvasColor(edge.data.color) } : {},
+				...edge.data.meta ? { metaEntries: Object.entries(edge.data.meta) } : {}
+			}
+		};
+	});
+	return {
+		id: graph.id,
+		rootNode: studioRootNode,
+		edges: studioEdges,
+		context: {},
+		...graph.data?.schemas ? { schemas: normalizeSchemas(graph.data.schemas) } : {},
+		...graph.data?.implementations ? { implementations: {
+			actions: Object.fromEntries(graph.data.implementations.actions.map((action) => [action.name, toActionSource(action)])),
+			guards: Object.fromEntries(graph.data.implementations.guards.map((guard) => [guard.name, toGuardSource(guard)])),
+			actors: Object.fromEntries(graph.data.implementations.actors.map((actor) => [actor.name, toActorSource(actor)]))
+		} } : {}
+	};
+}
+function fromStudioMachine(studioMachine) {
+	const nodes = [];
+	const pathIdToNodeId = /* @__PURE__ */ new Map();
+	flattenStudioNodes(studioMachine.rootNode, null, nodes, pathIdToNodeId);
+	const edges = studioMachine.edges.map((edge) => ({
+		type: "edge",
+		id: edge.id,
+		sourceId: pathIdToNodeId.get(edge.source) ?? edge.source,
+		targetId: edge.target ? pathIdToNodeId.get(edge.target) ?? edge.target : pathIdToNodeId.get(edge.source) ?? edge.source,
+		label: fromStudioEventTypeData(edge.data.eventTypeData),
+		...edge.position ? {
+			x: edge.position.x,
+			y: edge.position.y
+		} : {},
+		...edge.size ? {
+			width: edge.size.width,
+			height: edge.size.height
+		} : {},
+		data: {
+			eventType: fromStudioEventTypeData(edge.data.eventTypeData),
+			transitionType: edge.target ? "normal" : "targetless",
+			...edge.data.guard ? { guard: {
+				type: edge.data.guard.type,
+				params: toUnknownRecord(edge.data.guard.params),
+				...edge.data.guard.kind === "inline" ? { code: edge.data.guard.type } : {}
+			} } : {},
+			actions: edge.data.actions.map(fromStudioAction),
+			...edge.data.description ? { description: edge.data.description } : {},
+			...edge.data.color ? { color: edge.data.color } : {},
+			...edge.data.metaEntries ? { meta: Object.fromEntries(edge.data.metaEntries) } : {}
+		}
+	}));
+	return createGraph({
+		id: studioMachine.id,
+		nodes: nodes.map(({ type: _type, initialNodeId, ...node }) => ({
+			...node,
+			...initialNodeId ? { initialNodeId } : {}
+		})),
+		edges: edges.map(({ type: _type, ...edge }) => edge),
+		data: {
+			...studioMachine.schemas ? { schemas: studioMachine.schemas } : {},
+			...studioMachine.implementations ? { implementations: {
+				actions: Object.values(studioMachine.implementations.actions).map(fromActionSource),
+				guards: Object.values(studioMachine.implementations.guards).map(fromGuardSource),
+				actors: Object.values(studioMachine.implementations.actors).map(fromActorSource),
+				delays: [],
+				tags: []
+			} } : {}
+		}
+	});
+}
+const studioMachineConverter = createFormatConverter(toStudioMachine, fromStudioMachine);
+
+//#endregion
+export { fromStudioMachine, studioMachineConverter, toStudioMachine };

package/dist/index.d.mts

@@ -1,45 +1,10 @@
-import { a as EmbedEventHandler, c as EmbedMode, d as ExportFormatMap, f as InitOptions, i as createInspector, l as ExportCallOptions, n as InspectOptions, o as EmbedEventMap, p as ProtocolMessage, r as Inspector, s as EmbedEventName, t as CreateInspectorOptions, u as ExportFormat } from "./inspect-Bt5Ohkrp.mjs";
+import { a as ExportCallOptions, c as InitOptions, i as EmbedMode, l as ProtocolMessage, n as EmbedEventMap, o as ExportFormat, r as EmbedEventName, s as ExportFormatMap, t as EmbedEventHandler } from "./protocol-DTIQmjHH.mjs";
+import { StatelyEmbed, StatelyEmbedOptions, createStatelyEmbed } from "./embed.mjs";
+import { C as EventTypeData, S as DigraphNodeConfig, _ as studioMachineConverter, a as StatelyGraphData, b as DigraphConfig, c as StatelyInvoke, d as StudioAction, f as StudioEdge, g as fromStudioMachine, h as StudioNode, i as StatelyGraph, l as StatelyNodeData, m as StudioMachine, o as StatelyGuard, r as StatelyEdgeData, t as StatelyAction, v as toStudioMachine, w as StateNodeJSONData, x as DigraphEdgeConfig, y as DigraphAction } from "./graph-BTUkUCsl.mjs";
+import { CreateInspectorOptions, InspectOptions, Inspector, createStatelyInspector } from "./inspect.mjs";
+import { ExtractMachinesResponse, ExtractedMachine, GetMachineOptions, ProjectData, ProjectMachine, StudioApiError, StudioClient, StudioClientOptions, VerifyApiKeyResponse, createStatelyClient } from "./studio.mjs";
+import { PlanSyncOptions, PullSyncResult, ResolvedSyncInput, SyncInputFormat, SyncPlan, SyncPlanSummary } from "./sync.mjs";
 
-//#region src/embed.d.ts
-interface StatelyEmbedOptions {
-  baseUrl: string;
-  apiKey?: string;
-  origin?: string;
-  onReady?: () => void;
-  onLoaded?: (graph: unknown) => void;
-  onChange?: (graph: unknown, machineConfig: unknown) => void;
-  onSave?: (graph: unknown, machineConfig: unknown) => void;
-  onError?: (error: {
-    code: string;
-    message: string;
-  }) => void;
-}
-interface StatelyEmbed {
-  /** Attach to an existing iframe element. Sets src and begins handshake. */
-  attach(iframe: HTMLIFrameElement): void;
-  /** Create an iframe and mount it into a container element. */
-  mount(container: HTMLElement): HTMLIFrameElement;
-  /** Send init message (queued if iframe not ready yet). */
-  init(options: InitOptions): void;
-  /** Update the machine (shorthand for update message). */
-  updateMachine(machine: unknown, format?: string): void;
-  /** Change the embed mode. */
-  setMode(mode: EmbedMode): void;
-  /** Change the embed theme. */
-  setTheme(theme: 'light' | 'dark'): void;
-  /** Export the current machine in a given format. Returns a promise. */
-  export<F extends ExportFormat>(format: F, options?: ExportCallOptions<F>): Promise<ExportFormatMap[F]['result']>;
-  /** Subscribe to an embed event. */
-  on<K extends EmbedEventName>(event: K, handler: EmbedEventHandler<K>): void;
-  /** Unsubscribe from an embed event. */
-  off<K extends EmbedEventName>(event: K, handler: EmbedEventHandler<K>): void;
-  /** Show a toast message in the embed. */
-  toast(message: string, toastType?: 'success' | 'error' | 'info' | 'warning'): void;
-  /** Tear down: remove listener, reject pending promises, optionally remove iframe. */
-  destroy(): void;
-}
-declare function createStatelyEmbed(options: StatelyEmbedOptions): StatelyEmbed;
-//#endregion
 //#region src/transport.d.ts
 interface Transport {
   send(msg: ProtocolMessage): void;
@@ -70,4 +35,4 @@ interface WebSocketTransportOptions {
 }
 declare function createWebSocketTransport(options: WebSocketTransportOptions): Transport;
 //#endregion
-export { type CreateInspectorOptions, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type InitOptions, type InspectOptions, type Inspector, type StatelyEmbed, type StatelyEmbedOptions, type Transport, createInspector, createPostMessageTransport, createStatelyEmbed, createWebSocketTransport };
+export { type CreateInspectorOptions, type DigraphAction, type DigraphConfig, type DigraphEdgeConfig, type DigraphNodeConfig, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type EventTypeData, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type ExtractMachinesResponse, type ExtractedMachine, type GetMachineOptions, type InitOptions, type InspectOptions, type Inspector, type PlanSyncOptions, type ProjectData, type ProjectMachine, type PullSyncResult, type ResolvedSyncInput, type StateNodeJSONData, type StatelyAction, type StatelyEdgeData, type StatelyEmbed, type StatelyEmbedOptions, type StatelyGraph, type StatelyGraphData, type StatelyGuard, type StatelyInvoke, type StatelyNodeData, type StudioAction, StudioApiError, type StudioClient, type StudioClientOptions, type StudioEdge, type StudioMachine, type StudioNode, type SyncInputFormat, type SyncPlan, type SyncPlanSummary, type Transport, type VerifyApiKeyResponse, createPostMessageTransport, createStatelyClient, createStatelyEmbed, createStatelyInspector, createWebSocketTransport, fromStudioMachine, studioMachineConverter, toStudioMachine };

package/dist/index.mjs

@@ -1,163 +1,7 @@
-import { a as createPendingExportManager, i as createEventRegistry, n as createPostMessageTransport, o as toInitMessage, r as createWebSocketTransport, t as createInspector } from "./inspect-C3Rjgn1o.mjs";
+import { n as createWebSocketTransport, t as createPostMessageTransport } from "./transport-D352iKKa.mjs";
+import { createStatelyEmbed } from "./embed.mjs";
+import { createStatelyInspector } from "./inspect.mjs";
+import { StudioApiError, createStatelyClient } from "./studio.mjs";
+import { fromStudioMachine, studioMachineConverter, toStudioMachine } from "./graph.mjs";
 
-//#region src/embed.ts
-function createStatelyEmbed(options) {
-	const base = options.baseUrl.replace(/\/+$/, "") + "/embed";
-	const embedUrl = options.apiKey ? `${base}?api_key=${encodeURIComponent(options.apiKey)}` : base;
-	const targetOrigin = options.origin ?? new URL(embedUrl).origin;
-	let iframe = null;
-	let transport = null;
-	let ownedIframe = false;
-	let destroyed = false;
-	const pendingMessages = [];
-	const events = createEventRegistry();
-	const exportManager = createPendingExportManager((message) => send(message));
-	function send(msg) {
-		if (!transport?.ready) {
-			pendingMessages.push(msg);
-			return;
-		}
-		transport.send(msg);
-	}
-	function flush() {
-		if (!transport) return;
-		while (pendingMessages.length > 0) {
-			const msg = pendingMessages.shift();
-			transport.send(msg);
-		}
-	}
-	function handleMessage(data) {
-		if (destroyed) return;
-		switch (data.type) {
-			case "@statelyai.ready":
-				flush();
-				options.onReady?.();
-				events.emit("ready", { version: data.version });
-				break;
-			case "@statelyai.loaded":
-				options.onLoaded?.(data.graph);
-				events.emit("loaded", { graph: data.graph });
-				break;
-			case "@statelyai.change":
-				options.onChange?.(data.graph, data.machineConfig);
-				events.emit("change", {
-					graph: data.graph,
-					machineConfig: data.machineConfig
-				});
-				break;
-			case "@statelyai.save":
-				options.onSave?.(data.graph, data.machineConfig);
-				events.emit("save", {
-					graph: data.graph,
-					machineConfig: data.machineConfig
-				});
-				break;
-			case "@statelyai.retrieved":
-				if (typeof data.requestId === "string") exportManager.resolve(data.requestId, data.data);
-				break;
-			case "@statelyai.error": {
-				const err = {
-					code: data.code,
-					message: data.message
-				};
-				exportManager.reject(new Error(err.message), typeof data.requestId === "string" ? data.requestId : void 0);
-				options.onError?.(err);
-				events.emit("error", err);
-				break;
-			}
-		}
-	}
-	function replaceTransport(nextTransport) {
-		transport?.destroy();
-		transport = nextTransport;
-	}
-	function setupTransport(el) {
-		replaceTransport(createPostMessageTransport({
-			iframe: el,
-			targetOrigin
-		}));
-		transport.onMessage(handleMessage);
-		transport.onReady(flush);
-	}
-	return {
-		attach(el) {
-			if (destroyed) return;
-			const currentSrc = el.getAttribute("src");
-			if (currentSrc && currentSrc !== "about:blank" && el.src !== embedUrl) console.warn("Replacing existing iframe src during attach()", {
-				currentSrc,
-				nextSrc: embedUrl
-			});
-			iframe = el;
-			ownedIframe = false;
-			el.src = embedUrl;
-			setupTransport(el);
-		},
-		mount(container) {
-			if (destroyed) throw new Error("Embed is destroyed");
-			const el = document.createElement("iframe");
-			el.src = embedUrl;
-			el.style.border = "none";
-			el.style.width = "100%";
-			el.style.height = "100%";
-			el.setAttribute("sandbox", "allow-scripts allow-same-origin");
-			el.setAttribute("allow", "clipboard-read; clipboard-write");
-			container.appendChild(el);
-			iframe = el;
-			ownedIframe = true;
-			setupTransport(el);
-			return el;
-		},
-		init(opts) {
-			send(toInitMessage(opts));
-		},
-		updateMachine(machine, format) {
-			send({
-				type: "@statelyai.update",
-				machine,
-				format
-			});
-		},
-		setMode(mode) {
-			send({
-				type: "@statelyai.setMode",
-				mode
-			});
-		},
-		setTheme(theme) {
-			send({
-				type: "@statelyai.setTheme",
-				theme
-			});
-		},
-		toast(message, toastType) {
-			send({
-				type: "@statelyai.toast",
-				message,
-				toastType
-			});
-		},
-		export(format, callOptions) {
-			return exportManager.start(format, callOptions, "Embed is destroyed", () => destroyed);
-		},
-		on(event, handler) {
-			events.on(event, handler);
-		},
-		off(event, handler) {
-			events.off(event, handler);
-		},
-		destroy() {
-			if (destroyed) return;
-			destroyed = true;
-			transport?.destroy();
-			transport = null;
-			exportManager.clear("Embed destroyed");
-			events.clear();
-			pendingMessages.length = 0;
-			if (ownedIframe && iframe) iframe.remove();
-			iframe = null;
-		}
-	};
-}
-
-//#endregion
-export { createInspector, createPostMessageTransport, createStatelyEmbed, createWebSocketTransport };
+export { StudioApiError, createPostMessageTransport, createStatelyClient, createStatelyEmbed, createStatelyInspector, createWebSocketTransport, fromStudioMachine, studioMachineConverter, toStudioMachine };

package/dist/inspect.d.mts

@@ -1,2 +1,45 @@
-import { a as EmbedEventHandler, c as EmbedMode, d as ExportFormatMap, f as InitOptions, i as createInspector, l as ExportCallOptions, n as InspectOptions, o as EmbedEventMap, r as Inspector, s as EmbedEventName, t as CreateInspectorOptions, u as ExportFormat } from "./inspect-Bt5Ohkrp.mjs";
-export { CreateInspectorOptions, EmbedEventHandler, EmbedEventMap, EmbedEventName, EmbedMode, ExportCallOptions, ExportFormat, ExportFormatMap, InitOptions, InspectOptions, Inspector, createInspector };
+import { a as ExportCallOptions, c as InitOptions, i as EmbedMode, n as EmbedEventMap, o as ExportFormat, r as EmbedEventName, s as ExportFormatMap, t as EmbedEventHandler } from "./protocol-DTIQmjHH.mjs";
+
+//#region src/inspect.d.ts
+interface CreateInspectorOptions {
+  /** WebSocket URL of the devtools server. Default: 'ws://localhost:4242' */
+  url?: string;
+  /** Auto-open browser to visualizer. Default: true */
+  autoOpen?: boolean;
+  /** Unique session ID. Auto-generated if not provided. */
+  sessionId?: string;
+  /** Display name for this connection in the visualizer. */
+  name?: string;
+}
+interface Inspector {
+  /** Send a machine for inspection (starts visualization). */
+  inspect(options: InspectOptions): void;
+  /** Update the machine currently being inspected. */
+  update(machine: unknown, format?: string): void;
+  /** Change the visualization mode. */
+  setMode(mode: EmbedMode): void;
+  /** Export the current machine in a given format. Returns a promise. */
+  export<F extends ExportFormat>(format: F, options?: ExportCallOptions<F>): Promise<ExportFormatMap[F]['result']>;
+  /** Subscribe to events from the visualizer. */
+  on<K extends EmbedEventName>(event: K, handler: EmbedEventHandler<K>): void;
+  /** Unsubscribe from an event. */
+  off<K extends EmbedEventName>(event: K, handler: EmbedEventHandler<K>): void;
+  /** Send a state snapshot for real-time inspection. */
+  sendSnapshot(snapshot: unknown, event?: unknown): void;
+  /** Clean up the connection. */
+  destroy(): void;
+  /** Session ID for this connection. */
+  readonly sessionId: string;
+}
+interface InspectOptions {
+  machine: unknown;
+  format?: string;
+  mode?: EmbedMode;
+  theme?: 'light' | 'dark';
+  readOnly?: boolean;
+  depth?: number;
+  panels?: InitOptions['panels'];
+}
+declare function createStatelyInspector(options?: CreateInspectorOptions): Inspector;
+//#endregion
+export { CreateInspectorOptions, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type InitOptions, InspectOptions, Inspector, createStatelyInspector };