@statelyai/sdk 0.1.1 → 0.3.0

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,111 +1,38 @@
-//#region src/embed.d.ts
-interface ExportFormatMap {
-  xstate: {
-    options: {
-      version?: 4 | 5;
-      addTSTypes?: boolean;
-      showIds?: boolean;
-      showDescriptions?: boolean;
-    };
-    result: string;
-  };
-  json: {
-    options: {
-      simplifyArrays?: boolean;
-      version?: 4 | 5;
-    };
-    result: Record<string, unknown>;
-  };
-  digraph: {
-    options: Record<string, never>;
-    result: Record<string, unknown>;
-  };
-  mermaid: {
-    options: Record<string, never>;
-    result: string;
-  };
-  scxml: {
-    options: Record<string, never>;
-    result: string;
-  };
-}
-type ExportFormat = keyof ExportFormatMap;
-type ExportCallOptions<F extends ExportFormat> = ExportFormatMap[F]['options'] & {
-  timeout?: number;
-};
-type EmbedMode = 'editing' | 'viewing' | 'simulating';
-interface InitOptions {
-  machine: unknown;
-  format?: string;
-  mode?: EmbedMode;
-  theme?: 'light' | 'dark';
-  readOnly?: boolean;
-  depth?: number;
-  panels?: {
-    leftPanels?: string[];
-    rightPanels?: string[];
-    activePanels?: string[];
-  };
-}
-interface EmbedEventMap {
-  ready: {
-    version: string;
-  };
-  loaded: {
-    graph: unknown;
-  };
-  change: {
-    graph: unknown;
-    machineConfig: unknown;
-  };
-  save: {
-    graph: unknown;
-    machineConfig: unknown;
-  };
-  error: {
-    code: string;
-    message: string;
-  };
+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-BC-_s3if.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-C-7ZK_nK.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, planSync, pullSync } from "./sync.mjs";
+
+//#region src/transport.d.ts
+interface Transport {
+  send(msg: ProtocolMessage): void;
+  onMessage(handler: (msg: ProtocolMessage) => void): () => void;
+  destroy(): void;
+  readonly ready: boolean;
+  onReady(handler: () => void): () => void;
 }
-type EmbedEventName = keyof EmbedEventMap;
-type EmbedEventHandler<K extends EmbedEventName> = (data: EmbedEventMap[K]) => void;
-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 PostMessageTransportOptions {
+  iframe: HTMLIFrameElement;
+  targetOrigin: string;
+  /** Filter by source. Defaults to iframe.contentWindow. */
+  source?: Window;
 }
-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 createPostMessageTransport(options: PostMessageTransportOptions): Transport;
+interface WebSocketTransportOptions {
+  url: string;
+  role: 'client' | 'viz';
+  sessionId: string;
+  metadata?: {
+    name?: string;
+    machineId?: string;
+  };
+  /** Reconnect on disconnect. Default true. */
+  reconnect?: boolean;
+  /** Max reconnect attempts. Default 10. */
+  maxReconnectAttempts?: number;
 }
-declare function createStatelyEmbed(options: StatelyEmbedOptions): StatelyEmbed;
+declare function createWebSocketTransport(options: WebSocketTransportOptions): Transport;
 //#endregion
-export { type EmbedEventMap, type EmbedMode, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type InitOptions, type StatelyEmbed, type StatelyEmbedOptions, createStatelyEmbed };
+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, planSync, pullSync, studioMachineConverter, toStudioMachine };

package/dist/index.mjs

