@statelyai/sdk 0.12.0 → 0.12.2

package/dist/sync.mjs

@@ -1,5 +1,5 @@
 import { createStatelyClient } from "./studio.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-D12GTMBp.mjs";
+import { d as xstateSourceToConfig, f as findStatelyPragmaAttachments, i as detectXStateSourceProfile, m as upsertStatelyPragma, p as getStatelyPragma, s as graphToXStateTS, t as INLINE_EXPRESSION_DIRECTIVE_FIELDS, u as serializeJS } from "./dist-C-AdA8Iw.mjs";
 import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
@@ -11,8 +11,6 @@ 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) {
@@ -109,3575 +107,6 @@ function getLineStarts(text) {
 	return lineStarts;
 }
 
-//#endregion
-//#region ../graph-tools/dist/index.mjs
-/**
-* Converts a graph to an adjacency list representation.
-*
-* @example
-* ```ts
-* import { createGraph, toAdjacencyList } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: { a: {}, b: {}, c: {} },
-*   edges: [{ source: 'a', target: 'b' }, { source: 'a', target: 'c' }],
-* });
-*
-* toAdjacencyList(graph);
-* // { a: ['b', 'c'], b: [], c: [] }
-* ```
-*/
-function toAdjacencyList(graph) {
-	const adj = {};
-	for (const node of graph.nodes) adj[node.id] = [];
-	for (const edge of graph.edges) {
-		adj[edge.sourceId]?.push(edge.targetId);
-		if (graph.mode !== "directed") adj[edge.targetId]?.push(edge.sourceId);
-	}
-	return adj;
-}
-/**
-* Parses an adjacency list into a graph.
-*
-* @example
-* ```ts
-* import { fromAdjacencyList } from '@statelyai/graph';
-*
-* const graph = fromAdjacencyList({
-*   a: ['b', 'c'],
-*   b: ['c'],
-*   c: [],
-* });
-*
-* graph.nodes; // [{id: 'a', ...}, {id: 'b', ...}, {id: 'c', ...}]
-* graph.edges; // [{sourceId: 'a', targetId: 'b', ...}, ...]
-* ```
-*/
-function fromAdjacencyList(adj, options) {
-	const directed = options?.directed ?? true;
-	const seen = /* @__PURE__ */ new Set();
-	const nodes = Object.keys(adj).map((id) => ({
-		type: "node",
-		id,
-		parentId: null,
-		initialNodeId: null,
-		label: "",
-		data: void 0
-	}));
-	const edges = [];
-	let edgeIdx = 0;
-	for (const [sourceId, targets] of Object.entries(adj)) for (const targetId of targets) {
-		const key = directed ? `${sourceId}->${targetId}` : [sourceId, targetId].sort().join("<->");
-		if (!seen.has(key)) {
-			seen.add(key);
-			edges.push({
-				type: "edge",
-				id: `e${edgeIdx++}`,
-				sourceId,
-				targetId,
-				label: "",
-				data: void 0
-			});
-		}
-	}
-	return {
-		id: options?.id ?? "",
-		mode: directed ? "directed" : "undirected",
-		initialNodeId: null,
-		nodes,
-		edges,
-		data: void 0
-	};
-}
-/**
-* Converts a graph to an edge list of `[source, target]` tuples.
-*
-* @example
-* ```ts
-* import { createGraph, toEdgeList } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: { a: {}, b: {}, c: {} },
-*   edges: [{ source: 'a', target: 'b' }, { source: 'b', target: 'c' }],
-* });
-*
-* toEdgeList(graph);
-* // [['a', 'b'], ['b', 'c']]
-* ```
-*/
-function toEdgeList(graph) {
-	return graph.edges.map((e) => [e.sourceId, e.targetId]);
-}
-/**
-* Parses an edge list of `[source, target]` tuples into a graph.
-*
-* @example
-* ```ts
-* import { fromEdgeList } from '@statelyai/graph';
-*
-* const graph = fromEdgeList([
-*   ['a', 'b'],
-*   ['b', 'c'],
-* ]);
-*
-* graph.nodes; // [{id: 'a', ...}, {id: 'b', ...}, {id: 'c', ...}]
-* graph.edges; // [{sourceId: 'a', targetId: 'b', ...}, ...]
-* ```
-*/
-function fromEdgeList(edges, options) {
-	const directed = options?.directed ?? true;
-	const nodeIds = /* @__PURE__ */ new Set();
-	for (const [source, target] of edges) {
-		nodeIds.add(source);
-		nodeIds.add(target);
-	}
-	const nodes = [...nodeIds].map((id) => ({
-		type: "node",
-		id,
-		parentId: null,
-		initialNodeId: null,
-		label: "",
-		data: void 0
-	}));
-	const edgeObjects = edges.map(([sourceId, targetId], i) => ({
-		type: "edge",
-		id: `e${i}`,
-		sourceId,
-		targetId,
-		label: "",
-		data: void 0
-	}));
-	return {
-		id: options?.id ?? "",
-		mode: directed ? "directed" : "undirected",
-		initialNodeId: null,
-		nodes,
-		edges: edgeObjects,
-		data: void 0
-	};
-}
-/**
-* Create a `GraphFormatConverter` from a pair of `to`/`from` functions.
-*
-* @example
-* ```ts
-* import { createFormatConverter } from '@statelyai/graph';
-*
-* const yamlConverter = createFormatConverter(
-*   (graph) => toYAML(graph),
-*   (yaml) => fromYAML(yaml),
-* );
-*
-* const yaml = yamlConverter.to(graph);
-* const graph = yamlConverter.from(yaml);
-* ```
-*/
-function createFormatConverter$1(to, from) {
-	return {
-		to,
-		from
-	};
-}
-createFormatConverter$1(toAdjacencyList, fromAdjacencyList);
-createFormatConverter$1(toEdgeList, fromEdgeList);
-const LAYOUT_KEYS = {
-	node: [
-		"x",
-		"y",
-		"width",
-		"height",
-		"style",
-		"color",
-		"shape"
-	],
-	edge: [
-		"x",
-		"y",
-		"width",
-		"height",
-		"style",
-		"color"
-	]
-};
-new Set(LAYOUT_KEYS.node), new Set(LAYOUT_KEYS.edge);
-function nodeToConfig$1(node) {
-	const config = { id: node.id };
-	if (node.parentId) config.parentId = node.parentId;
-	if (node.initialNodeId) config.initialNodeId = node.initialNodeId;
-	if (node.label !== "") config.label = node.label;
-	if (node.data !== void 0) config.data = node.data;
-	if (node.x !== void 0) config.x = node.x;
-	if (node.y !== void 0) config.y = node.y;
-	if (node.width !== void 0) config.width = node.width;
-	if (node.height !== void 0) config.height = node.height;
-	if (node.shape !== void 0) config.shape = node.shape;
-	if (node.color !== void 0) config.color = node.color;
-	if (node.style !== void 0) config.style = node.style;
-	return config;
-}
-function edgeToConfig$1(edge) {
-	const config = {
-		id: edge.id,
-		sourceId: edge.sourceId,
-		targetId: edge.targetId
-	};
-	if (edge.label !== "") config.label = edge.label;
-	if (edge.data !== void 0) config.data = edge.data;
-	if (edge.x !== void 0) config.x = edge.x;
-	if (edge.y !== void 0) config.y = edge.y;
-	if (edge.width !== void 0) config.width = edge.width;
-	if (edge.height !== void 0) config.height = edge.height;
-	if (edge.color !== void 0) config.color = edge.color;
-	if (edge.style !== void 0) config.style = edge.style;
-	return config;
-}
-/** Shallow-compare two values, returning true if they differ. */
-function differs(a, b) {
-	if (a === b) return false;
-	if (a == null || b == null) return a !== b;
-	if (typeof a === "object" && typeof b === "object") return JSON.stringify(a) !== JSON.stringify(b);
-	return true;
-}
-const NODE_COMPARE_KEYS = [
-	"parentId",
-	"initialNodeId",
-	"label",
-	"data",
-	"x",
-	"y",
-	"width",
-	"height",
-	"shape",
-	"color",
-	"style"
-];
-const EDGE_COMPARE_KEYS = [
-	"sourceId",
-	"targetId",
-	"label",
-	"data",
-	"x",
-	"y",
-	"width",
-	"height",
-	"color",
-	"style"
-];
-/**
-* Compute a structured diff from graph `a` to graph `b` by matching IDs.
-*
-* @example
-* ```ts
-* import { createGraph, getDiff } from '@statelyai/graph';
-*
-* const a = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
-* const b = createGraph({ nodes: [{ id: 'n1', label: 'hello' }, { id: 'n2' }], edges: [] });
-*
-* const diff = getDiff(a, b);
-* // diff.nodes.added → [{ id: 'n2' }]
-* // diff.nodes.updated → [{ id: 'n1', old: { label: '' }, new: { label: 'hello' } }]
-* ```
-*/
-function getDiff$1(a, b) {
-	const aNodeMap = new Map(a.nodes.map((n) => [n.id, n]));
-	const bNodeMap = new Map(b.nodes.map((n) => [n.id, n]));
-	const aEdgeMap = new Map(a.edges.map((e) => [e.id, e]));
-	const bEdgeMap = new Map(b.edges.map((e) => [e.id, e]));
-	const diff = {
-		nodes: {
-			added: [],
-			removed: [],
-			updated: []
-		},
-		edges: {
-			added: [],
-			removed: [],
-			updated: []
-		}
-	};
-	for (const [id, nodeB] of bNodeMap) {
-		const nodeA = aNodeMap.get(id);
-		if (!nodeA) diff.nodes.added.push(nodeToConfig$1(nodeB));
-		else {
-			const oldPartial = {};
-			const newPartial = {};
-			for (const key of NODE_COMPARE_KEYS) if (differs(nodeA[key], nodeB[key])) {
-				oldPartial[key] = nodeA[key];
-				newPartial[key] = nodeB[key];
-			}
-			if (Object.keys(oldPartial).length > 0) diff.nodes.updated.push({
-				id,
-				old: oldPartial,
-				new: newPartial
-			});
-		}
-	}
-	for (const [id, nodeA] of aNodeMap) if (!bNodeMap.has(id)) diff.nodes.removed.push(nodeToConfig$1(nodeA));
-	for (const [id, edgeB] of bEdgeMap) {
-		const edgeA = aEdgeMap.get(id);
-		if (!edgeA) diff.edges.added.push(edgeToConfig$1(edgeB));
-		else {
-			const oldPartial = {};
-			const newPartial = {};
-			for (const key of EDGE_COMPARE_KEYS) if (differs(edgeA[key], edgeB[key])) {
-				oldPartial[key] = edgeA[key];
-				newPartial[key] = edgeB[key];
-			}
-			if (Object.keys(oldPartial).length > 0) diff.edges.updated.push({
-				id,
-				old: oldPartial,
-				new: newPartial
-			});
-		}
-	}
-	for (const [id, edgeA] of aEdgeMap) if (!bEdgeMap.has(id)) diff.edges.removed.push(edgeToConfig$1(edgeA));
-	return diff;
-}
-/**
-* Check if a diff has zero changes.
-*
-* @example
-* ```ts
-* import { createGraph, getDiff, isEmptyDiff } from '@statelyai/graph';
-*
-* const g = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
-* const diff = getDiff(g, g);
-* isEmptyDiff(diff); // true
-* ```
-*/
-function isEmptyDiff$1(diff) {
-	return diff.nodes.added.length === 0 && diff.nodes.removed.length === 0 && diff.nodes.updated.length === 0 && diff.edges.added.length === 0 && diff.edges.removed.length === 0 && diff.edges.updated.length === 0;
-}
-function summarizeGraphDiff(diff) {
-	return {
-		hasChanges: !isEmptyDiff$1(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$1(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.enqueue": object({
-		code: string().optional(),
-		lang: string().optional()
-	}),
-	"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.enqueue": {
-		package: "xstate",
-		version: "^6",
-		import: "enqueue",
-		importKind: "named",
-		paramsSchema: builtInActionParamSchemas["xstate.enqueue"],
-		emit(params) {
-			return typeof params?.code === "string" ? stripExportDefault(params.code) : "";
-		}
-	},
-	"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;
-	if (type === "xstate.enqueue" && typeof params?.code === "string") return inlineCodeExpression$1(params.code);
-	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",
-			"choice"
-		].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,
-			...node.data.output !== void 0 ? { output: node.data.output } : 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 choiceArr = [];
-			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,
-					...edge.data.context !== void 0 ? { context: edge.data.context } : 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 === "" && node.data.type === "choice") choiceArr.push(transitionObject);
-				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 (choiceArr.length > 0) nodeConfig.choice = singleOrArray(choiceArr);
-			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,
-			code: guard.code,
-			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 === "choice" ? state.type : null,
-				initialId,
-				history: state.history ?? false,
-				...state.output !== void 0 ? { output: state.output } : {},
-				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),
-					...transition.context !== void 0 ? { context: transition.context } : {},
-					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),
-					...transition.context !== void 0 ? { context: transition.context } : {},
-					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),
-					...transition.context !== void 0 ? { context: transition.context } : {},
-					actions: actionItems(transition.actions),
-					description: typeof transition.description === "string" ? transition.description : null,
-					meta: null
-				}
-			});
-		}
-		for (const [index, transition] of transitionObjects(state.choice).entries()) {
-			const target = transitionTargets(transition.target)[0];
-			graph.edges.push({
-				id: `${id}-choice-${index}`,
-				sourceId: id,
-				targetId: targetToNodeId(id, target, rootKey),
-				data: {
-					eventType: "",
-					transitionType: target ? "normal" : "targetless",
-					guard: guardObject(transition.guard),
-					...transition.context !== void 0 ? { context: transition.context } : {},
-					actions: actionItems(transition.actions),
-					description: typeof transition.description === "string" ? transition.description : null,
-					meta: transition.meta && typeof transition.meta === "object" ? transition.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 (parent.transitionValue && key === "context") return {
-		v6: parent.v6,
-		assignmentMap: true,
-		transitionContext: true
-	};
-	if (parent.assignmentMap) return {
-		v6: parent.v6,
-		assignmentValue: 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 === "input" || key === "output") return {
-		v6: parent.v6,
-		ioValue: true
-	};
-	if (key === "on" || key === "after") return {
-		v6: parent.v6,
-		transitionMap: true
-	};
-	if (key === "always" || key === "choice" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout") return {
-		v6: parent.v6,
-		transitionValue: true
-	};
-	return { v6: parent.v6 };
-}
-function fallbackFunctionTransition(fn, actions = []) {
-	return {
-		...actions.length ? { actions } : void 0,
-		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 hashString(value) {
-	let hash = 5381;
-	for (let i = 0; i < value.length; i++) hash = hash * 33 ^ value.charCodeAt(i);
-	return (hash >>> 0).toString(36);
-}
-function inlineGuardCode(params, condition) {
-	return `${params} => ${condition}`;
-}
-function guardFromConditions(conds, params) {
-	const simplified = simplifyConditions(conds);
-	if (simplified.length === 0) return void 0;
-	const code = inlineGuardCode(params, simplified.map(conditionText).join(" && "));
-	return {
-		type: `inline:${hashString(code)}`,
-		code
-	};
-}
-function wrapAssignExpression(expr) {
-	return `{{ ${expr.trim()} }}`;
-}
-function hasSpreadAssignment(node) {
-	return node.properties.some((property) => ts.isSpreadAssignment(property));
-}
-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 };
-	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, {
-				v6: true,
-				transitionValue: true
-			}, depth + 1, new Map([["target", branch.result]]))
-		}));
-	}
-	return [{
-		conds: [],
-		actions: [],
-		result: expressionToValue(node, bindings, {
-			v6: true,
-			transitionValue: true
-		}, 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 = [];
-	const scopedBindings = new Map(bindings);
-	for (const statement of statements) {
-		const nextOpen = [];
-		for (const prefix of open) {
-			if (ts.isVariableStatement(statement)) {
-				for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) scopedBindings.set(declaration.name.text, declaration.initializer);
-				nextOpen.push(prefix);
-				continue;
-			}
-			if (ts.isReturnStatement(statement)) {
-				if (!statement.expression) {
-					done.push({
-						...prefix,
-						result: void 0
-					});
-					continue;
-				}
-				for (const branch of expressionBranches(statement.expression, scopedBindings, 0)) done.push(mergeBranchPrefix(prefix, branch));
-				continue;
-			}
-			if (ts.isExpressionStatement(statement)) {
-				const action = expressionStatementAction(statement, enqName, scopedBindings);
-				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], scopedBindings, 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, scopedBindings, 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, scopedBindings, 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 guardParams(fn) {
-	const param = fn.parameters[0];
-	if (!param) return "()";
-	return `(${param.getText()})`;
-}
-function normalizeFunctionTransition(fn, bindings, depth) {
-	const preservedActions = fn.body && ts.isBlock(fn.body) && fn.body.statements.some((statement) => ts.isExpressionStatement(statement)) ? [enqueueAction(fn)] : [];
-	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.length ? preservedActions : []);
-		if (!transition) return null;
-		if (typeof transition === "string") {
-			const guard = guardFromConditions(branch.conds, guardParams(fn));
-			return guard ? {
-				target: transition,
-				guard
-			} : transition;
-		}
-		const guard = guardFromConditions(branch.conds, guardParams(fn));
-		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, preservedActions);
-}
-function inlineAction(fn) {
-	return {
-		type: "xstate.expr",
-		params: {
-			code: fn.getText(),
-			lang: "ts"
-		}
-	};
-}
-function enqueueAction(fn) {
-	return {
-		type: "xstate.enqueue",
-		params: {
-			code: fn.getText(),
-			lang: "ts"
-		}
-	};
-}
-function inlineCodeExpression(expr) {
-	return {
-		"@type": "code",
-		lang: "ts",
-		expr
-	};
-}
-function normalizeFunctionAction(fn, _bindings) {
-	return enqueueAction(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 context.ioValue ? inlineCodeExpression(JSON.stringify(node.text)) : node.text;
-	if (ts.isNumericLiteral(node)) return context.ioValue ? inlineCodeExpression(node.text) : Number(node.text);
-	if (node.kind === ts.SyntaxKind.TrueKeyword) return context.ioValue ? inlineCodeExpression("true") : true;
-	if (node.kind === ts.SyntaxKind.FalseKeyword) return context.ioValue ? inlineCodeExpression("false") : false;
-	if (node.kind === ts.SyntaxKind.NullKeyword) return context.ioValue ? inlineCodeExpression("null") : null;
-	if (context.assignmentValue) {
-		if (ts.isIdentifier(node) && node.text === "undefined") return void 0;
-		return wrapAssignExpression(node.getText());
-	}
-	if (context.transitionContext && !ts.isObjectLiteralExpression(node)) return inlineCodeExpression(node.getText());
-	if (context.ioValue && !ts.isObjectLiteralExpression(node)) return inlineCodeExpression(node.getText());
-	if (context.transitionContext && ts.isObjectLiteralExpression(node) && hasSpreadAssignment(node)) return inlineCodeExpression(node.getText());
-	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 === "choice" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout" || 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",
-	"eventless_cycle",
-	"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 getEventlessCycleErrors(graph) {
-	const eventlessEdges = graph.edges.filter((edge) => edge.data.eventType === "" && !edge.data.guard);
-	const bySource = /* @__PURE__ */ new Map();
-	for (const edge of eventlessEdges) {
-		const edges = bySource.get(edge.sourceId) ?? [];
-		edges.push(edge);
-		bySource.set(edge.sourceId, edges);
-	}
-	const results = [];
-	const reported = /* @__PURE__ */ new Set();
-	for (const startEdge of eventlessEdges) {
-		const stack = [{
-			nodeId: startEdge.targetId,
-			path: [startEdge]
-		}];
-		const seen = /* @__PURE__ */ new Set();
-		while (stack.length > 0) {
-			const current = stack.pop();
-			if (current.nodeId === startEdge.sourceId) {
-				const edgeIds = current.path.map((edge) => edge.id);
-				const key = [...edgeIds].sort().join("|");
-				if (!reported.has(key)) {
-					reported.add(key);
-					results.push(issue({
-						code: "eventless_cycle",
-						kind: "correctness",
-						level: "error",
-						edgeIds,
-						nodeIds: Array.from(new Set(current.path.flatMap((edge) => [edge.sourceId, edge.targetId]))),
-						message: "Unguarded eventless transitions form an infinite transition loop",
-						metadata: { edgeIds }
-					}));
-				}
-				continue;
-			}
-			if (seen.has(current.nodeId)) continue;
-			seen.add(current.nodeId);
-			for (const nextEdge of bySource.get(current.nodeId) ?? []) stack.push({
-				nodeId: nextEdge.targetId,
-				path: [...current.path, nextEdge]
-			});
-		}
-	}
-	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(...getEventlessCycleErrors(nonTempGraph));
-	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();
@@ -4283,10 +712,6 @@ function offsetAtRangePosition(text, line, character) {
 	return text.length;
 }
 
-//#endregion
-//#region ../graph-tools/src/codegenTypes.ts
-const INLINE_EXPRESSION_DIRECTIVE_FIELDS = ["input", "output"];
-
 //#endregion
 //#region src/sync.ts
 const execFileAsync = promisify(execFile);