@statelyai/sdk 0.10.1 → 0.11.0

package/dist/sync.mjs

@@ -1,5 +1,5 @@
 import { createStatelyClient } from "./studio.mjs";
-import { d as upsertStatelyPragma, l as findStatelyPragmaAttachments, t as graphToXStateTS, u as getStatelyPragma } from "./graphToXStateTS-moihsH_U.mjs";
+import { S as upsertStatelyPragma, _ as string, b as findStatelyPragmaAttachments, d as boolean, f as discriminatedUnion, g as record, h as object, l as _enum, m as number, p as literal, t as graphToXStateTS, u as array, v as union, x as getStatelyPragma, y as unknown } from "./graphToXStateTS-DV62vO_d.mjs";
 import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
@@ -11,6 +11,8 @@ import { promisify } from "node:util";
 import * as fs$1 from "fs";
 import * as path$1 from "path";
 import { fileURLToPath, pathToFileURL } from "url";
+import { createMachine, transition } from "xstate";
+import { getShortestPaths, getSimplePaths } from "xstate/graph";
 
 //#region ../editor-sync/src/fs.ts
 function createTextDocument(fileName, text, uri = path$1.isAbsolute(fileName) ? pathToFileURL(fileName).toString() : fileName) {
@@ -107,11 +109,3095 @@ function getLineStarts(text) {
 	return lineStarts;
 }
 
+//#endregion
+//#region ../graph-tools/dist/index.mjs
+function summarizeGraphDiff(diff) {
+	return {
+		hasChanges: !isEmptyDiff(diff),
+		nodeChanges: diff.nodes.added.length + diff.nodes.removed.length + diff.nodes.updated.length,
+		edgeChanges: diff.edges.added.length + diff.edges.removed.length + diff.edges.updated.length
+	};
+}
+function nodeDepth(graph, node) {
+	let depth = 0;
+	let parentId = node.parentId;
+	while (parentId) {
+		depth++;
+		parentId = graph.nodes.find((candidate) => candidate.id === parentId)?.parentId;
+	}
+	return depth;
+}
+function getStableNodeId(node, parentStableId, siblingIndex) {
+	if (node.parentId === null) return "root";
+	const key = node.data.key || node.id;
+	const suffix = siblingIndex === 0 ? key : `${key}_${siblingIndex + 1}`;
+	return parentStableId ? `${parentStableId}.${suffix}` : suffix;
+}
+function getStableEdgeId(edge, siblingIndex) {
+	const suffix = siblingIndex === 0 ? "" : `.${siblingIndex + 1}`;
+	return [
+		edge.sourceId,
+		edge.data.eventType,
+		edge.targetId,
+		edge.data.guard?.type ?? ""
+	].join("->").concat(suffix);
+}
+function normalizeGraphForSemanticDiff(graph) {
+	const normalized = structuredClone(graph);
+	const nodeIdMap = /* @__PURE__ */ new Map();
+	const siblingKeys = /* @__PURE__ */ new Map();
+	const nodesByDepth = [...normalized.nodes].sort((a, b) => nodeDepth(normalized, a) - nodeDepth(normalized, b));
+	for (const node of nodesByDepth) {
+		const parentStableId = node.parentId ? nodeIdMap.get(node.parentId) ?? node.parentId : null;
+		const key = `${parentStableId ?? ""}:${node.data.key || node.id}`;
+		const siblingIndex = siblingKeys.get(key) ?? 0;
+		siblingKeys.set(key, siblingIndex + 1);
+		nodeIdMap.set(node.id, getStableNodeId(node, parentStableId, siblingIndex));
+	}
+	for (const node of normalized.nodes) {
+		node.id = nodeIdMap.get(node.id) ?? node.id;
+		if (node.parentId) node.parentId = nodeIdMap.get(node.parentId) ?? node.parentId;
+		if (node.initialNodeId) node.initialNodeId = nodeIdMap.get(node.initialNodeId) ?? node.initialNodeId;
+		if (node.data.initialId) node.data.initialId = nodeIdMap.get(node.data.initialId) ?? node.data.initialId;
+	}
+	const edgeSiblingKeys = /* @__PURE__ */ new Map();
+	for (const edge of normalized.edges) {
+		edge.sourceId = nodeIdMap.get(edge.sourceId) ?? edge.sourceId;
+		edge.targetId = nodeIdMap.get(edge.targetId) ?? edge.targetId;
+		const key = [
+			edge.sourceId,
+			edge.data.eventType,
+			edge.targetId,
+			edge.data.guard?.type ?? ""
+		].join("->");
+		const siblingIndex = edgeSiblingKeys.get(key) ?? 0;
+		edgeSiblingKeys.set(key, siblingIndex + 1);
+		edge.id = getStableEdgeId(edge, siblingIndex);
+	}
+	if (normalized.initialNodeId) normalized.initialNodeId = nodeIdMap.get(normalized.initialNodeId) ?? normalized.initialNodeId;
+	return normalized;
+}
+function diffGraphsSemantically(baseGraph, compareGraph) {
+	const base = normalizeGraphForSemanticDiff(baseGraph);
+	const compare = normalizeGraphForSemanticDiff(compareGraph);
+	const diff = getDiff(base, compare);
+	return {
+		base,
+		compare,
+		diff,
+		summary: summarizeGraphDiff(diff)
+	};
+}
+function hasEntityId(graph, id) {
+	return graph.nodes.some((node) => node.id === id) || graph.edges.some((edge) => edge.id === id);
+}
+function uniqueId(graph, prefix, preferred) {
+	if (preferred && !hasEntityId(graph, preferred)) return preferred;
+	let index = 1;
+	let id = `${prefix}${index}`;
+	while (hasEntityId(graph, id)) {
+		index++;
+		id = `${prefix}${index}`;
+	}
+	return id;
+}
+function resolveLocation(location, resolve) {
+	return "nodeId" in location ? {
+		...location,
+		nodeId: resolve(location.nodeId)
+	} : {
+		...location,
+		edgeId: resolve(location.edgeId)
+	};
+}
+function getActionArray(graph, location) {
+	if ("nodeId" in location) {
+		const node = graph.nodes.find((candidate) => candidate.id === location.nodeId);
+		return node ? node.data[location.group] : null;
+	}
+	return graph.edges.find((candidate) => candidate.id === location.edgeId)?.data.actions ?? null;
+}
+function hasActionId(graph, id) {
+	for (const node of graph.nodes) {
+		if (node.data.entry.some((action) => action.id === id)) return true;
+		if (node.data.exit.some((action) => action.id === id)) return true;
+	}
+	for (const edge of graph.edges) if (edge.data.actions.some((action) => action.id === id)) return true;
+	return false;
+}
+function hasInvokeId(graph, id) {
+	return graph.nodes.some((node) => node.data.invokes.some((invoke) => invoke.id === id));
+}
+function createNodeInGraph(graph, opts) {
+	if (hasEntityId(graph, opts.id)) return;
+	const parentNode = graph.nodes.find((node) => node.id === opts.parentId);
+	if (!parentNode) return;
+	graph.nodes.push({
+		type: "node",
+		id: opts.id,
+		parentId: opts.parentId,
+		position: {
+			x: opts.x ?? 0,
+			y: opts.y ?? 0
+		},
+		x: opts.x ?? 0,
+		y: opts.y ?? 0,
+		width: 0,
+		height: 0,
+		dx: 0,
+		dy: 0,
+		label: opts.key,
+		data: {
+			key: opts.key,
+			type: opts.type ?? null,
+			history: false,
+			entry: [],
+			exit: [],
+			meta: null,
+			tags: [],
+			description: void 0,
+			initialId: null,
+			invokes: []
+		}
+	});
+	if (!parentNode.data.initialId) {
+		parentNode.data.initialId = opts.id;
+		parentNode.initialNodeId = opts.id;
+	}
+}
+function updateNodeInGraph(graph, nodeId, data) {
+	const node = graph.nodes.find((candidate) => candidate.id === nodeId);
+	if (!node) return;
+	if (data.key !== void 0) {
+		data.key = data.key.trim();
+		node.label = data.key;
+	}
+	if (data.initialId !== void 0) node.initialNodeId = data.initialId;
+	Object.assign(node.data, data);
+}
+function createEdgeInGraph(graph, opts) {
+	if (hasEntityId(graph, opts.id)) return;
+	const sourceNode = graph.nodes.find((node) => node.id === opts.sourceId);
+	if (!sourceNode) return;
+	graph.edges.push({
+		type: "edge",
+		id: opts.id,
+		sourceId: opts.sourceId,
+		targetId: opts.targetId,
+		label: opts.eventType,
+		position: {
+			x: sourceNode.position?.x ?? sourceNode.x ?? 0,
+			y: (sourceNode.position?.y ?? sourceNode.y ?? 0) + (sourceNode.height ?? 0) + 60
+		},
+		x: sourceNode.position?.x ?? sourceNode.x ?? 0,
+		y: (sourceNode.position?.y ?? sourceNode.y ?? 0) + (sourceNode.height ?? 0) + 60,
+		width: 0,
+		height: 0,
+		dx: 0,
+		dy: 0,
+		data: {
+			eventType: opts.eventType,
+			transitionType: opts.transitionType ?? "normal",
+			guard: null,
+			description: null,
+			actions: [],
+			meta: null
+		}
+	});
+}
+function updateEdgeInGraph(graph, edgeId, data) {
+	const edge = graph.edges.find((candidate) => candidate.id === edgeId);
+	if (!edge) return;
+	if (data.sourceId !== void 0) edge.sourceId = data.sourceId;
+	if (data.targetId !== void 0) edge.targetId = data.targetId;
+	if (data.eventType !== void 0) {
+		data.eventType = data.eventType.trim();
+		edge.label = data.eventType;
+	}
+	const { sourceId: _sourceId, targetId: _targetId, ...edgeData } = data;
+	Object.assign(edge.data, edgeData);
+}
+function deleteEdgeFromGraph(graph, edgeId) {
+	const index = graph.edges.findIndex((edge) => edge.id === edgeId);
+	if (index >= 0) graph.edges.splice(index, 1);
+}
+function deleteEntitiesFromGraph(graph, entityIds) {
+	const deletedNodeIds = /* @__PURE__ */ new Set();
+	const nodesToDelete = /* @__PURE__ */ new Set();
+	for (const id of entityIds) {
+		const node = graph.nodes.find((candidate) => candidate.id === id);
+		if (node && node.parentId !== null) {
+			nodesToDelete.add(id);
+			const collectDescendants = (parentId) => {
+				for (const child of graph.nodes) if (child.parentId === parentId && !nodesToDelete.has(child.id)) {
+					nodesToDelete.add(child.id);
+					collectDescendants(child.id);
+				}
+			};
+			collectDescendants(id);
+		}
+	}
+	for (const id of nodesToDelete) {
+		const index = graph.nodes.findIndex((node) => node.id === id);
+		if (index === -1) continue;
+		const nodeToDelete = graph.nodes[index];
+		const parentNode = graph.nodes.find((node) => node.id === nodeToDelete.parentId);
+		graph.nodes.splice(index, 1);
+		deletedNodeIds.add(id);
+		if (parentNode && parentNode.data.initialId === id) {
+			const childNodes = graph.nodes.filter((node) => node.parentId === parentNode.id);
+			parentNode.data.initialId = childNodes[0]?.id ?? null;
+			parentNode.initialNodeId = parentNode.data.initialId;
+		}
+	}
+	graph.edges = graph.edges.filter((edge) => !entityIds.has(edge.id) && !deletedNodeIds.has(edge.sourceId) && !deletedNodeIds.has(edge.targetId));
+	graph.annotations = graph.annotations.filter((annotation) => !entityIds.has(annotation.id));
+}
+function ensureImplementations(graph) {
+	graph.data.implementations ??= {
+		actions: [],
+		guards: [],
+		actors: [],
+		delays: [],
+		tags: []
+	};
+	return graph.data.implementations;
+}
+function implementationList(graph, sourceType) {
+	const implementations = ensureImplementations(graph);
+	if (sourceType === "action") return implementations.actions;
+	if (sourceType === "guard") return implementations.guards;
+	if (sourceType === "actor") return implementations.actors;
+	return implementations.delays;
+}
+function applyGraphPatches(graph, patches) {
+	const nextGraph = structuredClone(graph);
+	const idMap = /* @__PURE__ */ new Map();
+	const resolve = (id) => idMap.get(id) ?? id;
+	for (const patch of patches) switch (patch.op) {
+		case "createState": {
+			const realId = uniqueId(nextGraph, "node-", patch.id);
+			if (patch.id) idMap.set(patch.id, realId);
+			createNodeInGraph(nextGraph, {
+				id: realId,
+				parentId: resolve(patch.parentId),
+				key: patch.key,
+				x: patch.x,
+				y: patch.y,
+				type: patch.type
+			});
+			const node = nextGraph.nodes.find((candidate) => candidate.id === realId);
+			if (node) {
+				if (patch.color !== void 0) node.data.color = patch.color ?? void 0;
+				if (patch.initial) {
+					const parentNode = nextGraph.nodes.find((candidate) => candidate.id === node.parentId);
+					if (parentNode) {
+						parentNode.data.initialId = realId;
+						parentNode.initialNodeId = realId;
+					}
+				}
+			}
+			break;
+		}
+		case "updateState": {
+			const nodeData = {};
+			if (patch.key !== void 0) nodeData.key = patch.key;
+			if (patch.type !== void 0) nodeData.type = patch.type;
+			if (patch.stateDescription !== void 0) nodeData.description = patch.stateDescription;
+			if (patch.initialId !== void 0) nodeData.initialId = patch.initialId ? resolve(patch.initialId) : patch.initialId;
+			if (patch.color !== void 0) nodeData.color = patch.color ?? void 0;
+			if (patch.meta !== void 0) nodeData.meta = patch.meta;
+			if (patch.history !== void 0) nodeData.history = patch.history === null ? false : patch.history;
+			updateNodeInGraph(nextGraph, resolve(patch.stateId), nodeData);
+			break;
+		}
+		case "deleteState":
+			deleteEntitiesFromGraph(nextGraph, new Set([resolve(patch.stateId)]));
+			break;
+		case "createTransition": {
+			const realId = uniqueId(nextGraph, "edge-", patch.id);
+			if (patch.id) idMap.set(patch.id, realId);
+			createEdgeInGraph(nextGraph, {
+				id: realId,
+				sourceId: resolve(patch.sourceId),
+				targetId: resolve(patch.targetId),
+				eventType: patch.eventType,
+				transitionType: patch.transitionType
+			});
+			const edge = nextGraph.edges.find((candidate) => candidate.id === realId);
+			if (edge) {
+				if (patch.guard) edge.data.guard = patch.guard;
+				if (patch.color !== void 0) edge.data.color = patch.color ?? void 0;
+				if (patch.transitionDescription !== void 0) edge.data.description = patch.transitionDescription;
+			}
+			break;
+		}
+		case "updateTransition": {
+			const edgeData = {};
+			if (patch.sourceId !== void 0) edgeData.sourceId = resolve(patch.sourceId);
+			if (patch.targetId !== void 0) edgeData.targetId = resolve(patch.targetId);
+			if (patch.eventType !== void 0) edgeData.eventType = patch.eventType;
+			if (patch.transitionType !== void 0) edgeData.transitionType = patch.transitionType;
+			if (patch.transitionDescription !== void 0) edgeData.description = patch.transitionDescription;
+			if (patch.color !== void 0) edgeData.color = patch.color ?? void 0;
+			if (patch.meta !== void 0) edgeData.meta = patch.meta;
+			updateEdgeInGraph(nextGraph, resolve(patch.transitionId), edgeData);
+			break;
+		}
+		case "deleteTransition":
+			deleteEdgeFromGraph(nextGraph, resolve(patch.transitionId));
+			break;
+		case "createAction": {
+			const realId = patch.action.id ? uniqueId(nextGraph, "action-", patch.action.id) : `action-${Math.max(1, patches.indexOf(patch) + 1)}`;
+			if (patch.action.id) idMap.set(patch.action.id, realId);
+			if (!patch.action.type.trim()) break;
+			if (hasActionId(nextGraph, realId)) break;
+			const actions = getActionArray(nextGraph, resolveLocation(patch.location, resolve));
+			if (!actions) break;
+			const action = {
+				...patch.action,
+				id: realId,
+				params: patch.action.params ?? {}
+			};
+			if (patch.index !== void 0) actions.splice(patch.index, 0, action);
+			else actions.push(action);
+			break;
+		}
+		case "updateAction": {
+			const action = getActionArray(nextGraph, resolveLocation(patch.location, resolve))?.find((candidate) => candidate.id === resolve(patch.actionId));
+			if (action) Object.assign(action, patch.data);
+			break;
+		}
+		case "deleteAction": {
+			const actions = getActionArray(nextGraph, resolveLocation(patch.location, resolve));
+			if (!actions) break;
+			const index = actions.findIndex((candidate) => candidate.id === resolve(patch.actionId));
+			if (index >= 0) actions.splice(index, 1);
+			break;
+		}
+		case "createInvoke": {
+			const realId = patch.invoke.id ? uniqueId(nextGraph, "invoke-", patch.invoke.id) : `invoke-${Math.max(1, patches.indexOf(patch) + 1)}`;
+			if (patch.invoke.id) idMap.set(patch.invoke.id, realId);
+			if (!patch.invoke.src.trim()) break;
+			if (hasInvokeId(nextGraph, realId)) break;
+			nextGraph.nodes.find((candidate) => candidate.id === resolve(patch.nodeId))?.data.invokes.push({
+				...patch.invoke,
+				id: realId
+			});
+			break;
+		}
+		case "updateInvoke": {
+			const invoke = nextGraph.nodes.find((candidate) => candidate.id === resolve(patch.nodeId))?.data.invokes.find((candidate) => candidate.id === resolve(patch.invokeId));
+			if (invoke) Object.assign(invoke, patch.data);
+			break;
+		}
+		case "deleteInvoke": {
+			const node = nextGraph.nodes.find((candidate) => candidate.id === resolve(patch.nodeId));
+			if (!node) break;
+			const index = node.data.invokes.findIndex((candidate) => candidate.id === resolve(patch.invokeId));
+			if (index >= 0) node.data.invokes.splice(index, 1);
+			break;
+		}
+		case "createImplementation": {
+			const code = patch.implementation.code;
+			const base = {
+				id: patch.implementation.id,
+				name: patch.implementation.name ?? patch.implementation.id,
+				description: null,
+				code: code ? {
+					body: code,
+					lang: "ts",
+					deps: {}
+				} : null
+			};
+			implementationList(nextGraph, patch.sourceType).push(patch.sourceType === "actor" ? {
+				...base,
+				inputSchema: null,
+				outputSchema: null
+			} : {
+				...base,
+				paramsSchema: null
+			});
+			break;
+		}
+		case "updateImplementation": {
+			const item = implementationList(nextGraph, patch.sourceType).find((implementation) => implementation.id === resolve(patch.implementationId));
+			if (!item) break;
+			if (patch.data.name !== void 0) {
+				item.name = patch.data.name;
+				item.id = patch.data.name;
+			}
+			if (patch.data.code !== void 0) item.code = {
+				body: patch.data.code,
+				lang: "ts",
+				deps: {}
+			};
+			break;
+		}
+		case "deleteImplementation": {
+			const list = implementationList(nextGraph, patch.sourceType);
+			const index = list.findIndex((implementation) => implementation.id === resolve(patch.implementationId));
+			if (index >= 0) list.splice(index, 1);
+			break;
+		}
+		case "setGuard": {
+			if (!patch.guard.type.trim()) break;
+			const edge = nextGraph.edges.find((candidate) => candidate.id === resolve(patch.edgeId));
+			if (edge) edge.data.guard = patch.guard;
+			break;
+		}
+		case "deleteGuard": {
+			const edge = nextGraph.edges.find((candidate) => candidate.id === resolve(patch.edgeId));
+			if (edge) edge.data.guard = null;
+			break;
+		}
+		case "createTag": {
+			const node = nextGraph.nodes.find((candidate) => candidate.id === resolve(patch.nodeId));
+			if (node && !node.data.tags.some((tag) => tag.name === patch.tag.name)) node.data.tags.push(patch.tag);
+			break;
+		}
+		case "deleteTag": {
+			const node = nextGraph.nodes.find((candidate) => candidate.id === resolve(patch.nodeId));
+			if (!node) break;
+			const index = node.data.tags.findIndex((tag) => tag.name === patch.tagName);
+			if (index >= 0) node.data.tags.splice(index, 1);
+			break;
+		}
+		case "createAnnotation": {
+			const realId = uniqueId(nextGraph, "annotation-", patch.id);
+			if (patch.id) idMap.set(patch.id, realId);
+			nextGraph.annotations.push({
+				type: "node",
+				id: realId,
+				parentId: patch.parentId,
+				position: {
+					x: patch.x ?? 0,
+					y: patch.y ?? 0
+				},
+				x: patch.x ?? 0,
+				y: patch.y ?? 0,
+				dx: 0,
+				dy: 0,
+				width: 0,
+				height: 0,
+				content: patch.content,
+				data: { referenceIds: [] }
+			});
+			break;
+		}
+		case "updateAnnotation": {
+			const annotation = nextGraph.annotations.find((candidate) => candidate.id === resolve(patch.annotationId));
+			if (annotation && patch.data.content !== void 0) annotation.content = patch.data.content;
+			break;
+		}
+		case "deleteAnnotation":
+			deleteEntitiesFromGraph(nextGraph, new Set([resolve(patch.annotationId)]));
+			break;
+		case "setContext":
+			nextGraph.data.context = patch.context;
+			break;
+		case "updateSchemas":
+			nextGraph.data.schemas ??= {
+				context: null,
+				events: null,
+				input: null,
+				output: null
+			};
+			if (patch.schemas.context !== void 0) nextGraph.data.schemas.context = patch.schemas.context;
+			if (patch.schemas.events !== void 0) nextGraph.data.schemas.events = patch.schemas.events;
+			if (patch.schemas.input !== void 0) nextGraph.data.schemas.input = patch.schemas.input;
+			if (patch.schemas.output !== void 0) nextGraph.data.schemas.output = patch.schemas.output;
+			break;
+	}
+	return nextGraph;
+}
+function isAutoGeneratedId(id) {
+	return !!id && id.startsWith("$auto-");
+}
+function getAuthoredNodeId(node) {
+	const authored = node.data.nodeId ?? void 0;
+	return authored && !isAutoGeneratedId(authored) ? authored : void 0;
+}
+function getRootEmittedId(graph, node) {
+	if (graph.id === "root" && node.data.key && node.data.key !== "root") return getAuthoredNodeId(node) ?? node.data.key;
+	return getAuthoredNodeId(node) ?? (isAutoGeneratedId(graph.id) ? void 0 : graph.id);
+}
+function getDefaultPathId(graph, node) {
+	if (!node.parentId) return getRootEmittedId(graph, node) ?? "(machine)";
+	const parentNode = graph.nodes.find((candidate) => candidate.id === node.parentId);
+	if (!parentNode) return node.data.key;
+	return `${getResolvedNodeId(graph, parentNode)}.${node.data.key}`;
+}
+function getEmittedNodeId(graph, node) {
+	const authored = getAuthoredNodeId(node);
+	if (!node.parentId) return getRootEmittedId(graph, node);
+	if (!authored) return void 0;
+	return authored === getDefaultPathId(graph, node) ? void 0 : authored;
+}
+function getResolvedNodeId(graph, node) {
+	return getEmittedNodeId(graph, node) ?? getDefaultPathId(graph, node);
+}
+/**
+* Serializes JavaScript values as JS source code (not JSON).
+* - Unquoted keys for valid identifiers
+* - Single-quoted strings
+* - Omits undefined values
+* - Supports RawCode for verbatim expressions
+* - Supports inline expression directives for verbatim expressions
+*/
+const VALID_IDENT = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+var RawCode = class {
+	constructor(code) {
+		this.code = code;
+	}
+};
+function serializeJS(value, indent = 0, step = 2) {
+	if (value instanceof RawCode) return value.code;
+	if (isInlineExpressionDirective(value)) return value.expr;
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (typeof value === "string") return `'${escapeString(value)}'`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return serializeArray(value, indent, step);
+	if (typeof value === "object") return serializeObject(value, indent, step);
+	return String(value);
+}
+function escapeString(s) {
+	return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function serializeArray(arr, indent, step) {
+	const filtered = arr.filter((v) => v !== void 0);
+	if (filtered.length === 0) return "[]";
+	const inner = indent + step;
+	const pad = " ".repeat(inner);
+	const closePad = " ".repeat(indent);
+	return `[\n${filtered.map((v) => `${pad}${serializeJS(v, inner, step)}`).join(",\n")},\n${closePad}]`;
+}
+function serializeObject(obj, indent, step) {
+	const entries = Object.entries(obj).filter(([, v]) => v !== void 0);
+	if (entries.length === 0) return "{}";
+	const inner = indent + step;
+	const pad = " ".repeat(inner);
+	const closePad = " ".repeat(indent);
+	return `{\n${entries.map(([key, val]) => {
+		const k = VALID_IDENT.test(key) ? key : `'${escapeString(key)}'`;
+		const serialized = serializeJS(val, inner, step);
+		if (isRawExpression(val) && serialized.includes("\n")) return `${pad}${k}: ${indentRawCode(serialized, inner)}`;
+		return `${pad}${k}: ${serialized}`;
+	}).join(",\n")},\n${closePad}}`;
+}
+function isRawExpression(value) {
+	return value instanceof RawCode || isInlineExpressionDirective(value);
+}
+function isInlineExpressionDirective(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const directive = value;
+	return directive["@type"] === "code" && typeof directive.expr === "string";
+}
+function indentRawCode(code, indent) {
+	const lines = code.split("\n");
+	if (lines.length <= 1) return code;
+	const pad = " ".repeat(indent);
+	return [lines[0], ...lines.slice(1).map((line) => line.trim() === "" ? "" : `${pad}${line}`)].join("\n");
+}
+/**
+* Strips `export default` wrapper from an expression string.
+* E.g. `"export default assign({ ... })"` → `"assign({ ... })"`
+*/
+function stripExportDefault(code) {
+	const trimmed = code.trim();
+	if (trimmed.startsWith("export default ")) return trimmed.slice(15).replace(/;$/, "");
+	return trimmed;
+}
+/**
+* Graph-native transition references. Transitions point at invoke/action/state
+* blocks by graph id (`@statelyai.*`); the literal `xstate.*` event is produced
+* here at codegen time. Literal `xstate.*` strings (pre-resolved, e.g. baked by
+* an import) are passed through unchanged.
+*/
+const STATELY_PREFIX = "@statelyai";
+/** Legacy prefix accepted on read for graphs persisted before the rename. */
+const LEGACY_STATELY_PREFIX = "@stately";
+const STATELY_REF_PREFIX = {
+	invokeDone: "@statelyai.invoke.done",
+	invokeError: "@statelyai.invoke.error",
+	invokeSnapshot: "@statelyai.invoke.snapshot",
+	actionDone: "@statelyai.action.done",
+	actionError: "@statelyai.action.error",
+	stateDone: "@statelyai.state.done"
+};
+function parseStatelyRef(eventType) {
+	if (eventType.startsWith(`${LEGACY_STATELY_PREFIX}.`)) eventType = `${STATELY_PREFIX}${eventType.slice(8)}`;
+	if (!eventType.startsWith(`${STATELY_PREFIX}.`)) return null;
+	for (const kind of Object.keys(STATELY_REF_PREFIX)) {
+		const prefix = STATELY_REF_PREFIX[kind];
+		if (eventType === prefix) return {
+			kind,
+			blockId: ""
+		};
+		if (eventType.startsWith(`${prefix}.`)) return {
+			kind,
+			blockId: eventType.slice(prefix.length + 1)
+		};
+	}
+	return null;
+}
+/** Find an invoke block by its graph id, or by its emitted id (legacy literals). */
+function findInvokeByActorId(node, actorId) {
+	const invokes = node.data.invokes ?? [];
+	return invokes.find((inv) => inv.id === actorId) ?? invokes.find((inv) => (inv.invocationId ?? inv.id) === actorId);
+}
+/** Resolve a spawn action block id to its spawned actor id (`params.id`). */
+function resolveSpawnActorId$1(node, actionId) {
+	const spawnId = [...node.data.entry ?? [], ...node.data.exit ?? []].find((action) => action.id === actionId)?.params?.["id"];
+	return typeof spawnId === "string" && spawnId ? spawnId : actionId;
+}
+/**
+* Resolve an edge's target into the string XState expects on the source state.
+* Prefer a relative key path (resolved against the source's parent, or the root
+* itself for root transitions) so output reads like a hand-written machine —
+* e.g. a sibling's child becomes `Unlocked.Manual`. Fall back to an absolute
+* `#id` reference only when the target lives outside the source's subtree.
+*/
+function resolveTransitionTarget(graph, sourceNode, targetNode) {
+	const isRootSource = sourceNode.parentId == null;
+	const baseId = sourceNode.parentId ?? sourceNode.id;
+	const keys = [];
+	let current = targetNode;
+	while (current) {
+		keys.unshift(current.data.key);
+		if (current.parentId === baseId) {
+			if (isRootSource) return `.${keys.join(".")}`;
+			return keys.join(".");
+		}
+		const parentId = current.parentId;
+		current = graph.nodes.find((n) => n.id === parentId);
+	}
+	return `#${getAbsoluteTargetId(graph, targetNode)}`;
+}
+function getAbsoluteTargetId(graph, targetNode) {
+	const resolved = getResolvedNodeId(graph, targetNode);
+	if (!resolved.startsWith("root.")) return resolved;
+	const rootNode = graph.nodes.find((node) => node.parentId === null);
+	const rootKey = rootNode?.data.nodeId && !isAutoGeneratedId(rootNode.data.nodeId) ? rootNode.data.nodeId : rootNode?.data.key;
+	return rootKey && rootKey !== "root" ? `${rootKey}.${resolved.slice(5)}` : resolved;
+}
+/** Unwrap single-element arrays to a single value (XState single-or-array convention) */
+function singleOrArray(arr) {
+	return arr.length === 1 ? arr[0] : arr;
+}
+/** Unwrap each value in a record of arrays */
+function singleOrArrayRecord(record) {
+	const result = {};
+	for (const [key, arr] of Object.entries(record)) result[key] = singleOrArray(arr);
+	return result;
+}
+/**
+* Remove empty arrays/objects/strings, unwrap single-element arrays.
+* Matches studio's simplifyAttributes behavior.
+*/
+function simplifyAttributes(obj) {
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		if (value === void 0 || value === null) delete obj[key];
+		else if (Array.isArray(value)) {
+			if (value.length === 0) delete obj[key];
+			else if (value.length === 1) obj[key] = value[0];
+		} else if (typeof value === "object" && Object.keys(value).length === 0) delete obj[key];
+		else if (typeof value === "string" && value === "") delete obj[key];
+	}
+	return obj;
+}
+/**
+* Recursively apply simplifyAttributes to a config tree.
+* Cleans up the config and all nested state nodes, transitions, and invokes.
+*/
+function deepSimplify(config) {
+	for (const mapKey of ["on", "after"]) {
+		const map = config[mapKey];
+		if (map && typeof map === "object" && !Array.isArray(map)) {
+			for (const [, val] of Object.entries(map)) if (val && typeof val === "object" && !Array.isArray(val)) simplifyAttributes(val);
+			else if (Array.isArray(val)) {
+				for (const item of val) if (item && typeof item === "object") simplifyAttributes(item);
+			}
+		}
+	}
+	for (const key of ["always", "onDone"]) {
+		const val = config[key];
+		if (val && typeof val === "object" && !Array.isArray(val)) simplifyAttributes(val);
+		else if (Array.isArray(val)) {
+			for (const item of val) if (item && typeof item === "object") simplifyAttributes(item);
+		}
+	}
+	const invoke = config.invoke;
+	if (invoke && typeof invoke === "object" && !Array.isArray(invoke)) simplifyAttributes(invoke);
+	else if (Array.isArray(invoke)) {
+		for (const item of invoke) if (item && typeof item === "object") simplifyAttributes(item);
+	}
+	simplifyAttributes(config);
+	if (config.states && typeof config.states === "object") for (const stateConfig of Object.values(config.states)) deepSimplify(stateConfig);
+	return config;
+}
+function buildMeta(meta, color) {
+	if (isCodeExpression(meta)) return meta;
+	const result = {};
+	if (meta) {
+		for (const [k, v] of Object.entries(meta)) if (v !== void 0 && v !== null) result[k] = v;
+	}
+	if (color) result["@statelyai.color"] = color;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function isCodeExpression(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value) && value["@type"] === "code" && typeof value.expr === "string");
+}
+/** Format event param — supports { type: string } (new) and plain string (legacy) */
+function formatEventParam(event) {
+	if (event && typeof event === "object" && "type" in event) return formatInlineObject(event);
+	if (typeof event === "string") return `{ type: '${event}' }`;
+	return "undefined";
+}
+function formatStringParam(value) {
+	return typeof value === "string" ? `'${value}'` : "undefined";
+}
+function formatInlineObject(value) {
+	return `{ ${Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => `${formatObjectKey(key)}: ${serializeJS(item)}`).join(", ")} }`;
+}
+function formatObjectKey(key) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+const eventParamSchema = union([string(), object({ type: string() }).catchall(unknown())]);
+const delayParamSchema = union([number(), string()]);
+const builtInActionParamSchemas = {
+	"xstate.raise": object({
+		event: eventParamSchema.optional(),
+		id: string().optional(),
+		delay: delayParamSchema.optional()
+	}),
+	"xstate.sendTo": object({
+		to: string().optional(),
+		event: eventParamSchema.optional(),
+		id: string().optional(),
+		delay: delayParamSchema.optional()
+	}),
+	"xstate.cancel": object({ sendId: string().optional() }),
+	"xstate.emit": object({ event: eventParamSchema.optional() }),
+	"xstate.spawnChild": object({
+		src: string().optional(),
+		id: string().optional(),
+		systemId: string().optional()
+	}),
+	"xstate.stopChild": object({ actorRef: string().optional() }),
+	"xstate.log": object({ label: string().optional() }),
+	"xstate.assign": object({ assignment: record(string(), unknown()).optional() }).catchall(unknown())
+};
+const XSTATE_BUILT_IN_ACTIONS = {
+	"xstate.raise": {
+		package: "xstate",
+		version: "^5",
+		import: "raise",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.raise"],
+		emit(params) {
+			const eventStr = formatEventParam(params?.event);
+			const opts = [];
+			if (params?.id) opts.push(`id: '${params.id}'`);
+			if (params?.delay != null) opts.push(`delay: ${JSON.stringify(params.delay)}`);
+			return `raise(${eventStr}${opts.length > 0 ? `, { ${opts.join(", ")} }` : ""})`;
+		}
+	},
+	"xstate.sendTo": {
+		package: "xstate",
+		version: "^5",
+		import: "sendTo",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.sendTo"],
+		emit(params) {
+			const to = formatStringParam(params?.to);
+			const eventStr = formatEventParam(params?.event);
+			const opts = [];
+			if (params?.id) opts.push(`id: '${params.id}'`);
+			if (params?.delay != null) opts.push(`delay: ${JSON.stringify(params.delay)}`);
+			return `sendTo(${to}, ${eventStr}${opts.length > 0 ? `, { ${opts.join(", ")} }` : ""})`;
+		}
+	},
+	"xstate.cancel": {
+		package: "xstate",
+		version: "^5",
+		import: "cancel",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.cancel"],
+		emit(params) {
+			return `cancel(${formatStringParam(params?.sendId)})`;
+		}
+	},
+	"xstate.emit": {
+		package: "xstate",
+		version: "^5",
+		import: "emit",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.emit"],
+		emit(params) {
+			return `emit(${formatEventParam(params?.event)})`;
+		}
+	},
+	"xstate.spawnChild": {
+		package: "xstate",
+		version: "^5",
+		import: "spawnChild",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.spawnChild"],
+		emit(params) {
+			const src = formatStringParam(params?.src);
+			const opts = [];
+			if (params?.id) opts.push(`id: '${params.id}'`);
+			if (params?.systemId) opts.push(`systemId: '${params.systemId}'`);
+			return `spawnChild(${src}${opts.length > 0 ? `, { ${opts.join(", ")} }` : ""})`;
+		}
+	},
+	"xstate.stopChild": {
+		package: "xstate",
+		version: "^5",
+		import: "stopChild",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.stopChild"],
+		emit(params) {
+			return `stopChild(${formatStringParam(params?.actorRef)})`;
+		}
+	},
+	"xstate.log": {
+		package: "xstate",
+		version: "^5",
+		import: "log",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.log"],
+		emit(params) {
+			return `log(${(params?.label ? `'${params.label}'` : void 0) ?? ""})`;
+		}
+	},
+	"xstate.assign": {
+		package: "xstate",
+		version: "^5",
+		import: "assign",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.assign"],
+		emit(params) {
+			const assignments = params?.assignment && typeof params.assignment === "object" && !Array.isArray(params.assignment) ? params.assignment : params;
+			const entries = Object.entries(assignments ?? {}).filter(([k, v]) => k && v !== void 0);
+			if (entries.length === 0) return "assign({})";
+			return `assign({ ${entries.map(([k, v]) => `${JSON.stringify(k)}: ${formatAssignValue(v)}`).join(", ")} })`;
+		}
+	}
+};
+function isBuiltInActionType(type) {
+	return type in XSTATE_BUILT_IN_ACTIONS;
+}
+function emitBuiltInAction(type, params) {
+	return XSTATE_BUILT_IN_ACTIONS[type].emit(params);
+}
+function actionCodeExpression(expr, source) {
+	return {
+		"@type": "code",
+		lang: "ts",
+		expr,
+		imports: [{
+			package: source.package,
+			version: source.version,
+			import: source.import,
+			importKind: source.importKind
+		}]
+	};
+}
+function inlineCodeExpression$1(expr) {
+	return {
+		"@type": "code",
+		lang: "ts",
+		expr: stripExportDefault(expr)
+	};
+}
+/**
+* Serialize an edge guard for a machine config. Codegen emits inline guards as
+* a code-expression directive so the source round-trips. The simulation passes
+* `asTypeRef` to get a plain `{ type }` reference instead (it stubs guards by
+* type and can't evaluate the source) — see MachineConfigOptions.
+*/
+function serializeGuard(guard, asTypeRef) {
+	if (asTypeRef) return guard.params ? {
+		type: guard.type,
+		params: guard.params
+	} : { type: guard.type };
+	return guard.code ? inlineCodeExpression$1(guard.code) : guard;
+}
+/**
+* Converts a built-in xstate ActionItem to a code expression directive,
+* or returns a plain { type, params } object for user-defined actions.
+*/
+function serializeActionItem(action) {
+	const { type, params } = action;
+	const exprCode = type === "xstate.expr" && typeof params?.code === "string" ? params.code : void 0;
+	if (isBuiltInActionType(type)) {
+		const builtInAction = XSTATE_BUILT_IN_ACTIONS[type];
+		return actionCodeExpression(emitBuiltInAction(type, params), builtInAction);
+	}
+	if (exprCode) return inlineCodeExpression$1(exprCode);
+	if (!params || Object.keys(params).length === 0) return { type };
+	return {
+		type,
+		params
+	};
+}
+function formatAssignValue(value) {
+	if (typeof value !== "string") return JSON.stringify(value);
+	const templateExpression = value.match(/^\{\{([\s\S]*)\}\}$/);
+	if (templateExpression) return templateExpression[1].trim();
+	return JSON.stringify(value);
+}
+/** Normalize tag to string — handles both `string` and `{ name: string }` */
+function tagToString(tag) {
+	return typeof tag === "string" ? tag : tag.name;
+}
+function graphToMachineConfig(graph, options = {}) {
+	const { showDescriptions = true, showMeta = true, inlineGuardsAsTypeRef = false } = options;
+	const config = {};
+	function getNodeConfig(node) {
+		const nodeConfig = node.parentId ? {} : config;
+		const resolvedNodeId = getEmittedNodeId(graph, node);
+		const initialNode = node.data.initialId ? graph.nodes.find((n) => n.id === node.data.initialId) : null;
+		const nodeType = [
+			"final",
+			"history",
+			"parallel"
+		].includes(node.data.type) ? node.data.type : void 0;
+		const tags = node.data.tags;
+		Object.assign(nodeConfig, {
+			id: resolvedNodeId,
+			type: nodeType === "normal" ? void 0 : nodeType ?? void 0,
+			initial: initialNode?.data.key,
+			...node.data.entry?.length ? { entry: node.data.entry.map(serializeActionItem) } : void 0,
+			...node.data.exit?.length ? { exit: node.data.exit.map(serializeActionItem) } : void 0,
+			...node.data.invokes?.length ? { invoke: node.data.invokes.map((inv) => ({
+				src: inv.src,
+				id: inv.invocationId ?? inv.id,
+				...inv.input ? { input: inv.input } : void 0,
+				...inv.output ? { output: inv.output } : void 0
+			})) } : void 0,
+			...tags?.length ? { tags: tags.map(tagToString) } : void 0,
+			...showDescriptions && node.data.description ? { description: node.data.description } : void 0,
+			...showMeta && node.data.meta && Object.keys(node.data.meta).length > 0 ? { meta: node.data.meta } : void 0,
+			...node.data.history ? { history: node.data.history } : void 0
+		});
+		const childNodes = graph.nodes.filter((n) => n.parentId === node.id && !n.data.temp);
+		const edges = graph.edges.filter((edge) => edge.sourceId === node.id && !edge.data.temp);
+		if (edges.length > 0) {
+			const on = {};
+			const after = {};
+			const alwaysArr = [];
+			const onDone = {};
+			const invokeMap = {};
+			for (const edge of edges) {
+				const targetNode = graph.nodes.find((n) => n.id === edge.targetId);
+				const resolvedTarget = targetNode ? resolveTransitionTarget(graph, node, targetNode) : "";
+				const type = edge.data.eventType ?? "";
+				const transitionMeta = showMeta ? buildMeta(edge.data.meta, edge.data.color) : void 0;
+				const transitionObject = {
+					target: edge.data.transitionType === "targetless" ? void 0 : `${resolvedTarget}`,
+					...edge.data.transitionType === "reenter" ? { reenter: true } : void 0,
+					guard: edge.data.guard ? serializeGuard(edge.data.guard, inlineGuardsAsTypeRef) : void 0,
+					actions: edge.data.actions?.length ? edge.data.actions.map(serializeActionItem) : void 0,
+					description: edge.data.description ?? void 0,
+					...transitionMeta ? { meta: transitionMeta } : void 0
+				};
+				const pushOn = (key) => {
+					if (!on[key]) on[key] = [];
+					on[key].push(transitionObject);
+				};
+				const nestInvoke = (blockId, slot) => {
+					invokeMap[blockId] = {
+						...invokeMap[blockId],
+						[slot]: (invokeMap[blockId]?.[slot] ?? []).concat(transitionObject)
+					};
+				};
+				const ref = parseStatelyRef(type);
+				if (ref) if (ref.kind === "invokeDone") nestInvoke(ref.blockId, "onDone");
+				else if (ref.kind === "invokeError") nestInvoke(ref.blockId, "onError");
+				else if (ref.kind === "invokeSnapshot") nestInvoke(ref.blockId, "onSnapshot");
+				else if (ref.kind === "stateDone") {
+					if (!onDone[type]) onDone[type] = [];
+					onDone[type].push(transitionObject);
+				} else pushOn(`xstate.${ref.kind === "actionDone" ? "done" : "error"}.actor.${resolveSpawnActorId$1(node, ref.blockId)}`);
+				else if (type === "") alwaysArr.push(transitionObject);
+				else if (type.startsWith("xstate.after.")) {
+					const delayKey = type.slice(13).split(".")[0];
+					if (!after[delayKey]) after[delayKey] = [];
+					after[delayKey].push(transitionObject);
+				} else if (type === "*") pushOn("*");
+				else if (type.startsWith("xstate.done.state")) {
+					if (!onDone[type]) onDone[type] = [];
+					onDone[type].push(transitionObject);
+				} else if (type.startsWith("xstate.done.actor.") || type.startsWith("xstate.error.actor.") || type.startsWith("xstate.snapshot.actor.")) {
+					const verb = type.startsWith("xstate.done.actor.") ? "onDone" : type.startsWith("xstate.error.actor.") ? "onError" : "onSnapshot";
+					const invoke = findInvokeByActorId(node, type.slice(type.lastIndexOf(".actor.") + 7));
+					if (invoke) nestInvoke(invoke.id, verb);
+					else pushOn(type);
+				} else pushOn(type);
+			}
+			if (Object.keys(on).length > 0) nodeConfig.on = singleOrArrayRecord(on);
+			if (Object.keys(after).length > 0) nodeConfig.after = singleOrArrayRecord(after);
+			if (alwaysArr.length > 0) nodeConfig.always = singleOrArray(alwaysArr);
+			if (Object.keys(onDone).length > 0) nodeConfig.onDone = singleOrArray(Object.values(onDone).flat());
+			if (Object.keys(invokeMap).length > 0 && Array.isArray(nodeConfig.invoke)) nodeConfig.invoke = nodeConfig.invoke.map((inv, index) => {
+				const mapped = invokeMap[node.data.invokes?.[index]?.id ?? inv.id];
+				if (!mapped) return inv;
+				return {
+					...inv,
+					...mapped.onDone ? { onDone: singleOrArray(mapped.onDone) } : void 0,
+					...mapped.onError ? { onError: singleOrArray(mapped.onError) } : void 0,
+					...mapped.onSnapshot ? { onSnapshot: singleOrArray(mapped.onSnapshot) } : void 0
+				};
+			});
+		}
+		if (Array.isArray(nodeConfig.invoke)) nodeConfig.invoke = nodeConfig.invoke.map((inv) => {
+			if (inv.id && !isAutoGeneratedId(inv.id)) return inv;
+			const { id: _id, ...rest } = inv;
+			return rest;
+		});
+		if (childNodes.length > 0) {
+			nodeConfig.states = {};
+			for (const childState of childNodes) nodeConfig.states[childState.data.key] = getNodeConfig(childState);
+		}
+		return nodeConfig;
+	}
+	const rootNode = graph.nodes.find((node) => node.data.parentId === null || node.parentId == null);
+	if (!rootNode) throw new Error("No root node found");
+	getNodeConfig(rootNode);
+	if (graph.data.context !== void 0 && graph.data.context !== null) config.context = graph.data.context;
+	return deepSimplify(config);
+}
+const REF_PREFIX = {
+	invokeDone: "@statelyai.invoke.done",
+	invokeError: "@statelyai.invoke.error",
+	invokeSnapshot: "@statelyai.invoke.snapshot",
+	actionDone: "@statelyai.action.done",
+	actionError: "@statelyai.action.error",
+	stateDone: "@statelyai.state.done"
+};
+function parseRef(eventType) {
+	if (eventType.startsWith("@stately.")) eventType = `@statelyai${eventType.slice(8)}`;
+	if (!eventType.startsWith("@statelyai.")) return null;
+	for (const kind of Object.keys(REF_PREFIX)) {
+		const prefix = REF_PREFIX[kind];
+		if (eventType === prefix) return {
+			kind,
+			blockId: ""
+		};
+		if (eventType.startsWith(`${prefix}.`)) return {
+			kind,
+			blockId: eventType.slice(prefix.length + 1)
+		};
+	}
+	return null;
+}
+function getSourceNode(graph, edge) {
+	return graph.nodes.find((node) => node.id === edge.sourceId);
+}
+function resolveSpawnActorId(sourceNode, actionId) {
+	const actorId = [...sourceNode?.data.entry ?? [], ...sourceNode?.data.exit ?? []].find((action) => action.id === actionId)?.params?.["id"];
+	return typeof actorId === "string" && actorId ? actorId : actionId;
+}
+function getTransitionRuntimeEventType(graph, edge) {
+	const eventType = edge.data.eventType;
+	const sourceNode = getSourceNode(graph, edge);
+	if (eventType.startsWith("xstate.after.")) {
+		const delayKey = eventType.slice(13).split(".")[0];
+		return sourceNode ? `xstate.after.${delayKey}.${getResolvedNodeId(graph, sourceNode)}` : eventType;
+	}
+	const ref = parseRef(eventType);
+	if (!ref) return eventType;
+	if (ref.kind === "stateDone") {
+		const node = graph.nodes.find((candidate) => candidate.id === ref.blockId) ?? sourceNode;
+		return `xstate.done.state.${node ? getResolvedNodeId(graph, node) : ref.blockId}`;
+	}
+	if (ref.kind === "invokeDone" || ref.kind === "invokeError" || ref.kind === "invokeSnapshot") {
+		const invokes = sourceNode?.data.invokes ?? [];
+		const index = invokes.findIndex((invoke) => invoke.id === ref.blockId);
+		const actorId = (index >= 0 ? invokes[index] : void 0)?.invocationId || (sourceNode && index >= 0 ? `${index}.${getResolvedNodeId(graph, sourceNode)}` : ref.blockId);
+		return `xstate.${ref.kind === "invokeDone" ? "done" : ref.kind === "invokeError" ? "error" : "snapshot"}.actor.${actorId}`;
+	}
+	return `xstate.${ref.kind === "actionDone" ? "done" : "error"}.actor.${resolveSpawnActorId(sourceNode, ref.blockId)}`;
+}
+function transitionMatchesRuntimeEvent(graph, edge, eventType) {
+	return getTransitionRuntimeEventType(graph, edge) === eventType;
+}
+/**
+* Map an XState state node (identified by its array of keys from the root) to
+* the corresponding graph node id. The runtime snapshot's `_nodes[].id` are
+* XState resolved ids (delimited paths), which do not match the graph's opaque
+* node ids; consumers (highlighting, edge lookup) need graph node ids.
+*/
+function getGraphNodeIdForPath(graph, path) {
+	const root = graph.nodes.find((n) => n.parentId === null);
+	if (!root) return null;
+	if (path.length === 0) return root.id;
+	let parentId = root.id;
+	let nodeId = null;
+	for (const key of path) {
+		const child = graph.nodes.find((n) => n.parentId === parentId && n.data.key === key);
+		if (!child) return null;
+		nodeId = child.id;
+		parentId = child.id;
+	}
+	return nodeId;
+}
+function getStateIds(graph, snapshot) {
+	const nodes = snapshot._nodes;
+	if (!nodes) return [];
+	return nodes.map((n) => getGraphNodeIdForPath(graph, n.path)).filter((id) => id !== null);
+}
+function getLeafStateIds(graph, snapshot) {
+	const nodes = snapshot._nodes;
+	if (!nodes) return [];
+	const leaves = nodes.filter((n) => n.path.length > 0 && (n.type === "atomic" || n.type === "final"));
+	return (leaves.length > 0 ? leaves : nodes).map((n) => getGraphNodeIdForPath(graph, n.path)).filter((id) => id !== null);
+}
+function getStatePath(snapshot) {
+	const nodes = snapshot._nodes;
+	if (!nodes?.length) return "(initial)";
+	const withPath = nodes.filter((n) => n.path.length > 0);
+	if (!withPath.length) return "(initial)";
+	const leaves = withPath.filter((n) => n.type === "atomic" || n.type === "final");
+	return (leaves.length > 0 ? leaves : withPath).map((n) => n.path.join(".")).join(", ");
+}
+function findEdgeId(graph, sourceStateIds, event) {
+	const guardType = event["@xstate.guard"];
+	for (const sourceId of sourceStateIds) {
+		const edge = graph.edges.find((candidate) => candidate.sourceId === sourceId && transitionMatchesRuntimeEvent(graph, candidate, event.type) && (candidate.data.guard?.type ?? null) === (guardType ?? null));
+		if (edge) return edge.id;
+	}
+	for (const sourceId of sourceStateIds) {
+		const edge = graph.edges.find((candidate) => candidate.sourceId === sourceId && transitionMatchesRuntimeEvent(graph, candidate, event.type));
+		if (edge) return edge.id;
+	}
+	return null;
+}
+function formatEventLabel(event) {
+	if (event.type === "") return "always";
+	if (event.type.startsWith("xstate.after.")) return `after ${event.type.slice(13).split(".")[0]}`;
+	const guardType = event["@xstate.guard"];
+	if (guardType) return `${event.type} [${guardType}]`;
+	return event.type;
+}
+function formatEdgeLabel(graph, edgeId) {
+	const edge = graph.edges.find((candidate) => candidate.id === edgeId);
+	if (!edge) return null;
+	const baseLabel = formatEventLabel({ type: edge.data.eventType });
+	const guardType = edge.data.guard?.type;
+	if (guardType) return `${baseLabel} [${guardType}]`;
+	return baseLabel;
+}
+function getFallbackTransitionLabels(graph, finalStateIds) {
+	return getFallbackEventlessEdges(graph, finalStateIds).map((edge) => formatEdgeLabel(graph, edge.id)).filter((label) => !!label);
+}
+function getFallbackEventlessEdges(graph, finalStateIds) {
+	const finalLeafIdSet = new Set(finalStateIds);
+	return graph.edges.filter((edge) => finalLeafIdSet.has(edge.targetId) && edge.data.eventType === "");
+}
+function getPathName(finalStatePath, finalStateIds, steps, graph) {
+	let transitionLabels = steps.map((step) => {
+		if (step.edgeId) return formatEdgeLabel(graph, step.edgeId);
+		if (step.eventType && step.eventType !== "xstate.init") return formatEventLabel({ type: step.eventType });
+		return null;
+	}).filter((label) => !!label);
+	if (transitionLabels.length === 0) transitionLabels = getFallbackTransitionLabels(graph, finalStateIds);
+	if (transitionLabels.length === 0) return {
+		name: finalStatePath,
+		viaLabel: null
+	};
+	return {
+		name: finalStatePath,
+		viaLabel: `via ${transitionLabels.join(" -> ")}`
+	};
+}
+function convertPath(path, graph, index) {
+	const steps = [];
+	const firstStep = path.steps[0];
+	if (firstStep) {
+		const allIds = getStateIds(graph, firstStep.state);
+		steps.push({
+			stateIds: getLeafStateIds(graph, firstStep.state),
+			statePath: getStatePath(firstStep.state),
+			eventType: firstStep.event.type,
+			edgeId: findEdgeId(graph, allIds, firstStep.event)
+		});
+	}
+	for (let i = 1; i < path.steps.length; i++) {
+		const prevStep = path.steps[i - 1];
+		const step = path.steps[i];
+		const prevStateIds = getStateIds(graph, prevStep.state);
+		steps.push({
+			stateIds: getLeafStateIds(graph, step.state),
+			statePath: getStatePath(step.state),
+			eventType: step.event.type,
+			edgeId: findEdgeId(graph, prevStateIds, step.event)
+		});
+	}
+	const finalStatePath = getStatePath(path.state);
+	const finalStateIds = getLeafStateIds(graph, path.state);
+	const title = getPathName(finalStatePath, finalStateIds, steps, graph);
+	return {
+		id: `path-${index}`,
+		name: title.name,
+		viaLabel: title.viaLabel,
+		steps,
+		finalStatePath,
+		finalStateIds
+	};
+}
+function serializeMachineTransition(_state, event, prevState) {
+	if (!event) return "";
+	const prevStateString = prevState ? ` from ${JSON.stringify(prevState.value)}` : "";
+	return ` via ${JSON.stringify(event)}${prevStateString}`;
+}
+function getGraphPathSimImplementations(graph, guardState) {
+	const guards = {};
+	for (const edge of graph.edges) if (edge.data.guard) {
+		const guardType = edge.data.guard.type;
+		if (guardState) guards[guardType] = () => guardState[guardType] ?? false;
+		else guards[guardType] = ({ event }) => {
+			if (event["@xstate.guard"] === guardType) return true;
+			return false;
+		};
+	}
+	return { guards };
+}
+function getTraversalEvents(state, graph) {
+	const events = [];
+	for (const edge of graph.edges) {
+		const eventType = getTransitionRuntimeEventType(graph, edge);
+		const event = { type: eventType };
+		if (edge.data.guard?.type) event["@xstate.guard"] = edge.data.guard.type;
+		if (eventType && !state.can(event)) continue;
+		events.push(event);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	return events.filter((event) => {
+		const key = JSON.stringify(event);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function getStepKey(step) {
+	return JSON.stringify({
+		stateIds: step.stateIds,
+		statePath: step.statePath,
+		eventType: step.eventType,
+		edgeId: step.edgeId
+	});
+}
+function getLeafGraphNodeIds(graph) {
+	const activeNodes = graph.nodes.filter((node) => !node.data.temp);
+	const parentIds = new Set(activeNodes.map((node) => node.parentId).filter(Boolean));
+	return activeNodes.filter((node) => !parentIds.has(node.id)).map((node) => node.id);
+}
+function getCoverage(graph, paths) {
+	const leafNodeIds = new Set(getLeafGraphNodeIds(graph));
+	const coveredStateIds = /* @__PURE__ */ new Set();
+	const coveredEdgeIds = /* @__PURE__ */ new Set();
+	for (const path of paths) {
+		let pathHasExplicitEdge = false;
+		for (const step of path.steps) {
+			for (const stateId of step.stateIds) if (leafNodeIds.has(stateId)) coveredStateIds.add(stateId);
+			if (step.edgeId) {
+				pathHasExplicitEdge = true;
+				coveredEdgeIds.add(step.edgeId);
+			}
+		}
+		for (const finalStateId of path.finalStateIds) if (leafNodeIds.has(finalStateId)) coveredStateIds.add(finalStateId);
+		if (!pathHasExplicitEdge) for (const edge of getFallbackEventlessEdges(graph, path.finalStateIds)) coveredEdgeIds.add(edge.id);
+	}
+	return {
+		states: {
+			covered: coveredStateIds.size,
+			total: leafNodeIds.size
+		},
+		transitions: {
+			covered: coveredEdgeIds.size,
+			total: graph.edges.filter((edge) => !edge.data.temp).length
+		}
+	};
+}
+function deduplicateGeneratedPaths(paths) {
+	const sorted = [...paths].sort((a, b) => b.steps.length - a.steps.length);
+	const unique = [];
+	for (const path of sorted) if (!unique.some((existing) => {
+		if (path.steps.length >= existing.steps.length) return false;
+		return path.steps.every((step, index) => getStepKey(step) === getStepKey(existing.steps[index]));
+	})) unique.push(path);
+	return unique;
+}
+function generateGraphPathsData(graph, options) {
+	const machineConfig = graphToMachineConfig(graph);
+	const implementations = getGraphPathSimImplementations(graph);
+	const machine = createMachine(machineConfig).provide(implementations);
+	let converted = (options.strategy === "shortest" ? getShortestPaths : getSimplePaths)(machine, {
+		events: (state) => getTraversalEvents(state, graph),
+		serializeState: (state, event, prevState) => {
+			const serializedState = JSON.stringify(state.value);
+			if (!options.preferTransitionCoverage) return serializedState;
+			return `${serializedState}|${serializeMachineTransition(state, event, prevState)}`;
+		}
+	}).map((path, index) => convertPath(path, graph, index));
+	if (options.reduceDuplicates) converted = deduplicateGeneratedPaths(converted);
+	if (options.limit) converted = converted.slice(0, options.limit);
+	return {
+		paths: converted,
+		coverage: getCoverage(graph, converted)
+	};
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : value === void 0 ? [] : [value];
+}
+function actionItems(value) {
+	return toArray(value).map((item, index) => {
+		if (typeof item === "string") return {
+			id: item,
+			type: item
+		};
+		if (item && typeof item === "object" && "type" in item) {
+			const action = item;
+			if (typeof action.type === "string") return {
+				id: action.type || `action-${index}`,
+				type: action.type,
+				params: action.params
+			};
+		}
+		return null;
+	}).filter((item) => item !== null);
+}
+function invokeItems(value) {
+	return toArray(value).map((item, index) => {
+		if (typeof item === "string") return {
+			id: item || `invoke-${index}`,
+			src: item
+		};
+		if (!item || typeof item !== "object") return null;
+		const invoke = item;
+		if (typeof invoke.src !== "string") return null;
+		return {
+			id: typeof invoke.id === "string" ? invoke.id : invoke.src,
+			src: invoke.src,
+			...invoke.input !== void 0 ? { input: invoke.input } : {},
+			...invoke.output !== void 0 ? { output: invoke.output } : {}
+		};
+	}).filter((item) => item !== null);
+}
+function transitionTargets(target) {
+	if (typeof target === "string") return [target];
+	if (Array.isArray(target)) return target.filter((item) => typeof item === "string");
+	return [];
+}
+function targetToNodeId(sourceId, target, rootKey) {
+	if (!target) return sourceId;
+	let clean = target.startsWith("#") ? target.slice(1) : target;
+	if (target.startsWith("#")) {
+		const rootPrefix = `${rootKey}.`;
+		if (clean === rootKey) return "root";
+		if (clean.startsWith(rootPrefix)) clean = clean.slice(rootPrefix.length);
+		return clean ? `root.${clean}` : "root";
+	}
+	if (clean.includes(".")) return `root.${clean}`;
+	return `${sourceId.split(".").slice(0, -1).join(".") || "root"}.${clean}`;
+}
+function transitionObjects(value) {
+	return toArray(value).map((item) => {
+		if (typeof item === "string") return { target: item };
+		if (item && typeof item === "object") return item;
+		return {};
+	});
+}
+function guardObject(value) {
+	if (!value) return null;
+	if (typeof value === "string") return { type: value };
+	if (typeof value === "object" && "type" in value && typeof value.type === "string") {
+		const guard = value;
+		return {
+			type: guard.type,
+			params: guard.params
+		};
+	}
+	return null;
+}
+function machineConfigToGraph(config) {
+	createMachine(config);
+	const rootKey = String(config.id ?? "machine");
+	const graph = {
+		id: "root",
+		nodes: [],
+		edges: [],
+		data: {
+			implementations: {
+				actions: [],
+				guards: [],
+				actors: [],
+				delays: []
+			},
+			schemas: config.schemas ?? null
+		}
+	};
+	function visit(state, key, parentId) {
+		const id = parentId ? `${parentId}.${key}` : "root";
+		const initialId = state.initial ? `${id}.${state.initial}` : null;
+		graph.nodes.push({
+			id,
+			parentId,
+			data: {
+				key,
+				type: state.type === "parallel" || state.type === "final" || state.type === "history" ? state.type : null,
+				initialId,
+				history: state.history ?? false,
+				entry: actionItems(state.entry),
+				exit: actionItems(state.exit),
+				invokes: invokeItems(state.invoke),
+				tags: Array.isArray(state.tags) ? state.tags : typeof state.tags === "string" ? [state.tags] : [],
+				description: state.description ?? null,
+				meta: state.meta ?? null
+			}
+		});
+		for (const [eventType, value] of Object.entries(state.on ?? {})) for (const [index, transition] of transitionObjects(value).entries()) {
+			const target = transitionTargets(transition.target)[0];
+			graph.edges.push({
+				id: `${id}-${eventType}-${index}`,
+				sourceId: id,
+				targetId: targetToNodeId(id, target, rootKey),
+				data: {
+					eventType,
+					transitionType: target ? transition.reenter ? "reenter" : "normal" : "targetless",
+					guard: guardObject(transition.guard),
+					actions: actionItems(transition.actions),
+					description: typeof transition.description === "string" ? transition.description : null,
+					meta: transition.meta && typeof transition.meta === "object" ? transition.meta : null
+				}
+			});
+		}
+		for (const [delay, value] of Object.entries(state.after ?? {})) for (const [index, transition] of transitionObjects(value).entries()) {
+			const target = transitionTargets(transition.target)[0];
+			graph.edges.push({
+				id: `${id}-after-${delay}-${index}`,
+				sourceId: id,
+				targetId: targetToNodeId(id, target, rootKey),
+				data: {
+					eventType: `xstate.after.${delay}.${id}`,
+					transitionType: target ? "normal" : "targetless",
+					guard: guardObject(transition.guard),
+					actions: actionItems(transition.actions),
+					description: typeof transition.description === "string" ? transition.description : null,
+					meta: null
+				}
+			});
+		}
+		for (const [index, transition] of transitionObjects(state.always).entries()) {
+			const target = transitionTargets(transition.target)[0];
+			graph.edges.push({
+				id: `${id}-always-${index}`,
+				sourceId: id,
+				targetId: targetToNodeId(id, target, rootKey),
+				data: {
+					eventType: "",
+					transitionType: target ? "normal" : "targetless",
+					guard: guardObject(transition.guard),
+					actions: actionItems(transition.actions),
+					description: typeof transition.description === "string" ? transition.description : null,
+					meta: null
+				}
+			});
+		}
+		for (const [childKey, child] of Object.entries(state.states ?? {})) visit(child, childKey, id);
+	}
+	visit(config, rootKey, null);
+	return graph;
+}
+const XSTATE_V6_FN_TRANSITION_META = "@statelyai.xstate.v6.fnTransition";
+const XSTATE_V6_FN_SOURCE_META = "@statelyai.xstate.v6.fnSource";
+function sourceFile(source) {
+	return ts.createSourceFile("machine.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+}
+function propName(name) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+	return null;
+}
+function unwrapExpression$2(node) {
+	if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node) || ts.isParenthesizedExpression(node)) return unwrapExpression$2(node.expression);
+	return node;
+}
+function propertyContext(parent, key) {
+	if (parent.transitionMap) return {
+		v6: parent.v6,
+		transitionValue: true
+	};
+	if (parent.transitionValue && key === "actions") return {
+		v6: parent.v6,
+		actionValue: true
+	};
+	if (key === "meta") return {
+		v6: parent.v6,
+		metaValue: true
+	};
+	if (parent.transitionValue && key === "to") return {
+		v6: parent.v6,
+		transitionValue: true
+	};
+	if (key === "entry" || key === "exit") return {
+		v6: parent.v6,
+		actionValue: true
+	};
+	if (key === "on" || key === "after") return {
+		v6: parent.v6,
+		transitionMap: true
+	};
+	if (key === "always" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout") return {
+		v6: parent.v6,
+		transitionValue: true
+	};
+	return { v6: parent.v6 };
+}
+function fallbackFunctionTransition(fn) {
+	return { meta: {
+		[XSTATE_V6_FN_TRANSITION_META]: true,
+		[XSTATE_V6_FN_SOURCE_META]: fn.getText()
+	} };
+}
+function conditionText(cond) {
+	return cond.negated ? `!(${cond.text})` : cond.text;
+}
+function simplifyConditions(conds) {
+	const seen = /* @__PURE__ */ new Set();
+	return conds.filter((cond) => {
+		if (cond.negated) return false;
+		const key = conditionText(cond);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function guardFromConditions(conds) {
+	const simplified = simplifyConditions(conds);
+	if (simplified.length === 0) return void 0;
+	return { type: simplified.map(conditionText).join(" && ") };
+}
+function mergeActions(left, right) {
+	return [...left ?? [], ...right];
+}
+function transitionFromValue(value, actions) {
+	if (typeof value === "string") {
+		if (actions.length === 0) return value;
+		return {
+			target: value,
+			actions
+		};
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) return actions.length ? { actions } : null;
+	const record = { ...value };
+	const context = record.context;
+	delete record.context;
+	if (context !== void 0) record.actions = mergeActions(Array.isArray(record.actions) ? record.actions : record.actions ? [record.actions] : void 0, [{
+		type: "xstate.assign",
+		params: { assignment: context }
+	}]);
+	if (actions.length) record.actions = mergeActions(Array.isArray(record.actions) ? record.actions : record.actions ? [record.actions] : void 0, actions);
+	return record;
+}
+function expressionBranches(expression, bindings, depth) {
+	const node = unwrapExpression$2(expression);
+	if (ts.isConditionalExpression(node)) {
+		const cond = node.condition.getText();
+		return [...expressionBranches(node.whenTrue, bindings, depth + 1).map((branch) => ({
+			...branch,
+			conds: [{ text: cond }, ...branch.conds]
+		})), ...expressionBranches(node.whenFalse, bindings, depth + 1).map((branch) => ({
+			...branch,
+			conds: [{
+				text: cond,
+				negated: true
+			}, ...branch.conds]
+		}))];
+	}
+	if (ts.isBinaryExpression(node) && (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === ts.SyntaxKind.BarBarToken)) {
+		const cond = node.left.getText();
+		if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) return [...expressionBranches(node.right, bindings, depth + 1).map((branch) => ({
+			...branch,
+			conds: [{ text: cond }, ...branch.conds]
+		})), {
+			conds: [{
+				text: cond,
+				negated: true
+			}],
+			actions: []
+		}];
+		return [{
+			conds: [{ text: cond }],
+			actions: [],
+			result: node.left.getText()
+		}, ...expressionBranches(node.right, bindings, depth + 1).map((branch) => ({
+			...branch,
+			conds: [{
+				text: cond,
+				negated: true
+			}, ...branch.conds]
+		}))];
+	}
+	if (ts.isObjectLiteralExpression(node)) {
+		const targetProperty = node.properties.find((property) => ts.isPropertyAssignment(property) && propName(property.name) === "target");
+		const target = targetProperty ? unwrapExpression$2(targetProperty.initializer) : null;
+		if (target && (ts.isConditionalExpression(target) || ts.isBinaryExpression(target) && (target.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || target.operatorToken.kind === ts.SyntaxKind.BarBarToken))) return expressionBranches(target, bindings, depth + 1).map((branch) => ({
+			...branch,
+			result: objectLiteralToValue(node, bindings, {}, depth + 1, new Map([["target", branch.result]]))
+		}));
+	}
+	return [{
+		conds: [],
+		actions: [],
+		result: expressionToValue(node, bindings, {}, depth + 1)
+	}];
+}
+function mergeBranchPrefix(prefix, branch) {
+	return {
+		conds: [...prefix.conds, ...branch.conds],
+		actions: [...prefix.actions, ...branch.actions],
+		result: branch.result,
+		unknown: prefix.unknown || branch.unknown
+	};
+}
+function expressionStatementAction(statement, enqName, bindings) {
+	const expression = unwrapExpression$2(statement.expression);
+	if (!ts.isCallExpression(expression)) return null;
+	const callee = expression.expression;
+	if (ts.isIdentifier(callee) && callee.text === enqName) return {
+		type: "xstate.expr",
+		params: {
+			code: expression.getText(),
+			lang: "ts"
+		}
+	};
+	if (!ts.isPropertyAccessExpression(callee)) return null;
+	if (!ts.isIdentifier(callee.expression) || callee.expression.text !== enqName) return null;
+	const method = callee.name.text;
+	const args = expression.arguments;
+	const value = (index) => {
+		const arg = args[index];
+		return arg && ts.isExpression(arg) ? expressionToValue(arg, bindings, {}, 0) : void 0;
+	};
+	const spreadOpts = (index) => {
+		const opts = value(index);
+		return opts && typeof opts === "object" && !Array.isArray(opts) ? opts : {};
+	};
+	if (method === "emit") return {
+		type: "xstate.emit",
+		params: { event: value(0) }
+	};
+	if (method === "raise") return {
+		type: "xstate.raise",
+		params: {
+			event: value(0),
+			...spreadOpts(1)
+		}
+	};
+	if (method === "sendTo") return {
+		type: "xstate.sendTo",
+		params: {
+			to: value(0),
+			event: value(1),
+			...spreadOpts(2)
+		}
+	};
+	if (method === "cancel") return {
+		type: "xstate.cancel",
+		params: { sendId: value(0) }
+	};
+	if (method === "log") return {
+		type: "xstate.log",
+		params: { label: value(0) }
+	};
+	if (method === "spawn") return {
+		type: "xstate.spawnChild",
+		params: {
+			src: value(0),
+			...spreadOpts(1)
+		}
+	};
+	if (method === "stop") return {
+		type: "xstate.stopChild",
+		params: { actorRef: value(0) }
+	};
+	return {
+		type: "xstate.expr",
+		params: {
+			code: expression.getText(),
+			lang: "ts"
+		}
+	};
+}
+function statementBranches(statements, bindings, enqName, prefixes = [{
+	conds: [],
+	actions: []
+}]) {
+	let open = prefixes;
+	const done = [];
+	for (const statement of statements) {
+		const nextOpen = [];
+		for (const prefix of open) {
+			if (ts.isReturnStatement(statement)) {
+				if (!statement.expression) {
+					done.push({
+						...prefix,
+						result: void 0
+					});
+					continue;
+				}
+				for (const branch of expressionBranches(statement.expression, bindings, 0)) done.push(mergeBranchPrefix(prefix, branch));
+				continue;
+			}
+			if (ts.isExpressionStatement(statement)) {
+				const action = expressionStatementAction(statement, enqName, bindings);
+				if (action) {
+					nextOpen.push({
+						...prefix,
+						actions: [...prefix.actions, action]
+					});
+					continue;
+				}
+			}
+			if (ts.isIfStatement(statement)) {
+				const cond = statement.expression.getText();
+				const thenBranches = statementBranches(ts.isBlock(statement.thenStatement) ? statement.thenStatement.statements : [statement.thenStatement], bindings, enqName, [{
+					...prefix,
+					conds: [...prefix.conds, { text: cond }]
+				}]);
+				const elseStatements = statement.elseStatement ? ts.isBlock(statement.elseStatement) ? statement.elseStatement.statements : [statement.elseStatement] : [];
+				const elseBranches = elseStatements.length > 0 ? statementBranches(elseStatements, bindings, enqName, [{
+					...prefix,
+					conds: [...prefix.conds, {
+						text: cond,
+						negated: true
+					}]
+				}]) : [{
+					...prefix,
+					conds: [...prefix.conds, {
+						text: cond,
+						negated: true
+					}]
+				}];
+				for (const branch of [...thenBranches, ...elseBranches]) if ("result" in branch) done.push(branch);
+				else nextOpen.push(branch);
+				continue;
+			}
+			if (ts.isSwitchStatement(statement)) {
+				const expr = statement.expression.getText();
+				const prior = [];
+				for (const clause of statement.caseBlock.clauses) {
+					const ownCond = ts.isCaseClause(clause) ? { text: `${expr} === ${clause.expression.getText()}` } : null;
+					const conds = ownCond ? [...prior, ownCond] : prior.length ? [...prior] : [];
+					const branches = statementBranches(clause.statements, bindings, enqName, [{
+						...prefix,
+						conds: [...prefix.conds, ...conds]
+					}]);
+					for (const branch of branches) if ("result" in branch) done.push(branch);
+					else nextOpen.push(branch);
+					if (ownCond) prior.push({
+						...ownCond,
+						negated: true
+					});
+				}
+				continue;
+			}
+			nextOpen.push({
+				...prefix,
+				unknown: true
+			});
+		}
+		open = nextOpen;
+	}
+	return [...done, ...open];
+}
+function enqueueParamName(fn) {
+	const param = fn.parameters[1];
+	return param && ts.isIdentifier(param.name) ? param.name.text : "enq";
+}
+function normalizeFunctionTransition(fn, bindings, depth) {
+	const transitions = (ts.isArrowFunction(fn) && !ts.isBlock(fn.body) ? expressionBranches(fn.body, bindings, depth + 1) : fn.body && ts.isBlock(fn.body) ? statementBranches(fn.body.statements, bindings, enqueueParamName(fn)) : []).filter((branch) => !branch.unknown).map((branch) => {
+		const transition = transitionFromValue(branch.result, branch.actions);
+		if (!transition) return null;
+		if (typeof transition === "string") {
+			const guard = guardFromConditions(branch.conds);
+			return guard ? {
+				target: transition,
+				guard
+			} : transition;
+		}
+		const guard = guardFromConditions(branch.conds);
+		return guard ? {
+			...transition,
+			guard
+		} : transition;
+	}).filter((transition) => Boolean(transition));
+	if (transitions.length === 1) return transitions[0];
+	if (transitions.length > 1) return transitions;
+	return fallbackFunctionTransition(fn);
+}
+function inlineAction(fn) {
+	return {
+		type: "xstate.expr",
+		params: {
+			code: fn.getText(),
+			lang: "ts"
+		}
+	};
+}
+function inlineCodeExpression(expr) {
+	return {
+		"@type": "code",
+		lang: "ts",
+		expr
+	};
+}
+function normalizeFunctionAction(fn, bindings) {
+	if (ts.isArrowFunction(fn) && !ts.isBlock(fn.body)) return inlineAction(fn);
+	if (!fn.body || !ts.isBlock(fn.body)) return inlineAction(fn);
+	const branches = statementBranches(fn.body.statements, bindings, enqueueParamName(fn));
+	if (branches.length === 1 && !branches[0].unknown && branches[0].conds.length === 0 && branches[0].actions.length > 0 && !("result" in branches[0])) return branches[0].actions;
+	return inlineAction(fn);
+}
+function objectLiteralToValue(node, bindings, context, depth, overrides = /* @__PURE__ */ new Map()) {
+	const result = {};
+	for (const property of node.properties) {
+		if (ts.isSpreadAssignment(property)) {
+			const spread = expressionToValue(property.expression, bindings, context, depth + 1);
+			if (spread && typeof spread === "object" && !Array.isArray(spread)) Object.assign(result, spread);
+			continue;
+		}
+		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) continue;
+		const key = propName(property.name);
+		if (!key) continue;
+		if (overrides.has(key)) {
+			result[key] = overrides.get(key);
+			continue;
+		}
+		if (ts.isShorthandPropertyAssignment(property)) {
+			result[key] = expressionToValue(property.name, bindings, propertyContext(context, key), depth + 1);
+			continue;
+		}
+		result[key] = expressionToValue(property.initializer, bindings, propertyContext(context, key), depth + 1);
+	}
+	if (context.transitionValue && "to" in result) {
+		const to = result.to;
+		const { to: _to, ...rest } = result;
+		if (typeof to === "string") return {
+			...rest,
+			target: to
+		};
+		if (Array.isArray(to)) return to.map((item) => typeof item === "string" ? {
+			...rest,
+			target: item
+		} : item && typeof item === "object" ? {
+			...rest,
+			...item
+		} : rest);
+		if (to && typeof to === "object" && !Array.isArray(to)) return {
+			...rest,
+			...to
+		};
+	}
+	return result;
+}
+function expressionToValue(expression, bindings, context = {}, depth = 0) {
+	if (depth > 30) return void 0;
+	const node = unwrapExpression$2(expression);
+	if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+	if (ts.isNumericLiteral(node)) return Number(node.text);
+	if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+	if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+	if (node.kind === ts.SyntaxKind.NullKeyword) return null;
+	if (ts.isIdentifier(node)) {
+		if (node.text === "undefined") return void 0;
+		const binding = bindings.get(node.text);
+		return binding ? expressionToValue(binding, bindings, context, depth + 1) : context.metaValue ? inlineCodeExpression(node.getText()) : node.text;
+	}
+	if (ts.isObjectLiteralExpression(node)) return objectLiteralToValue(node, bindings, context, depth);
+	if (ts.isArrayLiteralExpression(node)) {
+		const values = node.elements.map((element) => expressionToValue(element, bindings, context, depth + 1));
+		return context.actionValue ? values.flat() : values;
+	}
+	if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+		if (context.metaValue) return inlineCodeExpression(node.getText());
+		if (context.v6 && context.transitionValue) return normalizeFunctionTransition(node, bindings, depth);
+		if (context.v6 && context.actionValue) return normalizeFunctionAction(node, bindings);
+		return node.getText();
+	}
+	if (ts.isCallExpression(node)) {
+		if (context.metaValue) return inlineCodeExpression(node.getText());
+		if (context.actionValue) return inlineAction(node);
+		const callee = node.expression.getText();
+		const type = callee.includes(".") ? callee.split(".").pop() : callee;
+		return { type: type === "assign" ? "xstate.assign" : type };
+	}
+	return context.metaValue ? inlineCodeExpression(node.getText()) : node.getText();
+}
+function collectBindings$1(file) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of file.statements) {
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) bindings.set(declaration.name.text, declaration.initializer);
+	}
+	return bindings;
+}
+function isCreateMachineCall(node) {
+	const expression = node.expression;
+	if (ts.isIdentifier(expression)) return expression.text === "createMachine";
+	if (ts.isPropertyAccessExpression(expression)) return expression.name.text === "createMachine";
+	return false;
+}
+function hasV6Syntax(source) {
+	const file = sourceFile(source);
+	let found = false;
+	function visit(node) {
+		if (found) return;
+		if (ts.isPropertyAssignment(node) && (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name))) {
+			const key = node.name.text;
+			if (key === "triggers" || key === "internalEvents" || key === "timeout" || key === "onTimeout" || key === "choice" || key === "route") {
+				found = true;
+				return;
+			}
+			if ((key === "on" || key === "after" || key === "always" || key === "entry" || key === "exit" || key === "actions" && !ts.isObjectLiteralExpression(node.initializer)) && node.initializer.getText().includes("=>")) {
+				found = true;
+				return;
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(file);
+	return found;
+}
+function detectXStateSourceProfile(source) {
+	return hasV6Syntax(source) ? "xstate-v6-alpha" : "xstate-v5";
+}
+function xstateSourceToConfig(source, options = {}) {
+	const file = sourceFile(source);
+	const bindings = collectBindings$1(file);
+	let found = null;
+	const profile = options.profile === "auto" || !options.profile ? detectXStateSourceProfile(source) : options.profile;
+	function visit(node) {
+		if (found || !ts.isCallExpression(node) || !isCreateMachineCall(node)) {
+			ts.forEachChild(node, visit);
+			return;
+		}
+		const arg = node.arguments[0];
+		if (!arg) return;
+		const value = expressionToValue(arg, bindings, { v6: profile === "xstate-v6-alpha" });
+		if (value && typeof value === "object" && !Array.isArray(value)) found = value;
+	}
+	visit(file);
+	if (!found) throw new Error("No createMachine(...) or setup(...).createMachine(...) call found.");
+	return found;
+}
+function parseJsonLike(input) {
+	return JSON.parse(input);
+}
+function parseSimpleYaml(input) {
+	const lines = input.split(/\r?\n/).filter((line) => line.trim() && !line.trim().startsWith("#"));
+	const root = {};
+	const stack = [{
+		indent: -1,
+		value: root
+	}];
+	for (const line of lines) {
+		const indent = line.match(/^\s*/)?.[0].length ?? 0;
+		const trimmed = line.trim();
+		const match = /^([^:]+):(.*)$/.exec(trimmed);
+		if (!match) continue;
+		const key = match[1].trim();
+		const raw = match[2].trim();
+		while (stack.length > 1 && indent <= stack[stack.length - 1].indent) stack.pop();
+		const parent = stack[stack.length - 1].value;
+		if (!raw) {
+			const child = {};
+			parent[key] = child;
+			stack.push({
+				indent,
+				value: child
+			});
+		} else if (raw === "true" || raw === "false") parent[key] = raw === "true";
+		else if (/^-?\d+(?:\.\d+)?$/.test(raw)) parent[key] = Number(raw);
+		else parent[key] = raw.replace(/^['"]|['"]$/g, "");
+	}
+	return root;
+}
+function parseMermaid(input) {
+	const states = /* @__PURE__ */ new Set();
+	const transitions = [];
+	let initial;
+	for (const line of input.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || /^(stateDiagram|stateDiagram-v2|flowchart|graph)\b/.test(trimmed)) continue;
+		const stateMatch = /^\[\*\]\s*-->\s*([A-Za-z0-9_.-]+)/.exec(trimmed);
+		if (stateMatch?.[1]) {
+			initial = stateMatch[1];
+			states.add(initial);
+			continue;
+		}
+		const transitionMatch = /^([A-Za-z0-9_.-]+)\s*(?:-->|--)\s*(?:\|([^|]+)\|)?\s*([A-Za-z0-9_.-]+)(?:\s*:\s*(.+))?/.exec(trimmed);
+		if (!transitionMatch) continue;
+		const source = transitionMatch[1];
+		const target = transitionMatch[3];
+		const event = transitionMatch[2] ?? transitionMatch[4];
+		states.add(source);
+		states.add(target);
+		transitions.push({
+			source,
+			target,
+			event: event?.trim()
+		});
+		initial ??= source;
+	}
+	const stateConfigs = {};
+	for (const state of states) stateConfigs[state] = {};
+	for (const transition of transitions) {
+		const source = stateConfigs[transition.source];
+		const on = source.on ??= {};
+		on[transition.event || "NEXT"] = transition.target;
+	}
+	return {
+		id: "machine",
+		initial: initial ?? [...states][0] ?? "idle",
+		states: Object.keys(stateConfigs).length ? stateConfigs : { idle: {} }
+	};
+}
+function inferMachineFormat(machine, format) {
+	if (format) return format;
+	if (typeof machine !== "string") return "json";
+	const trimmed = machine.trim();
+	if (trimmed.startsWith("{")) return "json";
+	if (/^(stateDiagram|flowchart|graph)\b/m.test(trimmed)) return "mermaid";
+	if (/^<\?xml|^<scxml/m.test(trimmed)) return "scxml";
+	if (/^\w+:/m.test(trimmed)) return "yaml";
+	return "xstate";
+}
+function machineInputToConfig(input) {
+	const format = inferMachineFormat(input.machine, input.format);
+	if (typeof input.machine !== "string") {
+		createMachine(input.machine);
+		return input.machine;
+	}
+	if (format === "json") {
+		const config = parseJsonLike(input.machine);
+		createMachine(config);
+		return config;
+	}
+	if (format === "yaml") {
+		const config = parseSimpleYaml(input.machine);
+		createMachine(config);
+		return config;
+	}
+	if (format === "mermaid") {
+		const config = parseMermaid(input.machine);
+		createMachine(config);
+		return config;
+	}
+	if (format === "xstate") {
+		const config = xstateSourceToConfig(input.machine, { profile: input.profile ?? (input.xstateVersion === 6 ? "xstate-v6-alpha" : input.xstateVersion === 5 ? "xstate-v5" : "auto") });
+		createMachine(config);
+		return config;
+	}
+	throw new Error(`${format} source parsing is not supported by graph-tools v1 yet.`);
+}
+function machineInputToGraph(input) {
+	return machineConfigToGraph(machineInputToConfig(input));
+}
+function graphToMermaid(graph) {
+	const machine = graphToMachineConfig(graph);
+	const lines = ["stateDiagram-v2"];
+	if (machine.initial) lines.push(`  [*] --> ${machine.initial}`);
+	for (const [stateKey, state] of Object.entries(machine.states ?? {})) for (const [event, transition] of Object.entries(state.on ?? {})) {
+		const target = typeof transition === "string" ? transition : Array.isArray(transition) ? void 0 : transition.target;
+		if (target) lines.push(`  ${stateKey} --> ${target} : ${event}`);
+	}
+	return lines.join("\n");
+}
+function toYaml(value, indent = 0) {
+	const pad = " ".repeat(indent);
+	if (!value || typeof value !== "object" || Array.isArray(value)) return `${JSON.stringify(value)}`;
+	return Object.entries(value).map(([key, item]) => {
+		if (item && typeof item === "object" && !Array.isArray(item)) return `${pad}${key}:\n${toYaml(item, indent + 2)}`;
+		return `${pad}${key}: ${typeof item === "string" ? item : JSON.stringify(item)}`;
+	}).join("\n");
+}
+function graphToFormat(graph, format) {
+	const config = graphToMachineConfig(graph);
+	if (format === "xstate") return `import { createMachine } from 'xstate';\n\nexport const machine = createMachine(${serializeJS(config, 2)});\n`;
+	if (format === "json") return config;
+	if (format === "yaml") return toYaml(config);
+	if (format === "mermaid") return graphToMermaid(graph);
+	if (format === "scxml") {
+		const machine = config;
+		return `<scxml version="1.0" initial="${machine.initial ?? ""}" name="${machine.id ?? "machine"}"></scxml>`;
+	}
+	return config;
+}
+const colorSchema = _enum([
+	"green",
+	"red",
+	"purple",
+	"blue",
+	"orange",
+	"yellow",
+	"pink",
+	"teal"
+]);
+const stateTypeSchema = _enum([
+	"normal",
+	"parallel",
+	"history",
+	"final"
+]).nullable();
+const actionLocationSchema = union([object({
+	nodeId: string(),
+	group: _enum(["entry", "exit"])
+}), object({
+	edgeId: string(),
+	group: literal("transition")
+})]);
+const createStatePatchSchema = object({
+	op: literal("createState"),
+	description: string().optional(),
+	id: string().optional(),
+	parentId: string(),
+	key: string(),
+	type: stateTypeSchema.optional(),
+	x: number().optional(),
+	y: number().optional(),
+	color: colorSchema.nullable().optional(),
+	initial: boolean().optional()
+});
+const updateStatePatchSchema = object({
+	op: literal("updateState"),
+	description: string().optional(),
+	stateId: string(),
+	key: string().optional(),
+	type: stateTypeSchema.optional(),
+	stateDescription: string().optional(),
+	initialId: string().nullable().optional(),
+	color: colorSchema.nullable().optional(),
+	meta: record(string(), unknown()).nullable().optional(),
+	history: _enum(["shallow", "deep"]).nullable().optional()
+});
+const deleteStatePatchSchema = object({
+	op: literal("deleteState"),
+	description: string().optional(),
+	stateId: string()
+});
+const guardSchema = object({
+	type: string(),
+	code: string().optional(),
+	params: record(string(), unknown()).optional()
+});
+const createTransitionPatchSchema = object({
+	op: literal("createTransition"),
+	description: string().optional(),
+	id: string().optional(),
+	sourceId: string(),
+	targetId: string(),
+	eventType: string(),
+	transitionType: _enum([
+		"normal",
+		"targetless",
+		"reenter"
+	]).optional(),
+	guard: guardSchema.optional(),
+	color: colorSchema.nullable().optional(),
+	transitionDescription: string().nullable().optional()
+});
+const updateTransitionPatchSchema = object({
+	op: literal("updateTransition"),
+	description: string().optional(),
+	transitionId: string(),
+	sourceId: string().optional(),
+	targetId: string().optional(),
+	eventType: string().optional(),
+	transitionType: _enum([
+		"normal",
+		"targetless",
+		"reenter"
+	]).optional(),
+	transitionDescription: string().nullable().optional(),
+	color: colorSchema.nullable().optional(),
+	meta: record(string(), unknown()).nullable().optional()
+});
+const deleteTransitionPatchSchema = object({
+	op: literal("deleteTransition"),
+	description: string().optional(),
+	transitionId: string()
+});
+const createActionPatchSchema = object({
+	op: literal("createAction"),
+	description: string().optional(),
+	location: actionLocationSchema,
+	action: object({
+		id: string().optional(),
+		type: string(),
+		params: record(string(), unknown()).optional()
+	}),
+	index: number().optional()
+});
+const updateActionPatchSchema = object({
+	op: literal("updateAction"),
+	description: string().optional(),
+	location: actionLocationSchema,
+	actionId: string(),
+	data: object({
+		type: string().optional(),
+		params: record(string(), unknown()).optional()
+	})
+});
+const deleteActionPatchSchema = object({
+	op: literal("deleteAction"),
+	description: string().optional(),
+	location: actionLocationSchema,
+	actionId: string()
+});
+const setGuardPatchSchema = object({
+	op: literal("setGuard"),
+	description: string().optional(),
+	edgeId: string(),
+	guard: guardSchema
+});
+const deleteGuardPatchSchema = object({
+	op: literal("deleteGuard"),
+	description: string().optional(),
+	edgeId: string()
+});
+const machinePatchSchema = discriminatedUnion("op", [
+	createStatePatchSchema,
+	updateStatePatchSchema,
+	deleteStatePatchSchema,
+	createTransitionPatchSchema,
+	updateTransitionPatchSchema,
+	deleteTransitionPatchSchema,
+	createActionPatchSchema,
+	updateActionPatchSchema,
+	deleteActionPatchSchema,
+	setGuardPatchSchema,
+	deleteGuardPatchSchema
+]);
+const validationLevelSchema = _enum([
+	"info",
+	"warning",
+	"error"
+]);
+const validationIssueKindSchema = _enum([
+	"correctness",
+	"reachability",
+	"optimization",
+	"maintainability",
+	"security"
+]);
+const validationIssueCodeSchema = _enum([
+	"parse_error",
+	"unsupported_format",
+	"empty_state_key",
+	"invalid_state_key",
+	"duplicate_state_key",
+	"history_initial",
+	"missing_initial",
+	"invalid_initial",
+	"unreachable_state",
+	"final_state_invokes",
+	"invalid_state_children",
+	"empty_parallel",
+	"single_child_compound",
+	"noop_transient_state",
+	"on_done_unreachable",
+	"duplicate_transition",
+	"invalid_delay",
+	"repeated_guard",
+	"transition_never_taken",
+	"missing_guard",
+	"redundant_transition",
+	"missing_delay_implementation",
+	"invalid_final_transition",
+	"invalid_history_transition",
+	"parallel_region_transition",
+	"duplicate_source_name",
+	"undefined_action",
+	"undefined_guard",
+	"undefined_actor"
+]);
+const validationFixKindSchema = _enum([
+	"patch",
+	"rewrite",
+	"advice",
+	"proposedPatch"
+]);
+const validationFixSourceSchema = _enum(["deterministic", "llm"]);
+const AUTO_NAME_PREFIXES = [
+	":invocation:",
+	"inline:",
+	"$auto-"
+];
+const AUTO_NAME_SUBSTRINGS = [
+	":invocation[",
+	"#transition[",
+	"#actor["
+];
+function isAutoGeneratedInlineName(name) {
+	return AUTO_NAME_PREFIXES.some((prefix) => name.startsWith(prefix)) || AUTO_NAME_SUBSTRINGS.some((part) => name.includes(part));
+}
+function getImplementations(graph) {
+	return graph.data.implementations ?? {
+		actions: [],
+		guards: [],
+		actors: [],
+		delays: []
+	};
+}
+function issue(input) {
+	const nodeIds = input.nodeIds ?? [];
+	const edgeIds = input.edgeIds ?? [];
+	return {
+		code: input.code,
+		kind: input.kind,
+		level: input.level,
+		message: input.message,
+		target: {
+			nodeIds,
+			edgeIds
+		},
+		metadata: input.metadata,
+		fixes: input.fixes,
+		source: "deterministic",
+		nodeIds,
+		edgeIds
+	};
+}
+function deleteTransitionFix(edge, title) {
+	return {
+		kind: "patch",
+		source: "deterministic",
+		title,
+		patches: [{
+			op: "deleteTransition",
+			transitionId: edge.id
+		}],
+		confidence: .9
+	};
+}
+function setInitialFix(node, child, title) {
+	return {
+		kind: "patch",
+		source: "deterministic",
+		title,
+		patches: [{
+			op: "updateState",
+			stateId: node.id,
+			initialId: child.id
+		}],
+		confidence: .85
+	};
+}
+function findDuplicateNodes(graph, node, parent) {
+	if (!parent) return [];
+	return graph.nodes.filter((n) => n.parentId === parent.id && n.id !== node.id).filter((childNode) => childNode.data.key === node.data.key);
+}
+function findDuplicateEdges(graph, edge) {
+	return graph.edges.filter((graphEdge) => graphEdge.id !== edge.id && !graphEdge.data.guard && !edge.data.guard && graphEdge.sourceId === edge.sourceId && graphEdge.data.eventType === edge.data.eventType);
+}
+function hasUnconditionalAlways(graph, sourceId) {
+	return graph.edges.some((e) => e.sourceId === sourceId && e.data.eventType === "" && !e.data.guard && e.targetId !== e.sourceId);
+}
+function isTransitionPreempted(graph, edge) {
+	if (edge.data.eventType === "") return false;
+	return hasUnconditionalAlways(graph, edge.sourceId);
+}
+function computeReachableGraphNodes(graph) {
+	const rootNode = graph.nodes.find((n) => n.parentId === null);
+	if (!rootNode) return /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	function getNodeInitialStates(node) {
+		const children = graph.nodes.filter((n) => n.parentId === node.id);
+		if (!children.length) return [];
+		if (node.data.type === "parallel") return children;
+		const initial = children.find((n) => node.data.initialId === n.id);
+		return initial ? [initial] : [];
+	}
+	function dfs(node) {
+		if (visited.has(node.id)) return;
+		visited.add(node.id);
+		getNodeInitialStates(node).forEach((n) => dfs(n));
+		if (node.data.type === "parallel") graph.nodes.filter((n) => n.parentId === node.id).forEach((region) => {
+			getNodeInitialStates(region).forEach((n) => dfs(n));
+		});
+		if (node.data.type === "history") {
+			const parent = graph.nodes.find((n) => n.id === node.parentId);
+			if (parent) if (parent.data.type === "parallel") graph.nodes.filter((n) => n.parentId === parent.id).forEach((region) => {
+				getNodeInitialStates(region).forEach((n) => dfs(n));
+			});
+			else getNodeInitialStates(parent).forEach((n) => dfs(n));
+		}
+		graph.edges.filter((edge) => edge.sourceId === node.id && !isTransitionPreempted(graph, edge)).forEach((edge) => {
+			const target = graph.nodes.find((n) => n.id === edge.targetId);
+			if (target) dfs(target);
+		});
+		let ancestor = graph.nodes.find((n) => n.id === node.parentId);
+		while (ancestor) {
+			graph.edges.filter((edge) => edge.sourceId === ancestor.id && !isTransitionPreempted(graph, edge)).forEach((edge) => {
+				const target = graph.nodes.find((n) => n.id === edge.targetId);
+				if (target) dfs(target);
+			});
+			ancestor = graph.nodes.find((n) => n.id === ancestor.parentId);
+		}
+	}
+	dfs(rootNode);
+	const reachableWithParents = new Set(visited);
+	for (const nodeId of visited) {
+		let node = graph.nodes.find((n) => n.id === nodeId);
+		while (node?.parentId) {
+			reachableWithParents.add(node.parentId);
+			node = graph.nodes.find((n) => n.id === node.parentId);
+		}
+	}
+	return reachableWithParents;
+}
+function getNodeErrors(graph, node) {
+	const errors = [];
+	if (node.data.key.length === 0) errors.push({
+		code: "empty_state_key",
+		kind: "correctness",
+		message: "State key cannot be empty"
+	});
+	const parent = graph.nodes.find((n) => n.id === node.parentId);
+	const isInitial = parent?.data.initialId === node.id;
+	const isHistoryNode = node.data.type === "history";
+	if (isInitial && isHistoryNode) errors.push({
+		code: "history_initial",
+		kind: "correctness",
+		message: "A history node cannot be the initial node. This will cause an infinite loop."
+	});
+	if (findDuplicateNodes(graph, node, parent).length > 0) errors.push({
+		code: "duplicate_state_key",
+		kind: "correctness",
+		message: "A state with that name already exists"
+	});
+	if (node.data.key.includes("#")) errors.push({
+		code: "invalid_state_key",
+		kind: "correctness",
+		message: "State key cannot contain \"#\"",
+		metadata: { character: "#" }
+	});
+	const children = graph.nodes.filter((n) => n.parentId === node.id);
+	if (children.length > 0 && node.data.type !== "parallel" && node.data.type !== "final" && node.data.type !== "history") {
+		const isTargeted = graph.edges.some((edge) => edge.targetId === node.id);
+		if (!node.data.initialId && isTargeted) errors.push({
+			code: "missing_initial",
+			kind: "correctness",
+			message: "Compound state must have an initial state",
+			metadata: {
+				reason: "targeted_compound",
+				childCount: children.length
+			},
+			fixes: children.length === 1 ? [setInitialFix(node, children[0], `Set ${children[0].data.key} as initial state`)] : void 0
+		});
+		else if (node.data.initialId) {
+			if (!children.some((n) => n.id === node.data.initialId)) errors.push({
+				code: "invalid_initial",
+				kind: "correctness",
+				message: "Initial state does not exist",
+				metadata: {
+					initialId: node.data.initialId,
+					childCount: children.length
+				},
+				fixes: children.length === 1 ? [setInitialFix(node, children[0], `Set ${children[0].data.key} as initial state`)] : void 0
+			});
+		}
+	}
+	return errors.length > 0 ? errors : null;
+}
+function getNodeWarningsWithReachability(graph, node, reachableNodes) {
+	const warnings = [];
+	if (!reachableNodes.has(node.id) && node.data.type !== "history") warnings.push({
+		code: "unreachable_state",
+		kind: "reachability",
+		message: "Unreachable state"
+	});
+	if (node.data.type === "final" && (node.data.invokes?.length ?? 0) > 0) warnings.push({
+		code: "final_state_invokes",
+		kind: "correctness",
+		message: "Final state cannot have invocations"
+	});
+	if (node.data.type && ["final", "history"].includes(node.data.type) && graph.nodes.filter((n) => n.parentId === node.id).length > 0) warnings.push({
+		code: "invalid_state_children",
+		kind: "correctness",
+		message: `${node.data.type.charAt(0).toUpperCase() + node.data.type.slice(1)} state cannot have child states`,
+		metadata: { stateType: node.data.type }
+	});
+	if (node.data.type === "parallel" && graph.nodes.filter((n) => n.parentId === node.id).length === 0) warnings.push({
+		code: "empty_parallel",
+		kind: "correctness",
+		message: "Parallel state should have child regions"
+	});
+	const children = graph.nodes.filter((n) => n.parentId === node.id);
+	if (children.length === 1 && node.data.type !== "parallel" && node.data.type !== "final" && node.data.type !== "history") warnings.push({
+		code: "single_child_compound",
+		kind: "optimization",
+		message: "State with single child can be simplified"
+	});
+	if (node.data.type !== "parallel" && node.data.type !== "final" && node.data.type !== "history" && children.length === 0 && (node.data.entry?.length ?? 0) === 0 && (node.data.exit?.length ?? 0) === 0 && (node.data.invokes?.length ?? 0) === 0) {
+		const alwaysEdges = graph.edges.filter((e) => e.sourceId === node.id && e.data.eventType === "");
+		const hasUnconditionalNoop = alwaysEdges.some((e) => !e.data.guard && e.targetId !== e.sourceId && (e.data.actions?.length ?? 0) === 0);
+		const hasMeaningfulAlways = alwaysEdges.some((e) => !!e.data.guard || (e.data.actions?.length ?? 0) > 0);
+		if (hasUnconditionalNoop && !hasMeaningfulAlways) warnings.push({
+			code: "noop_transient_state",
+			kind: "optimization",
+			message: "State has no effect: an unconditional transition exits it immediately, and it has no actions or invocations"
+		});
+	}
+	return warnings.length > 0 ? warnings : null;
+}
+function getOnDoneWarnings(graph, reachableNodes) {
+	const results = [];
+	for (const node of graph.nodes) {
+		const doneEdges = graph.edges.filter((edge) => edge.sourceId === node.id && (edge.data.eventType.startsWith("@statelyai.state.done.") || edge.data.eventType.startsWith("xstate.done.state.")));
+		if (doneEdges.length === 0) continue;
+		const edgeIds = doneEdges.map((e) => e.id);
+		if (node.data.type === "parallel") {
+			const regions = graph.nodes.filter((n) => n.parentId === node.id);
+			const regionsWithoutFinal = [];
+			const regionsWithoutReachableFinal = [];
+			for (const region of regions) {
+				const finalChildren = graph.nodes.filter((n) => n.parentId === region.id).filter((child) => child.data.type === "final");
+				if (finalChildren.length === 0) regionsWithoutFinal.push(region);
+				else if (!finalChildren.some((child) => reachableNodes.has(child.id))) regionsWithoutReachableFinal.push(region);
+			}
+			if (regionsWithoutFinal.length > 0) results.push(issue({
+				code: "on_done_unreachable",
+				kind: "reachability",
+				level: "warning",
+				nodeIds: [node.id],
+				edgeIds,
+				message: "onDone transitions require each parallel region to have a final child state",
+				metadata: { reason: "parallel_region_missing_final" }
+			}));
+			else if (regionsWithoutReachableFinal.length > 0) results.push(issue({
+				code: "on_done_unreachable",
+				kind: "reachability",
+				level: "warning",
+				nodeIds: [node.id],
+				edgeIds,
+				message: "onDone transitions will never trigger: a parallel region has no reachable final child state",
+				metadata: { reason: "parallel_region_final_unreachable" }
+			}));
+		} else {
+			const finalChildren = graph.nodes.filter((n) => n.parentId === node.id).filter((child) => child.data.type === "final");
+			if (finalChildren.length === 0) results.push(issue({
+				code: "on_done_unreachable",
+				kind: "reachability",
+				level: "warning",
+				nodeIds: [node.id],
+				edgeIds,
+				message: "onDone transitions require a final child state to trigger",
+				metadata: { reason: "missing_final_child" }
+			}));
+			else if (!finalChildren.some((child) => reachableNodes.has(child.id))) results.push(issue({
+				code: "on_done_unreachable",
+				kind: "reachability",
+				level: "warning",
+				nodeIds: [node.id],
+				edgeIds,
+				message: "onDone transitions will never trigger: no reachable final child state",
+				metadata: { reason: "final_child_unreachable" }
+			}));
+		}
+	}
+	return results;
+}
+function getEdgeErrors(graph, edge) {
+	const errors = [];
+	const duplicates = findDuplicateEdges(graph, edge);
+	if (duplicates.length > 0) errors.push({
+		code: "duplicate_transition",
+		kind: "correctness",
+		message: "Two events with the same name and source state are not allowed",
+		fixes: graph.edges.findIndex((e) => e.id === edge.id) > graph.edges.findIndex((e) => e.id === duplicates[0].id) ? [deleteTransitionFix(edge, "Delete duplicate transition")] : void 0
+	});
+	if (edge.data.eventType.startsWith("xstate.after.")) {
+		const delayPart = edge.data.eventType.replace(/^xstate\.after\./, "").split(".")[0];
+		if (delayPart !== void 0) {
+			const numericValue = Number(delayPart);
+			if (!Number.isNaN(numericValue) && numericValue < 0) errors.push({
+				code: "invalid_delay",
+				kind: "correctness",
+				message: "Delay value cannot be negative",
+				metadata: { delay: numericValue }
+			});
+		}
+	}
+	return errors.length > 0 ? errors : null;
+}
+function getEdgeWarnings(graph, edge) {
+	const warnings = [];
+	const group = graph.edges.filter((e) => e.sourceId === edge.sourceId && e.data.eventType === edge.data.eventType);
+	if (edge.data.guard && group.length > 1) {
+		const guardType = edge.data.guard.type;
+		const withRepeatedGuard = group.filter((e) => e.data.guard?.type === guardType);
+		if (withRepeatedGuard.length > 1) warnings.push({
+			code: "repeated_guard",
+			kind: "maintainability",
+			message: `Found ${withRepeatedGuard.length} guards with the name \`${guardType}\``,
+			metadata: {
+				guardType,
+				count: withRepeatedGuard.length
+			}
+		});
+	}
+	const edgeIndex = group.findIndex((e) => e.id === edge.id);
+	if (edgeIndex > 0 && group.slice(0, edgeIndex).some((e) => !e.data.guard) || isTransitionPreempted(graph, edge)) warnings.push({
+		code: "transition_never_taken",
+		kind: "reachability",
+		message: "This transition will never be taken",
+		fixes: edgeIndex > 0 && group.slice(0, edgeIndex).some((e) => !e.data.guard) ? [deleteTransitionFix(edge, "Delete unreachable transition")] : void 0
+	});
+	if (group.length > 1 && !edge.data.guard && edgeIndex < group.length - 1) warnings.push({
+		code: "missing_guard",
+		kind: "correctness",
+		message: "This transition is missing a guard, so transitions after it will never be taken"
+	});
+	if (edgeIndex > 0) {
+		const prevEdge = group[edgeIndex - 1];
+		const sameTarget = prevEdge.targetId === edge.targetId;
+		const sameActions = JSON.stringify(prevEdge.data.actions) === JSON.stringify(edge.data.actions);
+		if (sameTarget && sameActions) warnings.push({
+			code: "redundant_transition",
+			kind: "optimization",
+			message: "Redundant transition: same target and actions as previous transition",
+			fixes: [deleteTransitionFix(edge, "Delete redundant transition")]
+		});
+	}
+	if (edge.data.eventType.startsWith("xstate.after.")) {
+		const delayPart = edge.data.eventType.replace(/^xstate\.after\./, "").split(".")[0];
+		if (delayPart !== void 0 && Number.isNaN(Number(delayPart))) {
+			if (!getImplementations(graph).delays.find((d) => d.name === delayPart)?.code?.body?.trim()) warnings.push({
+				code: "missing_delay_implementation",
+				kind: "correctness",
+				message: `Missing delay implementation for "${delayPart}"`,
+				metadata: { delay: delayPart }
+			});
+		}
+	}
+	const sourceNode = graph.nodes.find((n) => n.id === edge.sourceId);
+	if (sourceNode && sourceNode.data.type === "final") warnings.push({
+		code: "invalid_final_transition",
+		kind: "correctness",
+		message: "Final state cannot transition to other states",
+		fixes: [deleteTransitionFix(edge, "Delete transition from final state")]
+	});
+	if (sourceNode && sourceNode.data.type === "history") warnings.push({
+		code: "invalid_history_transition",
+		kind: "correctness",
+		message: "History state cannot have transitions",
+		fixes: [deleteTransitionFix(edge, "Delete transition from history state")]
+	});
+	const targetNode = graph.nodes.find((n) => n.id === edge.targetId);
+	if (sourceNode && targetNode && sourceNode.parentId === targetNode.parentId && sourceNode.id !== targetNode.id) {
+		const parentNode = graph.nodes.find((n) => n.id === sourceNode.parentId);
+		if (parentNode && parentNode.data.type === "parallel") warnings.push({
+			code: "parallel_region_transition",
+			kind: "correctness",
+			message: "Parallel regions should communicate via events, not transitions"
+		});
+	}
+	return warnings.length > 0 ? warnings : null;
+}
+function getSourceWarnings(graph) {
+	const results = [];
+	const impls = getImplementations(graph);
+	const groups = [
+		{
+			type: "action",
+			items: impls.actions
+		},
+		{
+			type: "guard",
+			items: impls.guards
+		},
+		{
+			type: "actor",
+			items: impls.actors
+		},
+		{
+			type: "delay",
+			items: impls.delays
+		}
+	];
+	for (const group of groups) {
+		const seen = /* @__PURE__ */ new Map();
+		for (const item of group.items) {
+			if (!item.name) continue;
+			seen.set(item.name, (seen.get(item.name) ?? 0) + 1);
+		}
+		for (const [name, count] of seen) if (count > 1) results.push(issue({
+			code: "duplicate_source_name",
+			kind: "maintainability",
+			level: "warning",
+			message: `Duplicate ${group.type} source name "${name}" (${count} occurrences)`,
+			metadata: {
+				sourceType: group.type,
+				name,
+				count
+			}
+		}));
+	}
+	return results;
+}
+function getSourceRestrictionErrors(graph, sourceAllowed) {
+	if (!sourceAllowed) return [];
+	const results = [];
+	const impls = getImplementations(graph);
+	const actionIds = new Set(impls.actions.map((a) => a.id));
+	const guardIds = new Set(impls.guards.map((g) => g.id));
+	const actorIds = new Set(impls.actors.map((a) => a.id));
+	const isInvalidActionType = (type) => {
+		if (!type) return true;
+		if (actionIds.has(type)) return false;
+		if (type.startsWith("xstate.")) return false;
+		if (isAutoGeneratedInlineName(type)) return false;
+		return true;
+	};
+	const formatActionMsg = (type) => type ? `Action "${type}" is not a defined action implementation` : "Action is not selected";
+	if (sourceAllowed.actions === "predefined") {
+		for (const node of graph.nodes) {
+			for (const action of node.data.entry ?? []) if (isInvalidActionType(action.type)) results.push(issue({
+				code: "undefined_action",
+				kind: "correctness",
+				level: "error",
+				nodeIds: [node.id],
+				message: formatActionMsg(action.type)
+			}));
+			for (const action of node.data.exit ?? []) if (isInvalidActionType(action.type)) results.push(issue({
+				code: "undefined_action",
+				kind: "correctness",
+				level: "error",
+				nodeIds: [node.id],
+				message: formatActionMsg(action.type)
+			}));
+		}
+		for (const edge of graph.edges) for (const action of edge.data.actions ?? []) if (isInvalidActionType(action.type)) results.push(issue({
+			code: "undefined_action",
+			kind: "correctness",
+			level: "error",
+			edgeIds: [edge.id],
+			message: formatActionMsg(action.type)
+		}));
+	}
+	if (sourceAllowed.guards === "predefined") for (const edge of graph.edges) {
+		const guard = edge.data.guard;
+		if (!guard) continue;
+		const type = guard.type;
+		if (!type || !guardIds.has(type) && !type.startsWith("inline:") && !isAutoGeneratedInlineName(type)) results.push(issue({
+			code: "undefined_guard",
+			kind: "correctness",
+			level: "error",
+			edgeIds: [edge.id],
+			message: type ? `Guard "${type}" is not a defined guard implementation` : "Guard is not selected"
+		}));
+	}
+	if (sourceAllowed.actors === "predefined") for (const node of graph.nodes) for (const invoke of node.data.invokes ?? []) {
+		const src = invoke.src;
+		if (!src || !actorIds.has(src) && !isAutoGeneratedInlineName(src)) results.push(issue({
+			code: "undefined_actor",
+			kind: "correctness",
+			level: "error",
+			nodeIds: [node.id],
+			message: src ? `Actor "${src}" is not a defined actor implementation` : "Actor is not selected"
+		}));
+	}
+	return results;
+}
+function pushMessages(results, messages, level, nodeIds, edgeIds) {
+	messages?.forEach((message) => {
+		results.push(issue({
+			...message,
+			level,
+			nodeIds,
+			edgeIds
+		}));
+	});
+}
+function validateGraph(graph, sourceAllowed) {
+	const results = [];
+	const nonTempNodes = graph.nodes.filter((n) => !n.data?.temp);
+	const nonTempEdges = graph.edges.filter((e) => !e.data?.temp);
+	const nonTempGraph = {
+		...graph,
+		nodes: nonTempNodes,
+		edges: nonTempEdges
+	};
+	const reachableNodes = computeReachableGraphNodes(nonTempGraph);
+	for (const node of nonTempNodes) {
+		pushMessages(results, getNodeErrors(nonTempGraph, node), "error", [node.id], []);
+		pushMessages(results, getNodeWarningsWithReachability(nonTempGraph, node, reachableNodes), "warning", [node.id], []);
+	}
+	for (const edge of nonTempEdges) {
+		pushMessages(results, getEdgeErrors(nonTempGraph, edge), "error", [], [edge.id]);
+		pushMessages(results, getEdgeWarnings(nonTempGraph, edge), "warning", [], [edge.id]);
+	}
+	results.push(...getOnDoneWarnings(nonTempGraph, reachableNodes));
+	results.push(...getSourceWarnings(nonTempGraph));
+	results.push(...getSourceRestrictionErrors(nonTempGraph, sourceAllowed));
+	return results;
+}
+function validationOk(issues) {
+	return !issues.some((item) => item.level === "error");
+}
+const validationIssueTargetSchema = object({
+	nodeIds: array(string()).optional(),
+	edgeIds: array(string()).optional(),
+	source: object({
+		path: string().optional(),
+		start: number().optional(),
+		end: number().optional()
+	}).optional()
+});
+const validationFixSchema = object({
+	kind: validationFixKindSchema,
+	source: validationFixSourceSchema,
+	title: string(),
+	patches: array(unknown()).optional(),
+	output: unknown().optional(),
+	diff: unknown().optional(),
+	confidence: number().optional(),
+	rationale: string().optional(),
+	rank: number().optional(),
+	postValidation: object({
+		ok: boolean(),
+		remainingIssueCodes: array(validationIssueCodeSchema)
+	}).optional()
+});
+const validationIssueSchema = object({
+	code: validationIssueCodeSchema,
+	kind: validationIssueKindSchema,
+	level: validationLevelSchema,
+	message: string(),
+	target: validationIssueTargetSchema,
+	metadata: record(string(), unknown()).optional(),
+	fixes: array(validationFixSchema).optional(),
+	source: _enum(["deterministic", "llm"]).optional(),
+	nodeIds: array(string()),
+	edgeIds: array(string())
+});
+const machineFormatSchema = _enum([
+	"xstate",
+	"json",
+	"yaml",
+	"scxml",
+	"mermaid"
+]);
+const xstateSourceProfileSchema = _enum([
+	"auto",
+	"xstate-v5",
+	"xstate-v6-alpha"
+]);
+const machineInputSchema = object({
+	machine: union([record(string(), unknown()), string()]),
+	format: machineFormatSchema.optional(),
+	profile: xstateSourceProfileSchema.optional(),
+	xstateVersion: union([literal(5), literal(6)]).optional()
+});
+const graphSchema = record(string(), unknown());
+function asError(error) {
+	return { message: error instanceof Error ? error.message : String(error) };
+}
+function simImplementations(graph, guardState) {
+	const guards = {};
+	for (const edge of graph.edges) if (edge.data.guard) {
+		const guardType = edge.data.guard.type;
+		guards[guardType] = ({ event }) => {
+			if (event["@xstate.guard"] === guardType) return true;
+			return guardState?.[guardType] ?? false;
+		};
+	}
+	return { guards };
+}
+const operations = {
+	validate_machine: {
+		description: "Validate a machine without writing files.",
+		input: machineInputSchema,
+		output: object({
+			ok: boolean(),
+			issues: array(validationIssueSchema)
+		}),
+		async handler(input) {
+			try {
+				const issues = validateGraph(machineInputToGraph(input));
+				return {
+					ok: validationOk(issues),
+					issues
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					issues: [{
+						code: "parse_error",
+						kind: "correctness",
+						level: "error",
+						message: asError(error).message,
+						target: {
+							nodeIds: [],
+							edgeIds: []
+						},
+						source: "deterministic",
+						nodeIds: [],
+						edgeIds: []
+					}]
+				};
+			}
+		}
+	},
+	convert_to_graph: {
+		description: "Convert a machine into an internal graph for patching.",
+		input: machineInputSchema,
+		output: object({ graph: graphSchema }),
+		async handler(input) {
+			return { graph: machineInputToGraph(input) };
+		}
+	},
+	convert_format: {
+		description: "Convert a machine or graph to a machine format.",
+		input: object({
+			machine: union([record(string(), unknown()), string()]).optional(),
+			graph: graphSchema.optional(),
+			format: machineFormatSchema.optional(),
+			to: machineFormatSchema
+		}).refine((value) => Boolean(value.machine) !== Boolean(value.graph), { message: "Provide exactly one of machine or graph." }),
+		output: object({
+			format: machineFormatSchema,
+			output: union([record(string(), unknown()), string()])
+		}),
+		async handler(input) {
+			const graph = input.graph ?? machineInputToGraph({
+				machine: input.machine,
+				format: input.format
+			});
+			return {
+				format: input.to,
+				output: graphToFormat(graph, input.to)
+			};
+		}
+	},
+	apply_patch: {
+		description: "Apply semantic machine patches to a graph without writing files.",
+		input: object({
+			graph: graphSchema,
+			patches: array(machinePatchSchema),
+			outputFormat: machineFormatSchema.default("json")
+		}),
+		output: union([object({
+			ok: literal(true),
+			graph: graphSchema,
+			machine: union([record(string(), unknown()), string()]),
+			format: machineFormatSchema,
+			diff: unknown(),
+			patches: array(machinePatchSchema)
+		}), object({
+			ok: literal(false),
+			reason: string(),
+			errors: array(object({ message: string() }))
+		})]),
+		async handler(input) {
+			try {
+				const graph = applyGraphPatches(input.graph, input.patches);
+				createMachine(graphToMachineConfig(graph));
+				const diff = diffGraphsSemantically(input.graph, graph).diff;
+				return {
+					ok: true,
+					graph,
+					machine: graphToFormat(graph, input.outputFormat),
+					format: input.outputFormat,
+					diff,
+					patches: input.patches
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					reason: "validation",
+					errors: [asError(error)]
+				};
+			}
+		}
+	},
+	diff_machines: {
+		description: "Compute semantic diff between two machines.",
+		input: object({
+			left: machineInputSchema,
+			right: machineInputSchema,
+			includePatches: boolean().optional()
+		}),
+		output: object({
+			diff: unknown(),
+			patches: array(machinePatchSchema).optional()
+		}),
+		async handler(input) {
+			return { diff: diffGraphsSemantically(machineInputToGraph(input.left), machineInputToGraph(input.right)).diff };
+		}
+	},
+	generate_paths: {
+		description: "Generate paths through a machine.",
+		input: machineInputSchema.extend({
+			targetPath: array(string()).optional(),
+			kind: _enum(["shortest", "simple"]).default("shortest"),
+			max: number().int().positive().optional()
+		}),
+		output: object({ paths: array(unknown()) }),
+		async handler(input) {
+			const result = generateGraphPathsData(machineInputToGraph(input), {
+				strategy: input.kind,
+				reduceDuplicates: false,
+				preferTransitionCoverage: false,
+				limit: input.max
+			});
+			return { paths: input.targetPath ? result.paths.filter((path) => path.finalStatePath === input.targetPath.join(".")) : result.paths };
+		}
+	},
+	simulate: {
+		description: "Simulate one event from a machine state.",
+		input: machineInputSchema.extend({
+			stateValue: unknown(),
+			event: object({ type: string() }).passthrough(),
+			guardState: record(string(), boolean()).optional()
+		}),
+		output: object({
+			nextStateValue: unknown(),
+			actions: array(unknown()),
+			changed: boolean(),
+			microsteps: array(unknown()).optional()
+		}),
+		async handler(input) {
+			const graph = machineInputToGraph(input);
+			const machine = createMachine(graphToMachineConfig(graph)).provide(simImplementations(graph, input.guardState));
+			const snapshot = machine.resolveState({
+				value: input.stateValue,
+				context: {},
+				status: "active"
+			});
+			const [nextSnapshot, actions] = transition(machine, snapshot, input.event);
+			return {
+				nextStateValue: nextSnapshot.value,
+				actions,
+				changed: JSON.stringify(nextSnapshot.value) !== JSON.stringify(snapshot.value)
+			};
+		}
+	}
+};
+
 //#endregion
 //#region ../editor-sync/src/internal/sourceLocations.ts
 const sourceFileUris = /* @__PURE__ */ new WeakMap();
 function collectXStateSourceLocations(sourceText, document, options = {}) {
-	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$1(document.fileName));
+	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
 	const uri = document.uri?.toString() ?? document.fileName;
 	sourceFileUris.set(sourceFile, uri);
 	const bindings = collectBindings(sourceFile, uri, document.fileName, options);
@@ -119,13 +3205,18 @@ function collectXStateSourceLocations(sourceText, document, options = {}) {
 	const root = findMachineConfigObjectLiteral(sourceFile, bindings);
 	if (!root) return;
 	const states = [];
-	collectStateLocations(root, [], states, bindings, staticValues, root);
+	const statesObjectLocations = [];
+	collectStateLocations(root, [], states, statesObjectLocations, bindings, staticValues, root);
+	const rootProfile = detectXStateSourceProfile(sourceText);
+	const referencedStateSymbols = new Set([...states, ...statesObjectLocations].map((state) => state.symbol).filter((symbol) => typeof symbol === "string"));
 	return {
 		version: 1,
+		profile: rootProfile === "xstate-v6-alpha" || [...referencedStateSymbols].some((symbol) => detectXStateSourceProfile(bindings.get(symbol)?.sourceFile.text ?? "") === "xstate-v6-alpha") ? "xstate-v6-alpha" : rootProfile,
 		root: {
 			uri,
-			range: toSourceRange(sourceFile, root)
+			range: toSourceRange$1(sourceFile, root)
 		},
+		statesObject: statesObjectLocations[0],
 		states,
 		staticValues: collectStaticValueReferences(sourceFile, uri, root, staticValues)
 	};
@@ -143,7 +3234,7 @@ function collectStaticValueBindings(sourceFile) {
 					kind: "const",
 					symbol: declaration.name.text,
 					value,
-					valueRange: toSourceRange(sourceFile, declaration.initializer)
+					valueRange: toSourceRange$1(sourceFile, declaration.initializer)
 				});
 			}
 			continue;
@@ -158,15 +3249,18 @@ function collectStaticValueBindings(sourceFile) {
 				kind: "enumMember",
 				symbol,
 				value,
-				valueRange: toSourceRange(sourceFile, member.initializer)
+				valueRange: toSourceRange$1(sourceFile, member.initializer)
 			});
 		}
 	}
 	return bindings;
 }