@@ -1,201 +1,8 @@
-//#region src/embed.ts
-const PREFIX = "@statelyai.";
-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 ownedIframe = false;
-	let ready = false;
-	let destroyed = false;
-	const pendingMessages = [];
-	let pendingExport = null;
-	const jsonResultFormats = new Set(["digraph", "json"]);
-	const listeners = {};
-	function emit(event, data) {
-		const set = listeners[event];
-		if (set) set.forEach((fn) => fn(data));
-	}
-	function send(msg) {
-		if (!ready) {
-			pendingMessages.push(msg);
-			return;
-		}
-		iframe?.contentWindow?.postMessage(msg, targetOrigin);
-	}
-	function flush() {
-		while (pendingMessages.length > 0) {
-			const msg = pendingMessages.shift();
-			iframe?.contentWindow?.postMessage(msg, targetOrigin);
-		}
-	}
-	function handleMessage(e) {
-		if (destroyed) return;
-		if (e.source !== iframe?.contentWindow) return;
-		const data = e.data;
-		if (!data?.type?.startsWith?.(PREFIX)) return;
-		switch (data.type) {
-			case "@statelyai.ready":
-				ready = true;
-				flush();
-				options.onReady?.();
-				emit("ready", { version: data.version });
-				break;
-			case "@statelyai.loaded":
-				options.onLoaded?.(data.graph);
-				emit("loaded", { graph: data.graph });
-				break;
-			case "@statelyai.change":
-				options.onChange?.(data.graph, data.machineConfig);
-				emit("change", {
-					graph: data.graph,
-					machineConfig: data.machineConfig
-				});
-				break;
-			case "@statelyai.save":
-				options.onSave?.(data.graph, data.machineConfig);
-				emit("save", {
-					graph: data.graph,
-					machineConfig: data.machineConfig
-				});
-				break;
-			case "@statelyai.retrieved":
-				if (pendingExport) {
-					clearTimeout(pendingExport.timer);
-					let result = data.data;
-					if (jsonResultFormats.has(pendingExport.format) && typeof result === "string") result = JSON.parse(result);
-					pendingExport.resolve(result);
-					pendingExport = null;
-				}
-				break;
-			case "@statelyai.error": {
-				const err = {
-					code: data.code,
-					message: data.message
-				};
-				options.onError?.(err);
-				emit("error", err);
-				break;
-			}
-		}
-	}
-	function startListening() {
-		window.addEventListener("message", handleMessage);
-	}
-	return {
-		attach(el) {
-			if (destroyed) return;
-			iframe = el;
-			ownedIframe = false;
-			ready = false;
-			el.src = embedUrl;
-			startListening();
-		},
-		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;
-			ready = false;
-			startListening();
-			return el;
-		},
-		init(opts) {
-			send({
-				type: "@statelyai.init",
-				machine: opts.machine,
-				format: opts.format,
-				mode: opts.mode,
-				theme: opts.theme,
-				readOnly: opts.readOnly,
-				depth: opts.depth,
-				leftPanels: opts.panels?.leftPanels,
-				rightPanels: opts.panels?.rightPanels,
-				activePanels: opts.panels?.activePanels
-			});
-		},
-		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, options) {
-			const { timeout = 1e4, ...formatOptions } = options ?? {};
-			return new Promise((resolve, reject) => {
-				if (destroyed) {
-					reject(/* @__PURE__ */ new Error("Embed is destroyed"));
-					return;
-				}
-				if (pendingExport) {
-					clearTimeout(pendingExport.timer);
-					pendingExport.reject(/* @__PURE__ */ new Error("Superseded by new export"));
-				}
-				pendingExport = {
-					resolve,
-					reject,
-					timer: setTimeout(() => {
-						pendingExport = null;
-						reject(/* @__PURE__ */ new Error("Export timed out"));
-					}, timeout),
-					format
-				};
-				send({
-					type: "@statelyai.retrieve",
-					format,
-					...Object.keys(formatOptions).length > 0 && { options: formatOptions }
-				});
-			});
-		},
-		on(event, handler) {
-			if (!listeners[event]) listeners[event] = /* @__PURE__ */ new Set();
-			listeners[event].add(handler);
-		},
-		off(event, handler) {
-			listeners[event]?.delete(handler);
-		},
-		destroy() {
-			if (destroyed) return;
-			destroyed = true;
-			window.removeEventListener("message", handleMessage);
-			if (pendingExport) {
-				clearTimeout(pendingExport.timer);
-				pendingExport.reject(/* @__PURE__ */ new Error("Embed destroyed"));
-				pendingExport = null;
-			}
-			pendingMessages.length = 0;
-			if (ownedIframe && iframe) iframe.remove();
-			iframe = null;
-		}
-	};
-}
+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";
+import { n as pullSync, t as planSync } from "./sync-CzEOizjx.mjs";
 
-//#endregion
-export { createStatelyEmbed };
+export { StudioApiError, createPostMessageTransport, createStatelyClient, createStatelyEmbed, createStatelyInspector, createWebSocketTransport, fromStudioMachine, planSync, pullSync, studioMachineConverter, toStudioMachine };