@statelyai/sdk 0.26.2 → 0.27.0

package/dist/{statelyPragma-CWxhEIcZ.mjs → statelyPragma-DD7wx7-b.mjs}

@@ -1,5 +1,6 @@
 import { a as discriminatedUnion, c as object, d as union, f as unknown, i as custom, l as record, n as array, o as literal, r as boolean, s as number, t as _enum, u as string } from "./openapi-BTDjYWXd.mjs";
 import ts from "typescript";
+import "xstate";
 import "xstate/graph";
 
 //#region ../../node_modules/.pnpm/js-yaml@4.2.0/node_modules/js-yaml/dist/js-yaml.mjs
@@ -2333,6 +2334,57 @@ var index_vite_proxy_tmp_default = import_js_yaml.default;
 
 //#endregion
 //#region ../graph-tools/dist/index.mjs
+/**
+* Convert a resolved {@link GraphNode} back into a {@link NodeConfig}.
+*
+* Faithful and complete: round-tripping through `createGraphNode` yields a
+* deep-equal node. Optional fields are only included when present; ports are
+* deep-copied so the config does not share port objects with the source node.
+*/
+function toNodeConfig(node) {
+	const config = { id: node.id };
+	if (node.parentId != null) config.parentId = node.parentId;
+	if (node.initialNodeId != null) config.initialNodeId = node.initialNodeId;
+	if (node.label != null) config.label = node.label;
+	if (node.data != null) config.data = node.data;
+	if (node.ports !== void 0) config.ports = node.ports.map((p) => ({ ...p }));
+	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;
+}
+/**
+* Convert a resolved {@link GraphEdge} back into an {@link EdgeConfig}.
+*
+* Faithful and complete: round-tripping through `createGraphEdge` yields a
+* deep-equal edge. Optional fields are only included when present.
+*/
+function toEdgeConfig(edge) {
+	const config = {
+		id: edge.id,
+		sourceId: edge.sourceId,
+		targetId: edge.targetId
+	};
+	if (edge.label != null) config.label = edge.label;
+	if (edge.data != null) config.data = edge.data;
+	if (edge.weight !== void 0) config.weight = edge.weight;
+	if (edge.mode !== void 0) config.mode = edge.mode;
+	if (edge.sourcePort !== void 0) config.sourcePort = edge.sourcePort;
+	if (edge.targetPort !== void 0) config.targetPort = edge.targetPort;
+	if (edge.points !== void 0) config.points = edge.points.map((p) => ({ ...p }));
+	if (edge.routing !== void 0) config.routing = edge.routing;
+	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;
+}
 const LAYOUT_KEYS = {
 	node: [
 		"x",
@@ -2355,6 +2407,872 @@ const LAYOUT_KEYS = {
 	]
 };
 new Set(LAYOUT_KEYS.node), new Set(LAYOUT_KEYS.edge);
+/** 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",
+	"ports",
+	"x",
+	"y",
+	"width",
+	"height",
+	"shape",
+	"color",
+	"style"
+];
+const EDGE_COMPARE_KEYS = [
+	"sourceId",
+	"targetId",
+	"label",
+	"data",
+	"weight",
+	"mode",
+	"sourcePort",
+	"targetPort",
+	"points",
+	"routing",
+	"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(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(toNodeConfig(nodeB));
+		else {
+			const oldPartial = {};
+			const newPartial = {};
+			for (const key of NODE_COMPARE_KEYS) {
+				const oldValue = nodeA[key] ?? null;
+				const newValue = nodeB[key] ?? null;
+				if (differs(oldValue, newValue)) {
+					oldPartial[key] = oldValue;
+					newPartial[key] = newValue;
+				}
+			}
+			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(toNodeConfig(nodeA));
+	for (const [id, edgeB] of bEdgeMap) {
+		const edgeA = aEdgeMap.get(id);
+		if (!edgeA) diff.edges.added.push(toEdgeConfig(edgeB));
+		else {
+			const oldPartial = {};
+			const newPartial = {};
+			for (const key of EDGE_COMPARE_KEYS) {
+				const oldValue = edgeA[key] ?? null;
+				const newValue = edgeB[key] ?? null;
+				if (differs(oldValue, newValue)) {
+					oldPartial[key] = oldValue;
+					newPartial[key] = newValue;
+				}
+			}
+			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(toEdgeConfig(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(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(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$1(graph, node) {
+	let depth = 0;
+	let parentId = node.parentId;
+	while (parentId) {
+		depth++;
+		parentId = graph.nodes.find((candidate) => candidate.id === parentId)?.parentId;
+	}
+	return depth;
+}
+function nodeKey(node) {
+	return node.data?.key || node.id;
+}
+function edgeSignature(edge) {
+	return [
+		edge.sourceId,
+		edge.data?.eventType,
+		edge.targetId,
+		edge.data?.guard?.type ?? ""
+	].join("->");
+}
+function getStableNodeId(node, parentStableId, siblingIndex, preferredIds) {
+	const preferredId = preferredIds?.get(node.id);
+	if (preferredId !== void 0) return preferredId;
+	if (node.parentId === null) return "root";
+	const key = nodeKey(node);
+	const suffix = siblingIndex === 0 ? key : `${key}_${siblingIndex + 1}`;
+	return parentStableId ? `${parentStableId}.${suffix}` : suffix;
+}
+function getStableEdgeId(edge, siblingIndex, preferredIds) {
+	const preferredId = preferredIds?.get(edge.id);
+	if (preferredId !== void 0) return preferredId;
+	const suffix = siblingIndex === 0 ? "" : `.${siblingIndex + 1}`;
+	return edgeSignature(edge).concat(suffix);
+}
+function removePresentationFields(entity, kind) {
+	const mutableEntity = entity;
+	for (const key of LAYOUT_KEYS[kind]) delete mutableEntity[key];
+	const data = mutableEntity.data;
+	if (data && typeof data === "object" && !Array.isArray(data)) delete data.color;
+}
+/**
+* Rewrites entity ids to structural ("semantic") ids so two graphs that model
+* the same machine compare equal regardless of how their ids were minted.
+*
+* Invariant: node and edge array order is preserved exactly. Callers
+* (`alignCompareIds` in the editor's /v1/diff route) rely on
+* `normalized.nodes[i]` describing `graph.nodes[i]` to translate a semantic id
+* back to the caller's original id. Never sort, filter, or reorder the arrays
+* on the returned graph; sorting for traversal must be done on a copy, as the
+* depth ordering below does.
+*
+* Presentation-only fields defined by `LAYOUT_KEYS`, plus entity data colors,
+* are removed. When preferred ids are supplied, matching raw ids retain the
+* base graph's semantic identity so a stable-id rename is reported as an
+* update.
+*
+* Entity `data` is treated as optional throughout: sparse graphs (a node with
+* `data: {}`, an edge with `data: null`) normalize instead of throwing.
+*/
+function normalizeGraphForSemanticDiff(graph, preferredIds) {
+	const normalized = structuredClone(graph);
+	const nodeIdMap = /* @__PURE__ */ new Map();
+	const siblingKeys = /* @__PURE__ */ new Map();
+	const reservedNodeIds = new Set(preferredIds?.nodes.values());
+	const claimedNodeIds = /* @__PURE__ */ new Set();
+	const nodesByDepth = [...normalized.nodes].sort((a, b) => nodeDepth$1(normalized, a) - nodeDepth$1(normalized, b));
+	for (const node of nodesByDepth) {
+		const parentStableId = node.parentId ? nodeIdMap.get(node.parentId) ?? node.parentId : null;
+		const key = `${parentStableId ?? ""}:${nodeKey(node)}`;
+		const siblingIndex = siblingKeys.get(key) ?? 0;
+		siblingKeys.set(key, siblingIndex + 1);
+		const proposedId = getStableNodeId(node, parentStableId, siblingIndex, preferredIds?.nodes);
+		let stableId = proposedId;
+		let collisionIndex = 2;
+		while (!preferredIds?.nodes.has(node.id) && (reservedNodeIds.has(stableId) || claimedNodeIds.has(stableId))) stableId = `${proposedId}:unmatched:${collisionIndex++}`;
+		claimedNodeIds.add(stableId);
+		nodeIdMap.set(node.id, stableId);
+	}
+	for (const node of normalized.nodes) {
+		removePresentationFields(node, "node");
+		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();
+	const reservedEdgeIds = new Set(preferredIds?.edges.values());
+	const claimedEdgeIds = /* @__PURE__ */ new Set();
+	for (const edge of normalized.edges) {
+		removePresentationFields(edge, "edge");
+		edge.sourceId = nodeIdMap.get(edge.sourceId) ?? edge.sourceId;
+		edge.targetId = nodeIdMap.get(edge.targetId) ?? edge.targetId;
+		const key = edgeSignature(edge);
+		const siblingIndex = edgeSiblingKeys.get(key) ?? 0;
+		edgeSiblingKeys.set(key, siblingIndex + 1);
+		const proposedId = getStableEdgeId(edge, siblingIndex, preferredIds?.edges);
+		let stableId = proposedId;
+		let collisionIndex = 2;
+		while (!preferredIds?.edges.has(edge.id) && (reservedEdgeIds.has(stableId) || claimedEdgeIds.has(stableId))) stableId = `${proposedId}:unmatched:${collisionIndex++}`;
+		claimedEdgeIds.add(stableId);
+		edge.id = stableId;
+	}
+	if (normalized.initialNodeId) normalized.initialNodeId = nodeIdMap.get(normalized.initialNodeId) ?? normalized.initialNodeId;
+	return normalized;
+}
+function diffGraphsSemantically(baseGraph, compareGraph) {
+	const base = normalizeGraphForSemanticDiff(baseGraph);
+	const compareNodeIds = new Set(compareGraph.nodes.map((node) => node.id));
+	const compareEdgeIds = new Set(compareGraph.edges.map((edge) => edge.id));
+	const compare = normalizeGraphForSemanticDiff(compareGraph, {
+		nodes: new Map(baseGraph.nodes.map((node, index) => [node.id, base.nodes[index].id]).filter(([id]) => compareNodeIds.has(id))),
+		edges: new Map(baseGraph.edges.map((edge, index) => [edge.id, base.edges[index].id]).filter(([id]) => compareEdgeIds.has(id)))
+	});
+	const diff = getDiff(base, compare);
+	return {
+		base,
+		compare,
+		diff,
+		summary: summarizeGraphDiff(diff)
+	};
+}
+function stableStringify(value) {
+	return JSON.stringify(value, (_key, item) => {
+		if (item && typeof item === "object" && !Array.isArray(item)) return Object.fromEntries(Object.entries(item).sort(([left], [right]) => left.localeCompare(right)));
+		return item;
+	});
+}
+function isEqual(a, b) {
+	return stableStringify(a) === stableStringify(b);
+}
+function toStateColor(value) {
+	return value ?? null;
+}
+function toTransitionColor(value) {
+	return value ?? null;
+}
+function nodeDepth(graph, nodeId) {
+	const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+	let depth = 0;
+	let current = nodeById.get(nodeId);
+	while (current?.parentId) {
+		depth += 1;
+		current = nodeById.get(current.parentId);
+	}
+	return depth;
+}
+function isRootNode(node) {
+	return node.parentId == null;
+}
+function buildStateUpdatePatch(prevNode, nextNode) {
+	const patch = {
+		op: "updateState",
+		stateId: nextNode.id
+	};
+	let changed = false;
+	if (!prevNode || prevNode.data.key !== nextNode.data.key) {
+		patch.key = nextNode.data.key;
+		changed = true;
+	}
+	if (!prevNode || prevNode.data.type !== nextNode.data.type) {
+		patch.type = nextNode.data.type ?? null;
+		changed = true;
+	}
+	if (!prevNode || prevNode.data.description !== nextNode.data.description) {
+		patch.stateDescription = nextNode.data.description ?? null;
+		changed = true;
+	}
+	if (!prevNode || prevNode.data.initialId !== nextNode.data.initialId) {
+		patch.initialId = nextNode.data.initialId ?? null;
+		changed = true;
+	}
+	if (!prevNode || !isEqual(prevNode.data.initialInput, nextNode.data.initialInput)) {
+		patch.initialInput = nextNode.data.initialInput ?? null;
+		changed = true;
+	}
+	if (!prevNode || !isEqual(prevNode.data.output, nextNode.data.output)) {
+		patch.output = nextNode.data.output ?? null;
+		changed = true;
+	}
+	if (!prevNode || !isEqual(prevNode.data.timeout, nextNode.data.timeout)) {
+		patch.timeout = nextNode.data.timeout ?? null;
+		changed = true;
+	}
+	if (!prevNode || !isEqual(prevNode.data.route, nextNode.data.route)) {
+		patch.route = nextNode.data.route ?? null;
+		changed = true;
+	}
+	if (!prevNode || prevNode.data.color !== nextNode.data.color) {
+		patch.color = toStateColor(nextNode.data.color);
+		changed = true;
+	}
+	if (!prevNode || !isEqual(prevNode.data.meta, nextNode.data.meta)) {
+		patch.meta = nextNode.data.meta ?? null;
+		changed = true;
+	}
+	if (!prevNode || prevNode.data.history !== nextNode.data.history) {
+		patch.history = nextNode.data.history === true ? "shallow" : nextNode.data.history === false ? null : nextNode.data.history ?? null;
+		changed = true;
+	}
+	return changed ? patch : null;
+}
+function buildTransitionUpdatePatch(prevEdge, nextEdge) {
+	const patch = {
+		op: "updateTransition",
+		transitionId: nextEdge.id
+	};
+	let changed = false;
+	if (!prevEdge || prevEdge.sourceId !== nextEdge.sourceId) {
+		patch.sourceId = nextEdge.sourceId;
+		changed = true;
+	}
+	if (!prevEdge || prevEdge.targetId !== nextEdge.targetId) {
+		patch.targetId = nextEdge.targetId;
+		changed = true;
+	}
+	if (!prevEdge || prevEdge.data.eventType !== nextEdge.data.eventType) {
+		patch.eventType = nextEdge.data.eventType;
+		changed = true;
+	}
+	if (!prevEdge || !isEqual(prevEdge.data.matches, nextEdge.data.matches)) {
+		patch.matches = nextEdge.data.matches ?? null;
+		changed = true;
+	}
+	if (!prevEdge || prevEdge.data.transitionType !== nextEdge.data.transitionType) {
+		patch.transitionType = nextEdge.data.transitionType ?? "normal";
+		changed = true;
+	}
+	if (!prevEdge || prevEdge.data.description !== nextEdge.data.description) {
+		patch.transitionDescription = nextEdge.data.description ?? null;
+		changed = true;
+	}
+	if (!prevEdge || !isEqual(prevEdge.data.input, nextEdge.data.input)) {
+		patch.input = nextEdge.data.input ?? null;
+		changed = true;
+	}
+	if (!prevEdge || prevEdge.data.color !== nextEdge.data.color) {
+		patch.color = toTransitionColor(nextEdge.data.color);
+		changed = true;
+	}
+	if (!prevEdge || !isEqual(prevEdge.data.meta, nextEdge.data.meta)) {
+		patch.meta = nextEdge.data.meta ?? null;
+		changed = true;
+	}
+	return changed ? patch : null;
+}
+function diffTags(patches, nodeId, prevTags, nextTags) {
+	const getTagName = (tag) => typeof tag === "string" ? tag : tag.name;
+	const prev = new Set(prevTags.map(getTagName));
+	const next = new Set(nextTags.map(getTagName));
+	for (const tag of next) if (!prev.has(tag)) patches.push({
+		op: "createTag",
+		nodeId,
+		tag: { name: tag }
+	});
+	for (const tag of prev) if (!next.has(tag)) patches.push({
+		op: "deleteTag",
+		nodeId,
+		tagName: tag
+	});
+}
+function requiresAppendOnlyListRebuild(prevIds, nextIds) {
+	const prevIdSet = new Set(prevIds);
+	const nextIdSet = new Set(nextIds);
+	const retainedPrevIds = prevIds.filter((id) => nextIdSet.has(id));
+	const retainedNextIds = nextIds.filter((id) => prevIdSet.has(id));
+	let sawNewId = false;
+	for (const id of nextIds) if (prevIdSet.has(id)) {
+		if (sawNewId) return true;
+	} else sawNewId = true;
+	return !isEqual(retainedPrevIds, retainedNextIds);
+}
+function appendCreateInvokePatch(patches, nodeId, invoke) {
+	patches.push({
+		op: "createInvoke",
+		nodeId,
+		invoke: {
+			id: invoke.id,
+			...invoke.invocationId ? { invocationId: invoke.invocationId } : {},
+			src: invoke.src,
+			...invoke.srcExpression ? { srcExpression: invoke.srcExpression } : {},
+			...invoke.code ? { code: invoke.code } : {},
+			...invoke.registryKey ? { registryKey: invoke.registryKey } : {},
+			...invoke.timeout !== void 0 ? { timeout: invoke.timeout } : {},
+			...invoke.input ? { input: invoke.input } : {},
+			...invoke.output ? { output: invoke.output } : {}
+		}
+	});
+}
+function diffInvokes(patches, nodeId, prevInvokes, nextInvokes) {
+	if (requiresAppendOnlyListRebuild(prevInvokes.map((invoke) => invoke.id), nextInvokes.map((invoke) => invoke.id))) {
+		for (const invoke of prevInvokes) patches.push({
+			op: "deleteInvoke",
+			nodeId,
+			invokeId: invoke.id
+		});
+		for (const invoke of nextInvokes) appendCreateInvokePatch(patches, nodeId, invoke);
+		return;
+	}
+	const prevById = new Map(prevInvokes.map((invoke) => [invoke.id, invoke]));
+	const nextById = new Map(nextInvokes.map((invoke) => [invoke.id, invoke]));
+	for (const invoke of nextInvokes) {
+		const previous = prevById.get(invoke.id);
+		if (!previous) {
+			appendCreateInvokePatch(patches, nodeId, invoke);
+			continue;
+		}
+		const data = {};
+		if (previous.invocationId !== invoke.invocationId) data.invocationId = invoke.invocationId ?? null;
+		if (previous.src !== invoke.src) data.src = invoke.src;
+		if (previous.code !== invoke.code) data.code = invoke.code ?? null;
+		if (!isEqual(previous.srcExpression, invoke.srcExpression)) data.srcExpression = invoke.srcExpression ?? null;
+		if (previous.registryKey !== invoke.registryKey) data.registryKey = invoke.registryKey ?? null;
+		if (!isEqual(previous.timeout, invoke.timeout)) data.timeout = invoke.timeout ?? null;
+		if (!isEqual(previous.input, invoke.input)) data.input = invoke.input ?? null;
+		if (!isEqual(previous.output, invoke.output)) data.output = invoke.output ?? null;
+		if (Object.keys(data).length > 0) patches.push({
+			op: "updateInvoke",
+			nodeId,
+			invokeId: invoke.id,
+			data
+		});
+	}
+	for (const invoke of prevInvokes) if (!nextById.has(invoke.id)) patches.push({
+		op: "deleteInvoke",
+		nodeId,
+		invokeId: invoke.id
+	});
+}
+function diffActions(patches, location, prevActions, nextActions) {
+	const actionId = (action, index) => action.id ?? `${index}:${action.type}`;
+	const prevIds = prevActions.map(actionId);
+	const nextIds = nextActions.map(actionId);
+	if (requiresAppendOnlyListRebuild(prevIds, nextIds)) {
+		prevActions.forEach((action, index) => {
+			patches.push({
+				op: "deleteAction",
+				location,
+				actionId: actionId(action, index)
+			});
+		});
+		nextActions.forEach((action, index) => {
+			patches.push({
+				op: "createAction",
+				location,
+				index,
+				action: {
+					id: action.id,
+					type: action.type,
+					params: action.params
+				}
+			});
+		});
+		return;
+	}
+	const prevById = new Map(prevActions.map((action, index) => [actionId(action, index), action]));
+	const nextIdSet = new Set(nextIds);
+	prevActions.forEach((action, index) => {
+		const id = actionId(action, index);
+		if (!nextIdSet.has(id)) patches.push({
+			op: "deleteAction",
+			location,
+			actionId: id
+		});
+	});
+	nextActions.forEach((action, index) => {
+		const id = actionId(action, index);
+		const previous = prevById.get(id);
+		if (!previous) {
+			patches.push({
+				op: "createAction",
+				location,
+				index,
+				action: {
+					id: action.id,
+					type: action.type,
+					params: action.params
+				}
+			});
+			return;
+		}
+		const data = {};
+		if (previous.type !== action.type) data.type = action.type;
+		if (!isEqual(previous.params, action.params)) data.params = action.params ?? {};
+		if (Object.keys(data).length > 0) patches.push({
+			op: "updateAction",
+			location,
+			actionId: id,
+			data
+		});
+	});
+}
+function implementationList$1(graph, sourceType) {
+	const implementations = graph.data?.implementations;
+	if (!implementations) return [];
+	switch (sourceType) {
+		case "action": return implementations.actions ?? [];
+		case "guard": return implementations.guards ?? [];
+		case "actor": return implementations.actors ?? [];
+		case "delay": return implementations.delays ?? [];
+	}
+}
+function collectUnsupportedChanges(prevGraph, nextGraph) {
+	const unsupportedChanges = [];
+	const prevNodeById = new Map(prevGraph.nodes.map((node) => [node.id, node]));
+	for (const node of nextGraph.nodes) {
+		const previous = prevNodeById.get(node.id);
+		if (previous && (previous.parentId ?? null) !== (node.parentId ?? null)) unsupportedChanges.push(`State "${node.id}" moved to a different parent.`);
+	}
+	for (const sourceType of [
+		"action",
+		"guard",
+		"actor",
+		"delay"
+	]) {
+		const previousById = new Map(implementationList$1(prevGraph, sourceType).map((implementation) => [implementation.id, implementation]));
+		for (const implementation of implementationList$1(nextGraph, sourceType)) {
+			const previous = previousById.get(implementation.id);
+			const unsupportedMetadata = {
+				description: implementation.description,
+				lang: implementation.code?.lang,
+				deps: implementation.code?.deps,
+				..."paramsSchema" in implementation ? { paramsSchema: implementation.paramsSchema } : {},
+				..."inputSchema" in implementation ? { inputSchema: implementation.inputSchema } : {},
+				..."outputSchema" in implementation ? { outputSchema: implementation.outputSchema } : {}
+			};
+			const previousUnsupportedMetadata = previous ? {
+				description: previous.description,
+				lang: previous.code?.lang,
+				deps: previous.code?.deps,
+				..."paramsSchema" in previous ? { paramsSchema: previous.paramsSchema } : {},
+				..."inputSchema" in previous ? { inputSchema: previous.inputSchema } : {},
+				..."outputSchema" in previous ? { outputSchema: previous.outputSchema } : {}
+			} : {};
+			if (previous ? !isEqual(previousUnsupportedMetadata, unsupportedMetadata) : Object.values(unsupportedMetadata).some((value) => value !== void 0 && value !== null)) unsupportedChanges.push(`${sourceType} implementation "${implementation.id}" has metadata that source patches cannot represent.`);
+		}
+	}
+	return unsupportedChanges;
+}
+function diffImplementations(patches, sourceType, prevGraph, nextGraph) {
+	const prevById = new Map(implementationList$1(prevGraph, sourceType).map((implementation) => [implementation.id, implementation]));
+	const nextById = new Map(implementationList$1(nextGraph, sourceType).map((implementation) => [implementation.id, implementation]));
+	for (const implementation of nextById.values()) {
+		const previous = prevById.get(implementation.id);
+		const code = implementation.code?.body;
+		if (!previous) {
+			patches.push({
+				op: "createImplementation",
+				sourceType,
+				implementation: {
+					id: implementation.id,
+					name: implementation.name,
+					...code !== void 0 ? { code } : void 0
+				}
+			});
+			continue;
+		}
+		const data = {};
+		if (previous.name !== implementation.name) data.name = implementation.name;
+		if (previous.code?.body !== implementation.code?.body) data.code = code ?? null;
+		if (Object.keys(data).length > 0) patches.push({
+			op: "updateImplementation",
+			sourceType,
+			implementationId: implementation.id,
+			data
+		});
+	}
+	for (const implementation of prevById.values()) if (!nextById.has(implementation.id)) patches.push({
+		op: "deleteImplementation",
+		sourceType,
+		implementationId: implementation.id
+	});
+}
+function appendCreateTransitionPatches(patches, edge) {
+	patches.push({
+		op: "createTransition",
+		id: edge.id,
+		sourceId: edge.sourceId,
+		targetId: edge.targetId,
+		eventType: edge.data.eventType,
+		...edge.data.matches ? { matches: edge.data.matches } : {},
+		transitionType: edge.data.transitionType,
+		...edge.data.guard ? { guard: edge.data.guard } : {},
+		...edge.data.color ? { color: toTransitionColor(edge.data.color) } : {},
+		...edge.data.description ? { transitionDescription: edge.data.description } : {},
+		...edge.data.input !== void 0 ? { input: edge.data.input } : {}
+	});
+	if (edge.data.meta) patches.push({
+		op: "updateTransition",
+		transitionId: edge.id,
+		meta: edge.data.meta
+	});
+	diffActions(patches, {
+		edgeId: edge.id,
+		group: "transition"
+	}, [], edge.data.actions ?? []);
+}
+/** Transitions are ordered relative to their (source state, event type) peers. */
+function transitionPriorityGroup(edge) {
+	return `${edge.sourceId}\0${edge.data?.eventType ?? ""}`;
+}
+function groupEdgeIdsByPriority(edges) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		const key = transitionPriorityGroup(edge);
+		const ids = groups.get(key);
+		if (ids) ids.push(edge.id);
+		else groups.set(key, [edge.id]);
+	}
+	return groups;
+}
+/**
+* Returns the ids of transitions that must be deleted and recreated because
+* their priority group cannot be reached by appends and deletions alone.
+*
+* An edge is rebuilt when either the group it came from or the group it moves
+* to needs a rebuild, so a rebuilt group is always torn down and recreated as
+* a whole.
+*/
+function collectRebuiltEdgeIds(prevGraph, nextGraph) {
+	const prevGroups = groupEdgeIdsByPriority(prevGraph.edges);
+	const nextGroups = groupEdgeIdsByPriority(nextGraph.edges);
+	const rebuiltGroups = /* @__PURE__ */ new Set();
+	for (const key of new Set([...prevGroups.keys(), ...nextGroups.keys()])) if (requiresAppendOnlyListRebuild(prevGroups.get(key) ?? [], nextGroups.get(key) ?? [])) rebuiltGroups.add(key);
+	const rebuiltEdgeIds = /* @__PURE__ */ new Set();
+	for (const edge of [...prevGraph.edges, ...nextGraph.edges]) if (rebuiltGroups.has(transitionPriorityGroup(edge))) rebuiltEdgeIds.add(edge.id);
+	return rebuiltEdgeIds;
+}
+function graphChangeToPatchesResult(prevGraph, nextGraph) {
+	const patches = [];
+	const unsupportedChanges = collectUnsupportedChanges(prevGraph, nextGraph);
+	const prevNodeById = new Map(prevGraph.nodes.map((node) => [node.id, node]));
+	const nextNodeById = new Map(nextGraph.nodes.map((node) => [node.id, node]));
+	const prevEdgeById = new Map(prevGraph.edges.map((edge) => [edge.id, edge]));
+	const nextEdgeById = new Map(nextGraph.edges.map((edge) => [edge.id, edge]));
+	const createdNodes = nextGraph.nodes.filter((node) => !isRootNode(node) && !prevNodeById.has(node.id)).sort((a, b) => nodeDepth(nextGraph, a.id) - nodeDepth(nextGraph, b.id));
+	for (const node of createdNodes) {
+		const x = node.position?.x ?? node.x;
+		const y = node.position?.y ?? node.y;
+		patches.push({
+			op: "createState",
+			id: node.id,
+			parentId: node.parentId,
+			key: node.data.key,
+			type: node.data.type,
+			...x !== void 0 ? { x } : {},
+			...y !== void 0 ? { y } : {},
+			color: toStateColor(node.data.color),
+			initial: nextNodeById.get(node.parentId)?.data.initialId === node.id
+		});
+		const stateUpdate = buildStateUpdatePatch(void 0, node);
+		if (stateUpdate) patches.push(stateUpdate);
+		diffTags(patches, node.id, [], node.data.tags ?? []);
+		diffInvokes(patches, node.id, [], node.data.invokes ?? []);
+		diffActions(patches, {
+			nodeId: node.id,
+			group: "entry"
+		}, [], node.data.entry ?? []);
+		diffActions(patches, {
+			nodeId: node.id,
+			group: "exit"
+		}, [], node.data.exit ?? []);
+	}
+	for (const node of prevGraph.nodes.filter((node) => !isRootNode(node) && !nextNodeById.has(node.id)).sort((a, b) => nodeDepth(prevGraph, b.id) - nodeDepth(prevGraph, a.id))) patches.push({
+		op: "deleteState",
+		stateId: node.id
+	});
+	for (const node of nextGraph.nodes) {
+		const previous = prevNodeById.get(node.id);
+		if (!previous) continue;
+		const stateUpdate = buildStateUpdatePatch(previous, node);
+		if (stateUpdate) patches.push(stateUpdate);
+		diffTags(patches, node.id, previous.data.tags ?? [], node.data.tags ?? []);
+		diffInvokes(patches, node.id, previous.data.invokes ?? [], node.data.invokes ?? []);
+		diffActions(patches, {
+			nodeId: node.id,
+			group: "entry"
+		}, previous.data.entry ?? [], node.data.entry ?? []);
+		diffActions(patches, {
+			nodeId: node.id,
+			group: "exit"
+		}, previous.data.exit ?? [], node.data.exit ?? []);
+	}
+	const rebuiltEdgeIds = collectRebuiltEdgeIds(prevGraph, nextGraph);
+	const isRebuilt = (edge) => rebuiltEdgeIds.has(edge.id);
+	for (const edge of prevGraph.edges) if (isRebuilt(edge)) patches.push({
+		op: "deleteTransition",
+		transitionId: edge.id
+	});
+	for (const edge of nextGraph.edges) if (isRebuilt(edge)) appendCreateTransitionPatches(patches, edge);
+	for (const edge of nextGraph.edges) {
+		if (isRebuilt(edge)) continue;
+		const previous = prevEdgeById.get(edge.id);
+		if (!previous) {
+			appendCreateTransitionPatches(patches, edge);
+			continue;
+		}
+		const transitionUpdate = buildTransitionUpdatePatch(previous, edge);
+		if (transitionUpdate) patches.push(transitionUpdate);
+		if (!previous.data.guard && edge.data.guard) patches.push({
+			op: "setGuard",
+			edgeId: edge.id,
+			guard: edge.data.guard
+		});
+		else if (previous.data.guard && !edge.data.guard) patches.push({
+			op: "deleteGuard",
+			edgeId: edge.id
+		});
+		else if (!isEqual(previous.data.guard, edge.data.guard) && edge.data.guard) patches.push({
+			op: "setGuard",
+			edgeId: edge.id,
+			guard: edge.data.guard
+		});
+		diffActions(patches, {
+			edgeId: edge.id,
+			group: "transition"
+		}, previous.data.actions ?? [], edge.data.actions ?? []);
+	}
+	for (const edge of prevGraph.edges) if (!isRebuilt(edge) && !nextEdgeById.has(edge.id)) patches.push({
+		op: "deleteTransition",
+		transitionId: edge.id
+	});
+	if (!isEqual(prevGraph.data.context, nextGraph.data.context)) patches.push({
+		op: "setContext",
+		context: nextGraph.data.context ?? null
+	});
+	if (!isEqual(prevGraph.data.schemas, nextGraph.data.schemas)) patches.push({
+		op: "updateSchemas",
+		schemas: {
+			context: nextGraph.data.schemas?.context ?? null,
+			events: nextGraph.data.schemas?.events ?? null,
+			input: nextGraph.data.schemas?.input ?? null,
+			output: nextGraph.data.schemas?.output ?? null
+		}
+	});
+	diffImplementations(patches, "action", prevGraph, nextGraph);
+	diffImplementations(patches, "guard", prevGraph, nextGraph);
+	diffImplementations(patches, "actor", prevGraph, nextGraph);
+	diffImplementations(patches, "delay", prevGraph, nextGraph);
+	return {
+		patches,
+		unsupportedChanges
+	};
+}
+const UNMATCHED_ID_PREFIX = "__diff_unmatched_";
+function createIdAllocator(reserved) {
+	const taken = new Set(reserved);
+	let counter = 0;
+	return {
+		claim(preferredId) {
+			if (!taken.has(preferredId)) {
+				taken.add(preferredId);
+				return preferredId;
+			}
+			let candidate = `${UNMATCHED_ID_PREFIX}${counter++}`;
+			while (taken.has(candidate)) candidate = `${UNMATCHED_ID_PREFIX}${counter++}`;
+			taken.add(candidate);
+			return candidate;
+		},
+		reserve(id) {
+			taken.add(id);
+		},
+		isTaken(id) {
+			return taken.has(id);
+		}
+	};
+}
+function assignAlignedIds(compareEntities, baseIds, baseIdBySemanticId) {
+	const baseIdSet = new Set(baseIds);
+	const assigned = /* @__PURE__ */ new Map();
+	const allocator = createIdAllocator([]);
+	for (const entity of compareEntities) if (baseIdSet.has(entity.id)) {
+		allocator.reserve(entity.id);
+		assigned.set(entity.id, entity.id);
+	}
+	for (const entity of compareEntities) {
+		if (assigned.has(entity.id)) continue;
+		const matchedBaseId = baseIdBySemanticId.get(entity.semanticId);
+		if (matchedBaseId !== void 0 && !allocator.isTaken(matchedBaseId)) {
+			allocator.reserve(matchedBaseId);
+			assigned.set(entity.id, matchedBaseId);
+		}
+	}
+	for (const entity of compareEntities) {
+		if (assigned.has(entity.id)) continue;
+		assigned.set(entity.id, allocator.claim(entity.id));
+	}
+	return assigned;
+}
+/**
+* Rewrites compare entity ids to the corresponding base ids.
+*
+* Shared raw ids win, then semantic ids, then collision-free compare ids.
+* Normalization must preserve entity array order so semantic ids can be mapped
+* back to the caller's original graph.
+*/
+function alignCompareGraphIds(base, compare, semanticBase, semanticCompare) {
+	const baseNodeIds = new Map(semanticBase.nodes.map((node, index) => [node.id, base.nodes[index].id]));
+	const baseEdgeIds = new Map(semanticBase.edges.map((edge, index) => [edge.id, base.edges[index].id]));
+	const compareNodeIds = assignAlignedIds(compare.nodes.map((node, index) => ({
+		id: node.id,
+		semanticId: semanticCompare.nodes[index].id
+	})), base.nodes.map((node) => node.id), baseNodeIds);
+	const compareEdgeIds = assignAlignedIds(compare.edges.map((edge, index) => ({
+		id: edge.id,
+		semanticId: semanticCompare.edges[index].id
+	})), base.edges.map((edge) => edge.id), baseEdgeIds);
+	const mapNodeId = (id) => compareNodeIds.get(id) ?? id;
+	const aligned = structuredClone(compare);
+	if (aligned.initialNodeId) aligned.initialNodeId = mapNodeId(aligned.initialNodeId);
+	for (const node of aligned.nodes) {
+		if (node.parentId) node.parentId = mapNodeId(node.parentId);
+		if (node.initialNodeId) node.initialNodeId = mapNodeId(node.initialNodeId);
+		if (node.data?.initialId) node.data.initialId = mapNodeId(node.data.initialId);
+		node.id = mapNodeId(node.id);
+	}
+	for (const edge of aligned.edges) {
+		edge.sourceId = mapNodeId(edge.sourceId);
+		edge.targetId = mapNodeId(edge.targetId);
+		edge.id = compareEdgeIds.get(edge.id) ?? edge.id;
+	}
+	for (const annotation of aligned.annotations ?? []) {
+		const annotationData = annotation.data;
+		if (!annotationData?.referenceIds) continue;
+		annotationData.referenceIds = annotationData.referenceIds.map((id) => annotation.type === "edge" ? compareEdgeIds.get(id) ?? id : mapNodeId(id));
+	}
+	return aligned;
+}
 function isAutoGeneratedId(id) {
 	return !!id && id.startsWith("$auto-");
 }