-function collectBindings(sourceFile, uri, fileName, options) {
+function collectBindings(sourceFile, uri, fileName, options, cache = /* @__PURE__ */ new Map()) {
+	const cached = cache.get(fileName);
+	if (cached) return cached;
 	const bindings = collectTopLevelBindings(sourceFile, uri);
-	addImportedBindings(bindings, sourceFile, uri, fileName, options);
+	cache.set(fileName, bindings);
+	addImportedBindings(bindings, sourceFile, uri, fileName, options, cache);
 	return bindings;
 }
 function collectTopLevelBindings(sourceFile, uri) {
@@ -198,7 +3292,7 @@ function collectTopLevelBindings(sourceFile, uri) {
 	}
 	return bindings;
 }
-function addImportedBindings(bindings, sourceFile, uri, fileName, options) {
+function addImportedBindings(bindings, sourceFile, uri, fileName, options, cache) {
 	const resolver = options.resolver;
 	if (!resolver) return;
 	for (const statement of sourceFile.statements) {
@@ -210,9 +3304,9 @@ function addImportedBindings(bindings, sourceFile, uri, fileName, options) {
 			uri
 		}, statement.moduleSpecifier.text);
 		if (!importedDocument) continue;
-		const importedSourceFile = ts$1.createSourceFile(importedDocument.fileName, importedDocument.text, ts$1.ScriptTarget.Latest, true, getScriptKind$1(importedDocument.fileName));
+		const importedSourceFile = ts$1.createSourceFile(importedDocument.fileName, importedDocument.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(importedDocument.fileName));
 		sourceFileUris.set(importedSourceFile, importedDocument.uri);
-		const importedBindings = collectBindings(importedSourceFile, importedDocument.uri, importedDocument.fileName, options);
+		const importedBindings = collectBindings(importedSourceFile, importedDocument.uri, importedDocument.fileName, options, cache);
 		for (const element of namedBindings.elements) {
 			const importedName = element.propertyName?.text ?? element.name.text;
 			const binding = importedBindings.get(importedName);
@@ -235,11 +3329,20 @@ function findMachineConfigObjectLiteral(sourceFile, bindings) {
 	visit(sourceFile);
 	return found;
 }
-function collectStateLocations(stateObject, parentPath, locations, bindings, staticValues, root) {
-	const statesObject = getObjectLiteralProperty(stateObject, "states");
+function collectStateLocations(stateObject, parentPath, locations, statesObjectLocations, bindings, staticValues, root) {
+	const statesObject = resolveObjectLiteralProperty(stateObject, "states", bindings);
 	if (!statesObject) return;
-	for (const property of statesObject.properties) {
-		const resolved = resolveStateProperty(property, bindings, staticValues, root);
+	statesObjectLocations.push({
+		uri: statesObject.uri,
+		path: parentPath,
+		kind: statesObject.kind,
+		symbol: statesObject.symbol,
+		keyRange: statesObject.keyRange,
+		referenceRange: statesObject.referenceRange,
+		range: toSourceRange$1(statesObject.sourceFile, statesObject.object)
+	});
+	for (const property of statesObject.object.properties) {
+		const resolved = resolveStateProperty(property, statesObject.bindings, staticValues, root);
 		if (!resolved) continue;
 		const path = [...parentPath, resolved.key];
 		locations.push({
@@ -251,9 +3354,9 @@ function collectStateLocations(stateObject, parentPath, locations, bindings, sta
 			referenceRange: resolved.referenceRange,
 			keySource: resolved.keySource,
 			keyReplacementText: resolved.keyReplacementText,
-			range: toSourceRange(resolved.sourceFile, resolved.stateObject)
+			range: toSourceRange$1(resolved.sourceFile, resolved.stateObject)
 		});
-		collectStateLocations(resolved.stateObject, path, locations, resolved.bindings, staticValues, root);
+		collectStateLocations(resolved.stateObject, path, locations, statesObjectLocations, resolved.bindings, staticValues, root);
 	}
 }
 function resolveStateProperty(property, bindings, staticValues, root) {
@@ -264,8 +3367,8 @@ function resolveStateProperty(property, bindings, staticValues, root) {
 			key: property.name.text,
 			kind: binding.kind,
 			symbol: property.name.text,
-			keyRange: toSourceRange(property.getSourceFile(), property.name),
-			referenceRange: toSourceRange(property.getSourceFile(), property.name),
+			keyRange: toSourceRange$1(property.getSourceFile(), property.name),
+			referenceRange: toSourceRange$1(property.getSourceFile(), property.name),
 			stateObject: binding.node,
 			sourceFile: binding.sourceFile,
 			uri: binding.uri,
@@ -279,7 +3382,7 @@ function resolveStateProperty(property, bindings, staticValues, root) {
 	if (inlineObject) return {
 		key: resolvedKey.key,
 		kind: "inline",
-		keyRange: toSourceRange(property.getSourceFile(), property.name),
+		keyRange: toSourceRange$1(property.getSourceFile(), property.name),
 		keySource: resolvedKey.keySource,
 		keyReplacementText: resolvedKey.keyReplacementText,
 		stateObject: inlineObject,
@@ -294,8 +3397,8 @@ function resolveStateProperty(property, bindings, staticValues, root) {
 			key: resolvedKey.key,
 			kind: binding.kind,
 			symbol: property.initializer.text,
-			keyRange: toSourceRange(property.getSourceFile(), property.name),
-			referenceRange: toSourceRange(property.getSourceFile(), property.initializer),
+			keyRange: toSourceRange$1(property.getSourceFile(), property.name),
+			referenceRange: toSourceRange$1(property.getSourceFile(), property.initializer),
 			keySource: resolvedKey.keySource,
 			keyReplacementText: resolvedKey.keyReplacementText,
 			stateObject: binding.node,
@@ -327,11 +3430,34 @@ function resolveIdentifierObject(expression, bindings) {
 	const binding = bindings.get(unwrapped.text);
 	return binding?.kind === "objectReference" ? binding.node : null;
 }
-function getObjectLiteralProperty(objectLiteral, propertyName) {
+function resolveObjectLiteralProperty(objectLiteral, propertyName, bindings) {
 	for (const property of objectLiteral.properties) {
 		if (!ts$1.isPropertyAssignment(property)) continue;
 		if (getPropertyNameText$1(property.name) !== propertyName) continue;
-		return unwrapObjectLiteralExpression(property.initializer);
+		const inlineObject = unwrapObjectLiteralExpression(property.initializer);
+		if (inlineObject) return {
+			object: inlineObject,
+			kind: "inline",
+			keyRange: toSourceRange$1(property.getSourceFile(), property.name),
+			sourceFile: property.getSourceFile(),
+			uri: getSourceFileUri(property.getSourceFile()),
+			bindings
+		};
+		if (ts$1.isIdentifier(property.initializer)) {
+			const binding = bindings.get(property.initializer.text);
+			if (binding?.kind !== "objectReference") return null;
+			return {
+				object: binding.node,
+				kind: binding.kind,
+				symbol: property.initializer.text,
+				keyRange: toSourceRange$1(property.getSourceFile(), property.name),
+				referenceRange: toSourceRange$1(property.getSourceFile(), property.initializer),
+				sourceFile: binding.sourceFile,
+				uri: binding.uri,
+				bindings: binding.bindings
+			};
+		}
+		return null;
 	}
 	return null;
 }
@@ -383,7 +3509,7 @@ function collectStaticValueReferences(sourceFile, uri, root, staticValues) {
 			const binding = getStaticValueBindingForExpression(node.expression, staticValues);
 			if (binding && !isStateKeyComputedPropertyName(node)) references.push({
 				uri,
-				range: toSourceRange(sourceFile, node),
+				range: toSourceRange$1(sourceFile, node),
 				value: binding.value
 			});
 			return;
@@ -396,7 +3522,7 @@ function collectStaticValueReferences(sourceFile, uri, root, staticValues) {
 		if (binding) {
 			references.push({
 				uri,
-				range: toSourceRange(sourceFile, node),
+				range: toSourceRange$1(sourceFile, node),
 				value: binding.value
 			});
 			return;
@@ -478,7 +3604,7 @@ function unwrapExpression$1(expression) {
 		return current;
 	}
 }
-function toSourceRange(sourceFile, node) {
+function toSourceRange$1(sourceFile, node) {
 	const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
 	const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
 	return {
@@ -488,7 +3614,7 @@ function toSourceRange(sourceFile, node) {
 		endChar: end.character
 	};
 }
-function getScriptKind$1(fileName) {
+function getScriptKind$2(fileName) {
 	if (fileName.endsWith(".tsx")) return ts$1.ScriptKind.TSX;
 	if (fileName.endsWith(".jsx")) return ts$1.ScriptKind.JSX;
 	if (fileName.endsWith(".js")) return ts$1.ScriptKind.JS;
@@ -512,7 +3638,7 @@ function parseSourceToMachine(text, document, options = {}) {
 		range: location.range,
 		newText: JSON.stringify(location.value)
 	}));
-	const stateReplacements = sourceLocations.states.filter((location) => location.path.length === 1 && location.keyRange).flatMap((location) => {
+	const stateReplacements = sourceLocations.states.filter((location) => location.path.length === 1 && location.keyRange && !sourceLocations.statesObject?.referenceRange).flatMap((location) => {
 		const keyRange = location.keyRange;
 		const keyReplacement = location.keyReplacementText ? [{
 			range: keyRange,
@@ -530,7 +3656,93 @@ function parseSourceToMachine(text, document, options = {}) {
 			newText: `${location.path[0]}: ${stateText}`
 		}];
 	});
-	return applySourceRangeReplacements(text, [...staticValueReplacements, ...stateReplacements].filter(removeOverlappingRanges).sort(compareSourceRangesDescending));
+	const statesObjectReplacements = sourceLocations.statesObject?.referenceRange && sourceLocations.statesObject.kind !== "inline" ? (() => {
+		const statesText = readHydratedStatesObject(sourceLocations.statesObject.uri, sourceLocations.statesObject.range, sourceLocations.states, options.resolver);
+		return statesText ? [{
+			range: sourceLocations.statesObject.referenceRange,
+			newText: statesText
+		}] : [];
+	})() : [];
+	const importReplacements = collectHydratedImportReplacements(text, document, new Set([...sourceLocations.states.filter((location) => location.path.length === 1 && location.referenceRange).map((location) => location.symbol).filter((symbol) => typeof symbol === "string"), ...sourceLocations.statesObject?.symbol ? [sourceLocations.statesObject.symbol] : []]));
+	const hydratedText = applySourceRangeReplacements(text, [
+		...staticValueReplacements,
+		...stateReplacements,
+		...statesObjectReplacements,
+		...importReplacements
+	].filter(removeOverlappingRanges).sort(compareSourceRangesDescending));
+	if (sourceLocations.profile === "xstate-v6-alpha") return `import { createMachine } from "xstate";
+
+export const machine = createMachine(${serializeJS(xstateSourceToConfig(hydratedText, { profile: "xstate-v6-alpha" }), 0)});
+`;
+	return hydratedText;
+}
+function readHydratedStatesObject(uri, range, states, resolver) {
+	if (!resolver) return null;
+	const document = resolver.read(uri);
+	if (!document) return null;
+	const replacements = states.filter((state) => state.path.length === 1 && state.referenceRange).flatMap((state) => {
+		const stateText = readSourceRange(state.uri, state.range, resolver);
+		if (!stateText || !state.referenceRange) return [];
+		const isShorthand = state.keyRange && areSourceRangesEqual(state.referenceRange, state.keyRange);
+		return [{
+			range: state.referenceRange,
+			newText: isShorthand ? `${state.path[0]}: ${stateText}` : stateText
+		}];
+	});
+	return applySourceRangeReplacementsToSlice(document.text, range, replacements);
+}
+function applySourceRangeReplacementsToSlice(text, range, replacements) {
+	const sliceStart = offsetAtRangePosition(text, range.startLine, range.startChar);
+	const sliceEnd = offsetAtRangePosition(text, range.endLine, range.endChar);
+	let updated = text.slice(sliceStart, sliceEnd);
+	for (const replacement of replacements.sort(compareSourceRangesDescending)) {
+		const start = offsetAtRangePosition(text, replacement.range.startLine, replacement.range.startChar);
+		const end = offsetAtRangePosition(text, replacement.range.endLine, replacement.range.endChar);
+		if (start < sliceStart || end > sliceEnd) continue;
+		const localStart = start - sliceStart;
+		const localEnd = end - sliceStart;
+		updated = `${updated.slice(0, localStart)}${replacement.newText}${updated.slice(localEnd)}`;
+	}
+	return updated;
+}
+function collectHydratedImportReplacements(text, document, hydratedSymbols) {
+	if (hydratedSymbols.size === 0) return [];
+	const sourceFile = ts$1.createSourceFile(document.fileName, text, ts$1.ScriptTarget.Latest, true, getScriptKind$1(document.fileName));
+	const replacements = [];
+	for (const statement of sourceFile.statements) {
+		if (!ts$1.isImportDeclaration(statement) || !ts$1.isStringLiteral(statement.moduleSpecifier)) continue;
+		if (!statement.moduleSpecifier.text.startsWith(".")) continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (!namedBindings || !ts$1.isNamedImports(namedBindings)) continue;
+		const importedNames = namedBindings.elements.map((element) => element.name.text);
+		if (importedNames.length === 0 || !importedNames.every((name) => hydratedSymbols.has(name))) continue;
+		replacements.push({
+			range: toSourceRange(sourceFile, statement, { includeTrailingNewline: true }),
+			newText: ""
+		});
+	}
+	return replacements;
+}
+function toSourceRange(sourceFile, node, options = {}) {
+	const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+	let endOffset = node.getEnd();
+	if (options.includeTrailingNewline) {
+		const match = sourceFile.text.slice(endOffset).match(/^\r?\n/);
+		if (match) endOffset += match[0].length;
+	}
+	const end = sourceFile.getLineAndCharacterOfPosition(endOffset);
+	return {
+		startLine: start.line,
+		startChar: start.character,
+		endLine: end.line,
+		endChar: end.character
+	};
+}
+function getScriptKind$1(fileName) {
+	if (fileName.endsWith(".tsx")) return ts$1.ScriptKind.TSX;
+	if (fileName.endsWith(".jsx")) return ts$1.ScriptKind.JSX;
+	if (fileName.endsWith(".js")) return ts$1.ScriptKind.JS;
+	return ts$1.ScriptKind.TS;
 }
 function removeOverlappingRanges(replacement, index, replacements) {
 	return !replacements.some((candidate, candidateIndex) => {