@statelyai/sdk 0.10.2 → 0.12.0

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-DOaLOySy.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 { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
@@ -111,9 +111,346 @@ function getLineStarts(text) {
 
 //#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(diff),
+		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
 	};
@@ -180,7 +517,7 @@ function normalizeGraphForSemanticDiff(graph) {
 function diffGraphsSemantically(baseGraph, compareGraph) {
 	const base = normalizeGraphForSemanticDiff(baseGraph);
 	const compare = normalizeGraphForSemanticDiff(compareGraph);
-	const diff = getDiff(base, compare);
+	const diff = getDiff$1(base, compare);
 	return {
 		base,
 		compare,
@@ -839,6 +1176,7 @@ function deepSimplify(config) {
 	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;
@@ -846,6 +1184,9 @@ function buildMeta(meta, color) {
 	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);
@@ -864,6 +1205,10 @@ function formatObjectKey(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(),
@@ -887,6 +1232,16 @@ const builtInActionParamSchemas = {
 	"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",
@@ -1003,7 +1358,7 @@ function actionCodeExpression(expr, source) {
 		}]
 	};
 }
-function inlineCodeExpression(expr) {
+function inlineCodeExpression$1(expr) {
 	return {
 		"@type": "code",
 		lang: "ts",
@@ -1021,7 +1376,7 @@ function serializeGuard(guard, asTypeRef) {
 		type: guard.type,
 		params: guard.params
 	} : { type: guard.type };
-	return guard.code ? inlineCodeExpression(guard.code) : guard;
+	return guard.code ? inlineCodeExpression$1(guard.code) : guard;
 }
 /**
 * Converts a built-in xstate ActionItem to a code expression directive,
@@ -1029,12 +1384,13 @@ function serializeGuard(guard, asTypeRef) {
 */
 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(exprCode);
+	if (exprCode) return inlineCodeExpression$1(exprCode);
 	if (!params || Object.keys(params).length === 0) return { type };
 	return {
 		type,
@@ -1061,7 +1417,8 @@ function graphToMachineConfig(graph, options = {}) {
 		const nodeType = [
 			"final",
 			"history",
-			"parallel"
+			"parallel",
+			"choice"
 		].includes(node.data.type) ? node.data.type : void 0;
 		const tags = node.data.tags;
 		Object.assign(nodeConfig, {
@@ -1076,6 +1433,7 @@ function graphToMachineConfig(graph, options = {}) {
 				...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,
@@ -1087,6 +1445,7 @@ function graphToMachineConfig(graph, options = {}) {
 			const on = {};
 			const after = {};
 			const alwaysArr = [];
+			const choiceArr = [];
 			const onDone = {};
 			const invokeMap = {};
 			for (const edge of edges) {
@@ -1098,6 +1457,7 @@ function graphToMachineConfig(graph, options = {}) {
 					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
@@ -1120,6 +1480,7 @@ function graphToMachineConfig(graph, options = {}) {
 					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];
@@ -1139,6 +1500,7 @@ function graphToMachineConfig(graph, options = {}) {
 			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];
@@ -1517,6 +1879,7 @@ function guardObject(value) {
 		const guard = value;
 		return {
 			type: guard.type,
+			code: guard.code,
 			params: guard.params
 		};
 	}
@@ -1547,9 +1910,10 @@ function machineConfigToGraph(config) {
 			parentId,
 			data: {
 				key,
-				type: state.type === "parallel" || state.type === "final" || state.type === "history" ? state.type : null,
+				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),
@@ -1568,6 +1932,7 @@ function machineConfigToGraph(config) {
 					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
@@ -1584,6 +1949,7 @@ function machineConfigToGraph(config) {
 					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
@@ -1600,12 +1966,30 @@ function machineConfigToGraph(config) {
 					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);
@@ -1633,6 +2017,19 @@ function propertyContext(parent, key) {
 		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
@@ -1641,21 +2038,28 @@ function propertyContext(parent, key) {
 		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 === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout") return {
+	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) {
-	return { meta: {
-		[XSTATE_V6_FN_TRANSITION_META]: true,
-		[XSTATE_V6_FN_SOURCE_META]: fn.getText()
-	} };
+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;
@@ -1670,10 +2074,28 @@ function simplifyConditions(conds) {
 		return true;
 	});
 }
-function guardFromConditions(conds) {
+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;
-	return { type: simplified.map(conditionText).join(" && ") };
+	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];
@@ -1688,12 +2110,6 @@ function transitionFromValue(value, actions) {
 	}
 	if (!value || typeof value !== "object" || Array.isArray(value)) return actions.length ? { actions } : null;
 	const record = { ...value };
-	const context = record.context;
-	delete record.context;
-	if (context !== void 0) record.actions = mergeActions(Array.isArray(record.actions) ? record.actions : record.actions ? [record.actions] : void 0, [{
-		type: "xstate.assign",
-		params: { assignment: context }
-	}]);
 	if (actions.length) record.actions = mergeActions(Array.isArray(record.actions) ? record.actions : record.actions ? [record.actions] : void 0, actions);
 	return record;
 }
@@ -1741,13 +2157,19 @@ function expressionBranches(expression, bindings, depth) {
 		const target = targetProperty ? unwrapExpression$2(targetProperty.initializer) : null;
 		if (target && (ts.isConditionalExpression(target) || ts.isBinaryExpression(target) && (target.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || target.operatorToken.kind === ts.SyntaxKind.BarBarToken))) return expressionBranches(target, bindings, depth + 1).map((branch) => ({
 			...branch,
-			result: objectLiteralToValue(node, bindings, {}, depth + 1, new Map([["target", branch.result]]))
+			result: objectLiteralToValue(node, bindings, {
+				v6: true,
+				transitionValue: true
+			}, depth + 1, new Map([["target", branch.result]]))
 		}));
 	}
 	return [{
 		conds: [],
 		actions: [],
-		result: expressionToValue(node, bindings, {}, depth + 1)
+		result: expressionToValue(node, bindings, {
+			v6: true,
+			transitionValue: true
+		}, depth + 1)
 	}];
 }
 function mergeBranchPrefix(prefix, branch) {
@@ -1833,9 +2255,15 @@ function statementBranches(statements, bindings, enqName, prefixes = [{
 }]) {
 	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({
@@ -1844,11 +2272,11 @@ function statementBranches(statements, bindings, enqName, prefixes = [{
 					});
 					continue;
 				}
-				for (const branch of expressionBranches(statement.expression, bindings, 0)) done.push(mergeBranchPrefix(prefix, branch));
+				for (const branch of expressionBranches(statement.expression, scopedBindings, 0)) done.push(mergeBranchPrefix(prefix, branch));
 				continue;
 			}
 			if (ts.isExpressionStatement(statement)) {
-				const action = expressionStatementAction(statement, enqName, bindings);
+				const action = expressionStatementAction(statement, enqName, scopedBindings);
 				if (action) {
 					nextOpen.push({
 						...prefix,
@@ -1859,12 +2287,12 @@ function statementBranches(statements, bindings, enqName, prefixes = [{
 			}
 			if (ts.isIfStatement(statement)) {
 				const cond = statement.expression.getText();
-				const thenBranches = statementBranches(ts.isBlock(statement.thenStatement) ? statement.thenStatement.statements : [statement.thenStatement], bindings, enqName, [{
+				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, bindings, enqName, [{
+				const elseBranches = elseStatements.length > 0 ? statementBranches(elseStatements, scopedBindings, enqName, [{
 					...prefix,
 					conds: [...prefix.conds, {
 						text: cond,
@@ -1887,7 +2315,7 @@ function statementBranches(statements, bindings, enqName, prefixes = [{
 				for (const clause of statement.caseBlock.clauses) {
 					const ownCond = ts.isCaseClause(clause) ? { text: `${expr} === ${clause.expression.getText()}` } : null;
 					const conds = ownCond ? [...prior, ownCond] : prior.length ? [...prior] : [];
-					const branches = statementBranches(clause.statements, bindings, enqName, [{
+					const branches = statementBranches(clause.statements, scopedBindings, enqName, [{
 						...prefix,
 						conds: [...prefix.conds, ...conds]
 					}]);
@@ -1913,18 +2341,24 @@ 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);
+		const transition = transitionFromValue(branch.result, branch.actions.length ? preservedActions : []);
 		if (!transition) return null;
 		if (typeof transition === "string") {
-			const guard = guardFromConditions(branch.conds);
+			const guard = guardFromConditions(branch.conds, guardParams(fn));
 			return guard ? {
 				target: transition,
 				guard
 			} : transition;
 		}
-		const guard = guardFromConditions(branch.conds);
+		const guard = guardFromConditions(branch.conds, guardParams(fn));
 		return guard ? {
 			...transition,
 			guard
@@ -1932,7 +2366,7 @@ function normalizeFunctionTransition(fn, bindings, depth) {
 	}).filter((transition) => Boolean(transition));
 	if (transitions.length === 1) return transitions[0];
 	if (transitions.length > 1) return transitions;
-	return fallbackFunctionTransition(fn);
+	return fallbackFunctionTransition(fn, preservedActions);
 }
 function inlineAction(fn) {
 	return {
@@ -1943,12 +2377,24 @@ function inlineAction(fn) {
 		}
 	};
 }
-function normalizeFunctionAction(fn, bindings) {
-	if (ts.isArrowFunction(fn) && !ts.isBlock(fn.body)) return inlineAction(fn);
-	if (!fn.body || !ts.isBlock(fn.body)) return inlineAction(fn);
-	const branches = statementBranches(fn.body.statements, bindings, enqueueParamName(fn));
-	if (branches.length === 1 && !branches[0].unknown && branches[0].conds.length === 0 && branches[0].actions.length > 0 && !("result" in branches[0])) return branches[0].actions;
-	return inlineAction(fn);
+function 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 = {};
@@ -1995,15 +2441,22 @@ function objectLiteralToValue(node, bindings, context, depth, overrides = /* @__
 function expressionToValue(expression, bindings, context = {}, depth = 0) {
 	if (depth > 30) return void 0;
 	const node = unwrapExpression$2(expression);
-	if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
-	if (ts.isNumericLiteral(node)) return Number(node.text);
-	if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
-	if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
-	if (node.kind === ts.SyntaxKind.NullKeyword) return null;
+	if (ts.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) : 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)) {
@@ -2011,17 +2464,19 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 		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 node.getText();
+	return context.metaValue ? inlineCodeExpression(node.getText()) : node.getText();
 }
 function collectBindings$1(file) {
 	const bindings = /* @__PURE__ */ new Map();
@@ -2048,7 +2503,7 @@ function hasV6Syntax(source) {
 				found = true;
 				return;
 			}
-			if ((key === "on" || key === "after" || key === "always" || key === "entry" || key === "exit" || key === "actions" && !ts.isObjectLiteralExpression(node.initializer)) && node.initializer.getText().includes("=>")) {
+			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;
 			}
@@ -2402,6 +2857,7 @@ const validationIssueCodeSchema = _enum([
 	"transition_never_taken",
 	"missing_guard",
 	"redundant_transition",
+	"eventless_cycle",
 	"missing_delay_implementation",
 	"invalid_final_transition",
 	"invalid_history_transition",
@@ -2698,6 +3154,51 @@ function getOnDoneWarnings(graph, reachableNodes) {
 	}
 	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);
@@ -2929,6 +3430,7 @@ function validateGraph(graph, sourceAllowed) {
 		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;