@@ -2471,7 +3389,7 @@ function stripExportDefault(code) {
 	return trimmed;
 }
 const XSTATE_V5_PROFILE = "@statelyai/xstate@5.30.0";
-const XSTATE_V6_PROFILE = "@statelyai/xstate@6.0.0-alpha.47";
+const XSTATE_V6_PROFILE = "@statelyai/xstate@6.0.0-alpha.51";
 const LEGACY_MACHINE_PROFILES = ["xstate-v5", "xstate-v6-alpha"];
 function normalizeMachineProfile(profile) {
 	return profile === "xstate-v5" ? XSTATE_V5_PROFILE : profile === "xstate-v6-alpha" ? XSTATE_V6_PROFILE : profile;
@@ -2617,7 +3535,7 @@ function deepSimplify(config) {
 	return config;
 }
 function buildMeta(meta, color) {
-	if (isCodeExpression$1(meta)) return meta;
+	if (isCodeExpression$2(meta)) return meta;
 	const result = {};
 	if (meta) {
 		for (const [k, v] of Object.entries(meta)) if (v !== void 0 && v !== null) result[k] = v;
@@ -2625,7 +3543,7 @@ function buildMeta(meta, color) {
 	if (color) result["@statelyai.color"] = color;
 	return Object.keys(result).length > 0 ? result : void 0;
 }
-function isCodeExpression$1(value) {
+function isCodeExpression$2(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) */
@@ -2636,7 +3554,7 @@ function formatEventParam(event) {
 }
 function formatStringParam(value) {
 	if (typeof value === "string") return `'${value}'`;
-	return isCodeExpression$1(value) ? serializeJS(value) : "undefined";
+	return isCodeExpression$2(value) ? serializeJS(value) : "undefined";
 }
 function formatInlineObject(value) {
 	return `{ ${Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => `${formatObjectKey(key)}: ${serializeJS(item)}`).join(", ")} }`;
@@ -2885,6 +3803,7 @@ function graphToMachineConfig(graph, options = {}) {
 				...inv.output !== void 0 ? { output: inv.output } : void 0
 			})) } : void 0,
 			...node.data.output !== void 0 ? { output: node.data.output } : void 0,
+			...node.data.schemas ? { schemas: node.data.schemas } : 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,
@@ -3004,6 +3923,8 @@ function graphToMachineConfig(graph, options = {}) {
 	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;
+	if (graph.data.version) config.version = graph.data.version;
+	if (graph.data.options?.maxIterations !== void 0) config.options = { maxIterations: graph.data.options.maxIterations };
 	return deepSimplify(config);
 }
 const INLINE_EXPRESSION_DIRECTIVE_FIELDS = [
@@ -4159,16 +5080,27 @@ function isCreateMachineCall(node) {
 	return false;
 }
 function isMachineFactoryName(name) {
-	return name === "createMachine" || name === "createMachineFromConfig";
-}
-function setupCallForCreateMachine(node, bindings) {
-	if (!ts.isPropertyAccessExpression(node.expression)) return null;
-	let receiver = unwrapExpression(node.expression.expression);
-	if (ts.isIdentifier(receiver)) {
-		const binding = bindings.get(receiver.text);
-		if (binding && !ts.isFunctionDeclaration(binding)) receiver = unwrapExpression(binding);
-	}
-	return ts.isCallExpression(receiver) && ts.isIdentifier(receiver.expression) && receiver.expression.text === "setup" ? receiver : null;
+	return name === "createMachine" || name === "createMachineFromConfig" || name === "createFSM";
+}
+function setupConfigExpressionsForCreateMachine(node, bindings) {
+	if (!ts.isPropertyAccessExpression(node.expression)) return [];
+	const findSetupConfigs = (value, seen = /* @__PURE__ */ new Set()) => {
+		const receiver = unwrapExpression(value);
+		if (ts.isIdentifier(receiver)) {
+			if (seen.has(receiver.text)) return [];
+			seen.add(receiver.text);
+			const binding = bindings.get(receiver.text);
+			return binding && !ts.isFunctionDeclaration(binding) ? findSetupConfigs(binding, seen) : [];
+		}
+		if (!ts.isCallExpression(receiver)) return [];
+		if (ts.isIdentifier(receiver.expression) && receiver.expression.text === "setup") return receiver.arguments[0] ? [receiver.arguments[0]] : [];
+		if (ts.isPropertyAccessExpression(receiver.expression) && receiver.expression.name.text === "extend") {
+			const base = findSetupConfigs(receiver.expression.expression, seen);
+			return receiver.arguments[0] ? [...base, receiver.arguments[0]] : base;
+		}
+		return [];
+	};
+	return findSetupConfigs(node.expression.expression);
 }
 function hasV6Syntax(source) {
 	const file = sourceFile(source);
@@ -4220,14 +5152,14 @@ function hasV6Syntax(source) {
 	}
 	function visitMachineCalls(node) {
 		if (ts.isCallExpression(node) && isCreateMachineCall(node)) {
-			if ((ts.isIdentifier(node.expression) ? node.expression.text : ts.isPropertyAccessExpression(node.expression) ? node.expression.name.text : void 0) === "createMachineFromConfig") {
+			const factoryName = ts.isIdentifier(node.expression) ? node.expression.text : ts.isPropertyAccessExpression(node.expression) ? node.expression.name.text : void 0;
+			if (factoryName === "createMachineFromConfig" || factoryName === "createFSM") {
 				found = true;
 				return;
 			}
 			const config = node.arguments[0];
 			if (config) visitSyntax(config);
-			const setupConfig = setupCallForCreateMachine(node, bindings)?.arguments[0];
-			if (setupConfig) visitSyntax(setupConfig);
+			for (const setupConfig of setupConfigExpressionsForCreateMachine(node, bindings)) visitSyntax(setupConfig);
 			return;
 		}
 		ts.forEachChild(node, visitMachineCalls);
@@ -4240,24 +5172,93 @@ function detectXStateSourceProfile(source) {
 }
 function xstateSourceToConfig(source, options = {}) {
 	const [config] = extractXStateMachineConfigs(source, options);
-	if (!config) throw new Error("No createMachine(...) or setup(...).createMachine(...) call found.");
+	if (!config) throw new Error("No createMachine(...), createFSM(...), or setup factory call found.");
 	return config;
 }
 /**
 * Extract every XState machine config from source without executing code.
 * XState 5/6 syntax is inferred structurally unless a profile is supplied.
 */
-function extractXStateMachineConfigs(source, options = {}) {
+function extractXStateMachineConfigEntries(source, options = {}) {
 	const file = sourceFile(source);
 	const bindings = collectBindings(file);
 	const imports = collectSourceImports(file);
 	const found = [];
+	let machineIndex = 0;
 	const profile = options.profile === "auto" || !options.profile ? detectXStateSourceProfile(source) : options.profile;
+	const isRecordValue = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+	const mergeSetupStateSchemas = (machineStates, setupStates) => {
+		if (!isRecordValue(machineStates) || !isRecordValue(setupStates)) return machineStates;
+		return Object.fromEntries(Object.entries(machineStates).map(([key, machineState]) => {
+			if (!isRecordValue(machineState)) return [key, machineState];
+			const contract = isRecordValue(setupStates[key]) ? setupStates[key] : void 0;
+			if (!contract) return [key, machineState];
+			const contractSchemas = isRecordValue(contract.schemas) ? contract.schemas : {};
+			const stateSchemas = isRecordValue(machineState.schemas) ? machineState.schemas : {};
+			const schemas = Object.fromEntries([
+				"input",
+				"context",
+				"output"
+			].flatMap((schemaKey) => {
+				const schema = stateSchemas[schemaKey] ?? contractSchemas[schemaKey];
+				return schema === void 0 ? [] : [[schemaKey, schema]];
+			}));
+			return [key, {
+				...machineState,
+				...Object.keys(schemas).length ? { schemas } : {},
+				states: mergeSetupStateSchemas(machineState.states, contract.states)
+			}];
+		}));
+	};
+	const mergeSetupRecords = (base, extension) => {
+		const mergeMap = (left, right) => {
+			if (!isRecordValue(left) && !isRecordValue(right)) return void 0;
+			const merged = {
+				...isRecordValue(left) ? left : {},
+				...isRecordValue(right) ? right : {}
+			};
+			return Object.keys(merged).length ? merged : void 0;
+		};
+		const schemas = mergeMap(base.schemas, extension.schemas);
+		if (isRecordValue(schemas)) for (const key of [
+			"events",
+			"internalEvents",
+			"actions",
+			"guards",
+			"emitted",
+			"children"
+		]) {
+			const merged = mergeMap(isRecordValue(base.schemas) ? base.schemas[key] : void 0, isRecordValue(extension.schemas) ? extension.schemas[key] : void 0);
+			if (merged !== void 0) schemas[key] = merged;
+			else delete schemas[key];
+		}
+		const result = {
+			...base,
+			...extension
+		};
+		if (schemas !== void 0) result.schemas = schemas;
+		else delete result.schemas;
+		for (const key of [
+			"states",
+			"actions",
+			"actors",
+			"actorSources",
+			"guards",
+			"delays"
+		]) {
+			const merged = mergeMap(base[key], extension[key]);
+			if (merged !== void 0) result[key] = merged;
+			else delete result[key];
+		}
+		return result;
+	};
 	function visit(node) {
 		if (!ts.isCallExpression(node) || !isCreateMachineCall(node)) {
 			ts.forEachChild(node, visit);
 			return;
 		}
+		const sourceMachineIndex = machineIndex;
+		machineIndex += 1;
 		const arg = node.arguments[0];
 		if (!arg) return;
 		const value = expressionToValue(arg, bindings, {
@@ -4266,22 +5267,32 @@ function extractXStateMachineConfigs(source, options = {}) {
 			imports
 		});
 		if (value && typeof value === "object" && !Array.isArray(value)) {
-			const setupArg = setupCallForCreateMachine(node, bindings)?.arguments[0];
-			const setupValue = setupArg ? expressionToValue(setupArg, bindings, {
-				v6: profile === "xstate-v6-alpha",
-				setupValue: true,
-				imports
-			}) : null;
-			const setupRecord = setupValue && typeof setupValue === "object" && !Array.isArray(setupValue) ? Object.fromEntries(Object.entries(setupValue).filter(([, item]) => !(item && typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 0))) : {};
+			const { states: setupStates, ...setupWithoutStates } = setupConfigExpressionsForCreateMachine(node, bindings).reduce((merged, setupArg) => {
+				const setupValue = expressionToValue(setupArg, bindings, {
+					v6: profile === "xstate-v6-alpha",
+					setupValue: true,
+					imports
+				});
+				if (!isRecordValue(setupValue)) return merged;
+				return mergeSetupRecords(merged, setupValue);
+			}, {});
+			const machineValue = value;
 			found.push({
-				...setupRecord,
-				...value
+				machineIndex: sourceMachineIndex,
+				config: {
+					...setupWithoutStates,
+					...machineValue,
+					states: mergeSetupStateSchemas(machineValue.states, setupStates)
+				}
 			});
 		}
 	}
 	visit(file);
 	return found;
 }
+function extractXStateMachineConfigs(source, options = {}) {
+	return extractXStateMachineConfigEntries(source, options).map(({ config }) => config);
+}
 function jsonSchemaToTSType(schema) {
 	if (!schema) return "unknown";
 	if (schema.enum) return schema.enum.map((v) => typeof v === "string" ? `'${v}'` : String(v)).join(" | ");
@@ -4490,6 +5501,7 @@ function graphToXStateTS(graph, options = {}) {
 	const impls = filterInlineImplementations(graph.data.implementations);
 	const supportsTypeSyntax = targetLanguage === "typescript";
 	const hasSchemas = !!(schemas && (schemas.context || schemas.events || schemas.input || schemas.output));
+	const hasStateSchemas = graph.nodes.some((node) => node.data.schemas);
 	const hasActions = !!impls?.actions.length;
 	const hasGuards = !!impls?.guards.length;
 	const hasActors = !!impls?.actors.length;
@@ -4508,10 +5520,11 @@ function graphToXStateTS(graph, options = {}) {
 		implementationImports,
 		codeImports,
 		xstateVersion,
-		usesTypes: xstateVersion === 6 && supportsTypeSyntax && hasSchemas && xstateV6SchemaFormat === "types",
-		usesZod: xstateVersion === 6 && hasSchemas && xstateV6SchemaFormat === "zod"
+		usesTypes: xstateVersion === 6 && supportsTypeSyntax && (hasSchemas || hasStateSchemas) && xstateV6SchemaFormat === "types",
+		usesZod: xstateVersion === 6 && (hasSchemas || hasStateSchemas) && xstateV6SchemaFormat === "zod"
 	});
 	const machineConfig = xstateVersion === 6 ? toV6MachineConfig(graphToMachineConfig(graph, configOptions)) : toV5MachineConfig(graphToMachineConfig(graph, configOptions));
+	if (xstateVersion === 6) stripStateSchemas(machineConfig);
 	let machineExpr;
 	if (hasSetup) {
 		const setupObj = buildSetupObject(schemas, impls, {
@@ -4519,6 +5532,13 @@ function graphToXStateTS(graph, options = {}) {
 			xstateVersion,
 			xstateV6SchemaFormat
 		});
+		if (xstateVersion === 6) {
+			const states = buildV6SetupStates(graph, {
+				includeTypeSyntax: supportsTypeSyntax,
+				xstateV6SchemaFormat
+			});
+			if (states) setupObj.states = states;
+		}
 		const configStr = serializeJS(machineConfig, 2);
 		machineExpr = `setup(${serializeJS(setupObj, 0)}).createMachine(${configStr})`;
 	} else machineExpr = `createMachine(${serializeJS(machineConfig, 0)})`;
@@ -4535,6 +5555,51 @@ function graphToXStateTS(graph, options = {}) {
 	}
 	return lines.join("\n") + "\n";
 }
+function stripStateSchemas(config) {
+	delete config.schemas;
+	const states = config.states;
+	if (!states || typeof states !== "object" || Array.isArray(states)) return;
+	for (const state of Object.values(states)) if (state && typeof state === "object" && !Array.isArray(state)) stripStateSchemas(state);
+}
+function buildV6SetupStates(graph, options) {
+	const root = graph.nodes.find((node) => node.parentId == null);
+	if (!root) return void 0;
+	const buildState = (nodeId) => {
+		const node = graph.nodes.find((candidate) => candidate.id === nodeId);
+		if (!node) return void 0;
+		const result = {};
+		const schemas = buildV6StateSchemasBlock(node.data.schemas, options);
+		if (schemas) result.schemas = schemas;
+		const childStates = Object.fromEntries(graph.nodes.filter((candidate) => candidate.parentId === node.id).flatMap((child) => {
+			const contract = buildState(child.id);
+			return contract ? [[child.data.key, contract]] : [];
+		}));
+		if (Object.keys(childStates).length) result.states = childStates;
+		return Object.keys(result).length ? result : void 0;
+	};
+	const states = Object.fromEntries(graph.nodes.filter((node) => node.parentId === root.id).flatMap((node) => {
+		const contract = buildState(node.id);
+		return contract ? [[node.data.key, contract]] : [];
+	}));
+	return Object.keys(states).length ? states : void 0;
+}
+function buildV6StateSchemasBlock(schemas, options) {
+	if (!schemas) return void 0;
+	const result = {};
+	const contextSchema = schemas.context;
+	if (options.xstateV6SchemaFormat === "zod") {
+		const context = contextSchemaToZod(contextSchema);
+		if (context) result.context = raw(context);
+		if (schemas.input) result.input = raw(jsonSchemaToZod(schemas.input));
+		if (schemas.output) result.output = raw(jsonSchemaToZod(schemas.output));
+	} else if (options.includeTypeSyntax) {
+		const context = contextSchemaToTSType(contextSchema);
+		if (context) result.context = raw(`types<${context}>()`);
+		if (schemas.input) result.input = raw(`types<${jsonSchemaToTSType(schemas.input)}>()`);
+		if (schemas.output) result.output = raw(`types<${jsonSchemaToTSType(schemas.output)}>()`);
+	}
+	return Object.keys(result).length ? result : void 0;
+}
 function filterInlineImplementations(impls) {
 	if (!impls) return impls;
 	return {
@@ -5282,6 +6347,108 @@ function isCompleteFunctionExpression(code) {
 	if (!expression) return false;
 	return ts.isFunctionExpression(expression) || ts.isArrowFunction(expression);
 }
+function getXStateFSMCompatibilityIssues(graph) {
+	const root = graph.nodes.find((node) => node.parentId == null);
+	if (!root) return ["missing root state"];
+	const states = graph.nodes.filter((node) => node.parentId === root.id);
+	const stateIds = new Set(states.map((node) => node.id));
+	const issues = /* @__PURE__ */ new Set();
+	if (!root.data.initialId || !stateIds.has(root.data.initialId)) issues.add("missing initial state");
+	if (graph.nodes.some((node) => node.parentId !== null && node.parentId !== root.id)) issues.add("nested states");
+	if (states.some((node) => node.data.type && node.data.type !== "normal")) issues.add("non-atomic state types");
+	if (graph.nodes.some((node) => node.data.entry?.length || node.data.exit?.length || node.data.invokes?.length || node.data.timeout !== void 0 || node.data.route !== void 0 || node.data.output !== void 0 || node.data.initialInput !== void 0)) issues.add("state effects, invokes, timeouts, routes, or outputs");
+	if (graph.nodes.some((node) => node.data.schemas?.input || node.data.schemas?.output) || graph.data.schemas?.input || graph.data.schemas?.output) issues.add("input or output schemas");
+	if (graph.data.version || graph.data.options) issues.add("machine version or runtime options");
+	const eventCounts = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges.filter((edge) => stateIds.has(edge.sourceId))) {
+		const key = `${edge.sourceId}:${edge.data.eventType}`;
+		eventCounts.set(key, (eventCounts.get(key) ?? 0) + 1);
+		if (!edge.data.eventType) issues.add("eventless transitions");
+		if (!stateIds.has(edge.targetId) && edge.data.transitionType !== "targetless") issues.add("transitions outside the flat state set");
+		if (edge.data.guard || edge.data.actions?.length || edge.data.matches || edge.data.input !== void 0 || edge.data.transitionType === "reenter") issues.add("guards, actions, matching, transition input, or reentry");
+		if (isCodeExpression$1(edge.data.context)) issues.add("dynamic transition context");
+	}
+	if ([...eventCounts.values()].some((count) => count > 1)) issues.add("multiple transitions for one event");
+	return [...issues];
+}
+function graphToXStateFSM(graph, options = {}) {
+	const root = graph.nodes.find((node) => node.parentId == null);
+	if (!root) throw new Error("No root node found");
+	const states = graph.nodes.filter((node) => node.parentId === root.id);
+	const stateById = new Map(states.map((node) => [node.id, node]));
+	const initial = root.data.initialId ? stateById.get(root.data.initialId)?.data.key : void 0;
+	if (!initial) throw new Error("Cannot export XState FSM without an initial state.");
+	const schemaFormat = options.xstateV6SchemaFormat ?? "types";
+	const setupConfig = buildSetupConfig(graph, states, schemaFormat);
+	const config = {
+		id: root.data.nodeId || graph.id,
+		initial,
+		context: graph.data.context ?? void 0,
+		states: Object.fromEntries(states.map((state) => [state.data.key, buildState(graph, state, stateById)]))
+	};
+	const imports = [setupConfig ? "setup" : "createFSM"];
+	if (schemaFormat === "types" && setupConfig) imports.push("types");
+	const lines = [`import { ${imports.join(", ")} } from 'xstate/fsm';`];
+	if (schemaFormat === "zod" && setupConfig) lines.push(`import { z } from 'zod';`);
+	const expression = setupConfig ? `setup(${serializeJS(setupConfig, 0)}).createFSM(${serializeJS(config, 0)})` : `createFSM(${serializeJS(config, 0)})`;
+	lines.push("", `const machine = ${expression};`);
+	if ((options.exportStyle ?? "named") === "named") lines.push("", "export { machine };");
+	else if (options.exportStyle === "default") lines.push("", "export default machine;");
+	return `${lines.join("\n")}\n`;
+}
+function buildState(graph, state, stateById) {
+	const on = {};
+	for (const edge of graph.edges.filter((candidate) => candidate.sourceId === state.id)) {
+		const eventType = edge.data.eventType;
+		if (!eventType || on[eventType] !== void 0) continue;
+		const transition = buildTransition$1(edge, stateById);
+		if (transition !== void 0) on[eventType] = transition;
+	}
+	return Object.keys(on).length ? { on } : {};
+}
+function buildTransition$1(edge, stateById) {
+	const target = edge.data.transitionType === "targetless" ? void 0 : stateById.get(edge.targetId)?.data.key;
+	const context = isCodeExpression$1(edge.data.context) ? void 0 : edge.data.context;
+	if (context !== void 0) return {
+		target,
+		context
+	};
+	return target;
+}
+function buildSetupConfig(graph, states, format) {
+	const schemas = {};
+	const rootContext = graph.data.schemas?.context;
+	const rootEvents = graph.data.schemas?.events;
+	if (format === "types") {
+		const context = contextSchemaToTSType(rootContext);
+		if (context) schemas.context = raw(`types<${context}>()`);
+		if (rootEvents && Object.keys(rootEvents).length) schemas.events = Object.fromEntries(Object.entries(rootEvents).map(([eventType, schema]) => [eventType, raw(`types<${eventPayloadType(schema)}>()`)]));
+	} else {
+		const context = contextSchemaToZod(rootContext);
+		if (context) schemas.context = raw(context);
+		if (rootEvents && Object.keys(rootEvents).length) schemas.events = Object.fromEntries(Object.entries(rootEvents).map(([eventType, schema]) => [eventType, raw(eventSchemaToZod(schema))]));
+	}
+	const stateContracts = Object.fromEntries(states.flatMap((state) => {
+		const context = format === "types" ? contextSchemaToTSType(state.data.schemas?.context) : contextSchemaToZod(state.data.schemas?.context);
+		return context ? [[state.data.key, { schemas: { context: raw(format === "types" ? `types<${context}>()` : context) } }]] : [];
+	}));
+	const setup = {};
+	if (Object.keys(schemas).length) setup.schemas = schemas;
+	if (Object.keys(stateContracts).length) setup.states = stateContracts;
+	return Object.keys(setup).length ? setup : void 0;
+}
+function eventPayloadType(schema) {
+	const properties = Object.fromEntries(Object.entries(schema.properties ?? {}).filter(([key]) => key !== "type"));
+	const required = schema.required?.filter((key) => key !== "type");
+	return jsonSchemaToTSType({
+		...schema,
+		properties,
+		required
+	});
+}
+function isCodeExpression$1(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value) && value["@type"] === "code";
+}
 const colorSchema = _enum([
 	"green",
 	"red",
@@ -5663,4 +6830,4 @@ function getScriptKind(fileName) {
 }
 
 //#endregion
-export { RawCode as a, eventsSchemaToTSType as c, jsonSchemaToTSType as d, normalizeMachineProfile as f, xstateSourceToConfig as h, INLINE_EXPRESSION_DIRECTIVE_FIELDS as i, graphToMachineConfig as l, serializeJS as m, getStatelyPragma as n, contextSchemaToTSType as o, raw as p, upsertStatelyPragma as r, detectXStateSourceProfile as s, findStatelyPragmaAttachments as t, graphToXStateTS as u };
+export { normalizeMachineProfile as _, RawCode as a, xstateSourceToConfig as b, detectXStateSourceProfile as c, getXStateFSMCompatibilityIssues as d, graphChangeToPatchesResult as f, jsonSchemaToTSType as g, graphToXStateTS as h, INLINE_EXPRESSION_DIRECTIVE_FIELDS as i, diffGraphsSemantically as l, graphToXStateFSM as m, getStatelyPragma as n, alignCompareGraphIds as o, graphToMachineConfig as p, upsertStatelyPragma as r, contextSchemaToTSType as s, findStatelyPragmaAttachments as t, eventsSchemaToTSType as u, raw as v, serializeJS as y };