@statelyai/sdk 0.20.0 → 0.20.2

package/dist/{statelyPragma-GN-bfuC_.mjs → statelyPragma-Cnj58Rua.mjs}

@@ -1,4 +1,4 @@
-import { a as literal, c as record, d as unknown, i as discriminatedUnion, l as string, n as array, o as number, r as boolean, s as object, t as _enum, u as union } from "./schemas-C2raUv-n.mjs";
+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 "./schemas-b9wG-zYl.mjs";
 import ts from "typescript";
 import "xstate";
 import "xstate/graph";
@@ -2334,175 +2334,6 @@ var index_vite_proxy_tmp_default = import_js_yaml.default;
 
 //#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(to, from) {
-	return {
-		to,
-		from
-	};
-}
-createFormatConverter(toAdjacencyList, fromAdjacencyList);
-createFormatConverter(toEdgeList, fromEdgeList);
 const LAYOUT_KEYS = {
 	node: [
 		"x",
@@ -2518,6 +2349,8 @@ const LAYOUT_KEYS = {
 		"y",
 		"width",
 		"height",
+		"points",
+		"routing",
 		"style",
 		"color"
 	]
@@ -2638,9 +2471,14 @@ function stripExportDefault(code) {
 	if (trimmed.startsWith("export default ")) return trimmed.slice(15).replace(/;$/, "");
 	return trimmed;
 }
-const MACHINE_PROFILES = ["xstate-v5", "xstate-v6-alpha"];
+const XSTATE_V5_PROFILE = "@statelyai/xstate@5.30.0";
+const XSTATE_V6_PROFILE = "@statelyai/xstate@6.0.0-alpha.24";
+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;
+}
 function isXStateV6Profile(profile) {
-	return profile === "xstate-v6-alpha";
+	return (profile === "xstate-v5" || profile === "xstate-v6-alpha" ? normalizeMachineProfile(profile) : profile ?? XSTATE_V5_PROFILE).startsWith("@statelyai/xstate@6.");
 }
 /**
 * Graph-native transition references. Transitions point at invoke/action/state
@@ -3161,7 +2999,7 @@ function graphToMachineConfig(graph, options = {}) {
 		}
 		return nodeConfig;
 	}
-	const rootNode = graph.nodes.find((node) => node.data.parentId === null || node.parentId == null);
+	const rootNode = graph.nodes.find((node) => node.parentId === null || node.parentId == null);
 	if (!rootNode) throw new Error("No root node found");
 	getNodeConfig(rootNode);
 	if (graph.data.context !== void 0 && graph.data.context !== null) config.context = graph.data.context;
@@ -3175,703 +3013,254 @@ const INLINE_EXPRESSION_DIRECTIVE_FIELDS = [
 	"initialInput",
 	"route"
 ];
-function jsonSchemaToTSType(schema) {
-	if (!schema) return "unknown";
-	if (schema.enum) return schema.enum.map((v) => typeof v === "string" ? `'${v}'` : String(v)).join(" | ");
-	if (schema.const !== void 0) return typeof schema.const === "string" ? `'${schema.const}'` : String(schema.const);
-	if (schema.oneOf) return schema.oneOf.map((s) => jsonSchemaToTSType(resolveDef(s))).join(" | ");
-	if (schema.anyOf) return schema.anyOf.map((s) => jsonSchemaToTSType(resolveDef(s))).join(" | ");
-	if (schema.allOf) return schema.allOf.map((s) => jsonSchemaToTSType(resolveDef(s))).join(" & ");
-	if (schema.type === "array") return `Array<${jsonSchemaToTSType(resolveDef(schema.items))}>`;
-	if (Array.isArray(schema.type)) return schema.type.map((t) => primitiveType(t)).join(" | ");
-	if (schema.type === "object" || schema.properties) return objectType(schema);
-	if (schema.type) return primitiveType(schema.type);
-	return "unknown";
-}
-function primitiveType(type) {
-	switch (type) {
-		case "string": return "string";
-		case "number":
-		case "integer": return "number";
-		case "boolean": return "boolean";
-		case "null": return "null";
-		default: return "unknown";
-	}
-}
-function objectType(schema) {
-	const props = schema.properties;
-	if (!props || Object.keys(props).length === 0) {
-		if (schema.additionalProperties) return `Record<string, ${jsonSchemaToTSType(resolveDef(schema.additionalProperties))}>`;
-		return "Record<string, unknown>";
+const XSTATE_FORMATS = [
+	{
+		format: "typescript",
+		import: true,
+		export: true,
+		sourcePreserving: true
+	},
+	{
+		format: "javascript",
+		import: true,
+		export: true,
+		sourcePreserving: true
+	},
+	{
+		format: "json",
+		import: true,
+		export: true
+	},
+	{
+		format: "yaml",
+		import: true,
+		export: true
 	}
-	const required = getRequiredKeys(schema);
-	return `{ ${Object.entries(props).map(([key, def]) => {
-		const type = jsonSchemaToTSType(resolveDef(def));
-		return `${key}${isRequiredProperty(key, def, required) ? "" : "?"}: ${type}`;
-	}).join("; ")} }`;
+];
+const XSTATE_PROFILE_MANIFESTS = [{
+	profile: XSTATE_V5_PROFILE,
+	name: "XState v5",
+	formats: [...XSTATE_FORMATS]
+}, {
+	profile: XSTATE_V6_PROFILE,
+	name: "XState v6",
+	formats: [...XSTATE_FORMATS]
+}];
+const PROFILE_MANIFESTS = new Map(XSTATE_PROFILE_MANIFESTS.map((manifest) => [manifest.profile, manifest]));
+const XSTATE_V6_FN_TRANSITION_META = "@statelyai.xstate.v6.fnTransition";
+const XSTATE_V6_FN_SOURCE_META = "@statelyai.xstate.v6.fnSource";
+function sourceFile(source) {
+	return ts.createSourceFile("machine.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
 }
-function resolveDef(def) {
-	if (!def) return void 0;
-	if (Array.isArray(def)) return resolveDef(def[0]);
-	if (typeof def === "boolean") return void 0;
-	return def;
+function propName(name) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+	return null;
 }
-/**
-* Build an inline context type string from the schemas.context record.
-* Each key is a context property name, value is its JSONSchema7.
-*/
-function contextSchemaToTSType(context) {
-	if (!context || Object.keys(context).length === 0) return null;
-	return `{ ${Object.entries(context).map(([key, schema]) => {
-		return `${key}: ${jsonSchemaToTSType(schema)}`;
-	}).join("; ")} }`;
+function unwrapExpression(node) {
+	if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node) || ts.isParenthesizedExpression(node)) return unwrapExpression(node.expression);
+	return node;
 }
-/**
-* Build an event union type from the schemas.events record.
-* Each key is the event type name, value describes the payload properties.
-*/
-function eventsSchemaToTSType(events) {
-	if (!events || Object.keys(events).length === 0) return null;
-	return Object.entries(events).map(([eventType, schema]) => {
-		const props = schema.properties;
-		if (!props || Object.keys(props).length === 0) return `{ type: '${eventType}' }`;
-		const required = getRequiredKeys(schema);
-		const extraProps = Object.entries(props).filter(([k]) => k !== "type").map(([key, def]) => {
-			const type = jsonSchemaToTSType(resolveDef(def));
-			return `${key}${isRequiredProperty(key, def, required) ? "" : "?"}: ${type}`;
-		});
-		if (extraProps.length === 0) return `{ type: '${eventType}' }`;
-		return `{ type: '${eventType}'; ${extraProps.join("; ")} }`;
-	}).join("\n  | ");
+function propertyContext(parent, key) {
+	if (parent.invokeValue && key === "src") return {
+		v6: parent.v6,
+		actorSourceValue: true
+	};
+	if (parent.transitionMap) return {
+		v6: parent.v6,
+		transitionValue: true
+	};
+	if (parent.transitionValue && key === "actions") return {
+		v6: parent.v6,
+		actionValue: true
+	};
+	if (parent.transitionValue && key === "context") return {
+		v6: parent.v6,
+		assignmentMap: true,
+		transitionContext: true
+	};
+	if (parent.assignmentMap) return {
+		v6: parent.v6,
+		assignmentValue: true
+	};
+	if (key === "meta") return {
+		v6: parent.v6,
+		metaValue: true
+	};
+	if (parent.transitionValue && key === "to") return {
+		v6: parent.v6,
+		transitionValue: true
+	};
+	if (key === "entry" || key === "exit") return {
+		v6: parent.v6,
+		actionValue: true
+	};
+	if (key === "input" || key === "output") return {
+		v6: parent.v6,
+		ioValue: true
+	};
+	if (parent.ioValue || parent.ioPropertyValue) return {
+		v6: parent.v6,
+		ioPropertyValue: true
+	};
+	if (key === "invoke") return {
+		v6: parent.v6,
+		invokeValue: true
+	};
+	if (key === "timeout") return {
+		v6: parent.v6,
+		timeoutValue: true
+	};
+	if (key === "route") return {
+		v6: parent.v6,
+		routeValue: true
+	};
+	if (key === "on" || key === "after") return {
+		v6: parent.v6,
+		transitionMap: true
+	};
+	if (key === "always" || key === "choice" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout") return {
+		v6: parent.v6,
+		transitionValue: true
+	};
+	return { v6: parent.v6 };
 }
-function getRequiredKeys(schema) {
-	return new Set(Array.isArray(schema.required) ? schema.required : []);
+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 isRequiredProperty(key, def, required) {
-	if (required.has(key)) return true;
-	return typeof def === "object" && def !== null && def.required === true;
+function conditionText(cond) {
+	return cond.negated ? `!(${cond.text})` : cond.text;
 }
-function graphToXStateTS(graph, options = {}) {
-	const { exportStyle = "named", targetLanguage = "typescript", xstateVersion = 5, ...configOptions } = options;
-	const schemas = graph.data.schemas;
-	const impls = filterInlineImplementations(graph.data.implementations);
-	const supportsTypeSyntax = targetLanguage === "typescript";
-	const hasSchemas = !!(schemas && (schemas.context || schemas.events || schemas.input || schemas.output));
-	const hasActions = !!impls?.actions.length;
-	const hasGuards = !!impls?.guards.length;
-	const hasActors = !!impls?.actors.length;
-	const hasDelays = !!impls?.delays.length;
-	const hasSetup = hasSchemas || hasActions || hasGuards || hasActors || hasDelays;
-	const builtInActions = getUsedBuiltInActions(graph, xstateVersion);
-	const actorSourceImports = getActorSourceImports(graph);
-	const imports = buildImports({
-		hasSetup,
-		hasActors,
-		actors: impls?.actors ?? [],
-		builtInActions,
-		actorSourceImports,
-		usesTypes: xstateVersion === 6 && supportsTypeSyntax && hasSchemas
+function simplifyConditions(conds) {
+	const seen = /* @__PURE__ */ new Set();
+	return conds.filter((cond) => {
+		if (cond.negated) return false;
+		const key = conditionText(cond);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
 	});
-	const machineConfig = xstateVersion === 6 ? toV6MachineConfig(graphToMachineConfig(graph, configOptions)) : toV5MachineConfig(graphToMachineConfig(graph, configOptions));
-	let machineExpr;
-	if (hasSetup) {
-		const setupObj = buildSetupObject(schemas, impls, {
-			includeTypeSyntax: supportsTypeSyntax,
-			xstateVersion
-		});
-		const configStr = serializeJS(machineConfig, 2);
-		machineExpr = `setup(${serializeJS(setupObj, 0)}).createMachine(${configStr})`;
-	} else machineExpr = `createMachine(${serializeJS(machineConfig, 0)})`;
-	const lines = [];
-	lines.push(imports);
-	lines.push("");
-	lines.push(`const machine = ${machineExpr};`);
-	if (exportStyle === "named") {
-		lines.push("");
-		lines.push("export { machine };");
-	} else if (exportStyle === "default") {
-		lines.push("");
-		lines.push("export default machine;");
-	}
-	return lines.join("\n") + "\n";
 }
-function filterInlineImplementations(impls) {
-	if (!impls) return impls;
+function hashString(value) {
+	let hash = 5381;
+	for (let i = 0; i < value.length; i++) hash = hash * 33 ^ value.charCodeAt(i);
+	return (hash >>> 0).toString(36);
+}
+function inlineGuardCode(params, condition) {
+	return `${params} => ${condition}`;
+}
+function guardFromConditions(conds, params) {
+	const simplified = simplifyConditions(conds);
+	if (simplified.length === 0) return void 0;
+	const code = inlineGuardCode(params, simplified.map(conditionText).join(" && "));
 	return {
-		...impls,
-		actions: impls.actions.filter((action) => !action.name.startsWith("inline:")),
-		guards: impls.guards.filter((guard) => !guard.name.startsWith("inline:")),
-		delays: impls.delays.filter((delay) => !delay.name.startsWith("inline:"))
+		type: `inline:${hashString(code)}`,
+		code
 	};
 }
-/** Map from xstate action type to the import name */
-const BUILTIN_ACTION_IMPORTS = {
-	"xstate.raise": "raise",
-	"xstate.sendTo": "sendTo",
-	"xstate.cancel": "cancel",
-	"xstate.emit": "emit",
-	"xstate.spawnChild": "spawnChild",
-	"xstate.stopChild": "stopChild",
-	"xstate.log": "log",
-	"xstate.assign": "assign"
-};
-/** Check inline action/entry/exit code for references to xstate builtins */
-function scanInlineCodeForBuiltins(code, used) {
-	const expr = stripExportDefault(code);
-	for (const importName of Object.values(BUILTIN_ACTION_IMPORTS)) if (new RegExp(`\\b${importName}\\b`).test(expr)) used.add(importName);
-}
-function getExprActionCode(action) {
-	return action.type === "xstate.expr" && typeof action.params?.code === "string" ? action.params.code : void 0;
-}
-function getUsedBuiltInActions(graph, xstateVersion) {
-	const used = /* @__PURE__ */ new Set();
-	if (xstateVersion === 6) return used;
-	for (const node of graph.nodes) for (const action of [...node.data.entry ?? [], ...node.data.exit ?? []]) {
-		const imp = BUILTIN_ACTION_IMPORTS[action.type];
-		if (imp) used.add(imp);
-		const exprCode = getExprActionCode(action);
-		if (exprCode) scanInlineCodeForBuiltins(exprCode, used);
-	}
-	for (const edge of graph.edges) for (const action of edge.data.actions ?? []) {
-		const imp = BUILTIN_ACTION_IMPORTS[action.type];
-		if (imp) used.add(imp);
-		const exprCode = getExprActionCode(action);
-		if (exprCode) scanInlineCodeForBuiltins(exprCode, used);
-	}
-	return used;
-}
-function toV5MachineConfig(machineConfig) {
-	return mapMachineActionFields(machineConfig, (actions, wasArray) => {
-		const mapped = actions.map(unwrapDirectEnqExpression);
-		return wasArray ? mapped : mapped[0];
-	});
-}
-function toV6MachineConfig(machineConfig) {
-	return mapV6MachineConfig(machineConfig);
-}
-function mapV6MachineConfig(value, context = {}) {
-	if (Array.isArray(value)) return value.map((item) => mapV6MachineConfig(item, context));
-	if (!value || typeof value !== "object") return value;
-	if (context.transitionValue) return toV6TransitionValue(value);
-	const result = {};
-	for (const [key, item] of Object.entries(value)) {
-		if (key === "entry" || key === "exit" || key === "actions") {
-			result[key] = toV6ActionField(Array.isArray(item) ? item : item === void 0 ? [] : [item]);
-			continue;
-		}
-		if (key === "on" || key === "after") {
-			result[key] = mapV6TransitionMap(item);
-			continue;
-		}
-		if (key === "always" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout") {
-			result[key] = mapV6MachineConfig(item, { transitionValue: true });
-			continue;
-		}
-		result[key] = mapV6MachineConfig(item);
-	}
-	return result;
+function wrapAssignExpression(expr) {
+	return `{{ ${expr.trim()} }}`;
 }
-function mapV6TransitionMap(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-	const result = {};
-	for (const [key, item] of Object.entries(value)) result[key] = mapV6MachineConfig(item, { transitionValue: true });
-	return result;
+function hasSpreadAssignment(node) {
+	return node.properties.some((property) => ts.isSpreadAssignment(property));
 }
-function toV6TransitionValue(value) {
-	if (Array.isArray(value)) return value.map((item) => toV6TransitionValue(item));
-	if (!value || typeof value !== "object") return value;
-	const transition = value;
-	if (transition.guard || transition.description || transition.input !== void 0) return mapV6MachineConfig(transition);
-	const target = transition.target;
-	const context = transition.context;
-	const actionsValue = transition.actions;
-	const actions = Array.isArray(actionsValue) ? actionsValue : actionsValue === void 0 ? [] : [actionsValue];
-	if (actions.length === 0 && typeof target === "string" && context === void 0 && !transition.reenter && !transition.meta) return target;
-	if (actions.length === 0 && target === void 0 && context === void 0) return mapV6MachineConfig(transition);
-	return buildV6ActionFunction(actions, {
-		target: typeof target === "string" ? target : void 0,
-		reenter: transition.reenter === true,
-		meta: transition.meta,
-		context
-	}) ?? mapV6MachineConfig(transition);
+function mergeActions(left, right) {
+	return [...left ?? [], ...right];
 }
-function toV6ActionField(actions) {
-	if (actions.length === 1) {
-		const expr = inlineExpr(actions[0]);
-		if (expr && isCompleteFunctionExpression(stripExportDefault(expr))) return raw(stripExportDefault(expr));
+function transitionFromValue(value, actions) {
+	if (typeof value === "string") {
+		if (actions.length === 0) return value;
+		return {
+			target: value,
+			actions
+		};
 	}
-	return buildV6ActionFunction(actions) ?? actions;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return actions.length ? { actions } : null;
+	const record = { ...value };
+	if (actions.length) record.actions = mergeActions(Array.isArray(record.actions) ? record.actions : record.actions ? [record.actions] : void 0, actions);
+	return record;
 }
-function buildV6ActionFunction(actions, transition) {
-	const effects = actions.map(actionToV6Effect);
-	if (effects.some((effect) => !effect)) return void 0;
-	const statements = effects.flatMap((effect) => effect?.statements ?? []);
-	let returnValue;
-	let contextValue;
-	for (const effect of effects) {
-		returnValue = effect?.returnValue ?? returnValue;
-		contextValue = effect?.contextValue ?? contextValue;
+function expressionBranches(expression, bindings, depth) {
+	const node = unwrapExpression(expression);
+	if (ts.isConditionalExpression(node)) {
+		const cond = node.condition.getText();
+		return [...expressionBranches(node.whenTrue, bindings, depth + 1).map((branch) => ({
+			...branch,
+			conds: [{ text: cond }, ...branch.conds]
+		})), ...expressionBranches(node.whenFalse, bindings, depth + 1).map((branch) => ({
+			...branch,
+			conds: [{
+				text: cond,
+				negated: true
+			}, ...branch.conds]
+		}))];
 	}
-	if (transition) returnValue = buildV6TransitionReturnValue(transition, transition.context === void 0 ? contextValue : serializeJS(unwrapTemplateExpressions(transition.context)));
-	if (statements.length === 0 && !returnValue) return void 0;
-	return raw(`(_, enq) => {\n${[...statements.map((statement) => `  ${statement};`), ...returnValue ? [`  return ${returnValue};`] : []].join("\n")}\n}`);
-}
-function unwrapTemplateExpressions(value) {
-	if (typeof value === "string") {
-		const match = value.match(/^\{\{\s*([\s\S]*?)\s*\}\}$/);
-		return match?.[1] ? raw(match[1]) : value;
+	if (ts.isBinaryExpression(node) && (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === ts.SyntaxKind.BarBarToken)) {
+		const cond = node.left.getText();
+		if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) return [...expressionBranches(node.right, bindings, depth + 1).map((branch) => ({
+			...branch,
+			conds: [{ text: cond }, ...branch.conds]
+		})), {
+			conds: [{
+				text: cond,
+				negated: true
+			}],
+			actions: []
+		}];
+		return [{
+			conds: [{ text: cond }],
+			actions: [],
+			result: node.left.getText()
+		}, ...expressionBranches(node.right, bindings, depth + 1).map((branch) => ({
+			...branch,
+			conds: [{
+				text: cond,
+				negated: true
+			}, ...branch.conds]
+		}))];
 	}
-	if (Array.isArray(value)) return value.map(unwrapTemplateExpressions);
-	if (!value || typeof value !== "object") return value;
-	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, unwrapTemplateExpressions(item)]));
-}
-function buildV6TransitionReturnValue(transition, contextValue) {
-	if (!transition.reenter && !transition.meta && !contextValue) return transition.target ? `{ target: ${serializeJS(transition.target)} }` : void 0;
-	return serializeJS({
-		target: transition.target,
-		reenter: transition.reenter ? true : void 0,
-		meta: transition.meta,
-		context: contextValue ? raw(contextValue) : void 0
-	});
-}
-function mapMachineActionFields(value, mapActions) {
-	if (Array.isArray(value)) return value.map((item) => mapMachineActionFields(item, mapActions));
-	if (!value || typeof value !== "object") return value;
-	const result = {};
-	for (const [key, item] of Object.entries(value)) {
-		if (key === "entry" || key === "exit" || key === "actions") {
-			const wasArray = Array.isArray(item);
-			result[key] = mapActions(wasArray ? item : item === void 0 ? [] : [item], wasArray);
-			continue;
-		}
-		result[key] = mapMachineActionFields(item, mapActions);
+	if (ts.isObjectLiteralExpression(node)) {
+		const targetProperty = node.properties.find((property) => ts.isPropertyAssignment(property) && propName(property.name) === "target");
+		const target = targetProperty ? unwrapExpression(targetProperty.initializer) : null;
+		if (target && (ts.isConditionalExpression(target) || ts.isBinaryExpression(target) && (target.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || target.operatorToken.kind === ts.SyntaxKind.BarBarToken))) return expressionBranches(target, bindings, depth + 1).map((branch) => ({
+			...branch,
+			result: objectLiteralToValue(node, bindings, {
+				v6: true,
+				transitionValue: true
+			}, depth + 1, new Map([["target", branch.result]]))
+		}));
 	}
-	return result;
-}
-function unwrapDirectEnqExpression(action) {
-	const expr = inlineExpr(action);
-	if (!expr) return action;
-	const match = expr.match(/^enq\(([\s\S]*)\)$/);
-	return match?.[1] ? raw(match[1]) : action;
+	return [{
+		conds: [],
+		actions: [],
+		result: expressionToValue(node, bindings, {
+			v6: true,
+			transitionValue: true
+		}, depth + 1)
+	}];
 }
-function inlineExpr(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return;
-	const directive = value;
-	return directive["@type"] === "code" && typeof directive.expr === "string" ? directive.expr : void 0;
+function mergeBranchPrefix(prefix, branch) {
+	return {
+		conds: [...prefix.conds, ...branch.conds],
+		actions: [...prefix.actions, ...branch.actions],
+		result: branch.result,
+		unknown: prefix.unknown || branch.unknown
+	};
 }
-function actionToV6Effect(action) {
-	const expr = inlineExpr(action);
-	if (expr) {
-		if (expr.startsWith("enq(") || expr.startsWith("enq.")) return { statements: [expr] };
-		const builtIn = expr.match(/^(raise|emit|sendTo|cancel|log|spawnChild|stopChild)\(([\s\S]*)\)$/);
-		if (builtIn) {
-			const [, name, args] = builtIn;
-			return { statements: [`enq.${name === "spawnChild" ? "spawn" : name === "stopChild" ? "stop" : name}(${args})`] };
-		}
-		return { statements: [`enq(${expr})`] };
-	}
-	if (!action || typeof action !== "object" || Array.isArray(action)) return null;
-	const record = action;
-	const type = record.type;
-	if (typeof type !== "string") return null;
-	const params = record.params && typeof record.params === "object" && !Array.isArray(record.params) ? record.params : {};
-	if (type === "xstate.raise") {
-		const options = actionOptions(params, ["event"]);
-		return { statements: [`enq.raise(${serializeJS(params.event)}${options})`] };
-	}
-	if (type === "xstate.emit") return { statements: [`enq.emit(${serializeJS(params.event)})`] };
-	if (type === "xstate.sendTo") {
-		const options = actionOptions(params, ["to", "event"]);
-		return { statements: [`enq.sendTo(${serializeJS(params.to)}, ${serializeJS(params.event)}${options})`] };
-	}
-	if (type === "xstate.cancel") return { statements: [`enq.cancel(${serializeJS(params.sendId)})`] };
-	if (type === "xstate.log") return { statements: [`enq.log(${serializeJS(params.label)})`] };
-	if (type === "xstate.spawnChild") {
-		const options = actionOptions(params, ["src"]);
-		return { statements: [`enq.spawn(${serializeJS(params.src)}${options})`] };
-	}
-	if (type === "xstate.stopChild") return { statements: [`enq.stop(${serializeJS(params.actorRef)})`] };
-	if (type === "xstate.assign") {
-		const contextValue = serializeJS(params.assignment ?? params);
-		return {
-			contextValue,
-			returnValue: `{ context: ${contextValue} }`
-		};
-	}
-	return null;
-}
-function actionOptions(params, consumedKeys) {
-	const rest = Object.fromEntries(Object.entries(params).filter(([key, value]) => !consumedKeys.includes(key) && value !== void 0));
-	return Object.keys(rest).length ? `, ${serializeJS(rest)}` : "";
-}
-function buildImports({ hasSetup, hasActors, actors, builtInActions, actorSourceImports, usesTypes }) {
-	const xstateImports = [];
-	if (hasSetup) xstateImports.push("setup");
-	else xstateImports.push("createMachine");
-	for (const name of builtInActions) xstateImports.push(name);
-	for (const name of actorSourceImports) xstateImports.push(name);
-	if (usesTypes) xstateImports.push("types");
-	if (hasActors) {
-		if (actors.length > 0) xstateImports.push("fromPromise");
-	}
-	return `import { ${[...new Set(xstateImports)].join(", ")} } from 'xstate';`;
-}
-function getActorSourceImports(graph) {
-	const imports = /* @__PURE__ */ new Set();
-	const candidates = [
-		"createAsyncLogic",
-		"fromPromise",
-		"fromCallback",
-		"fromObservable",
-		"fromEventObservable",
-		"fromTransition"
-	];
-	for (const node of graph.nodes) for (const invoke of node.data.invokes ?? []) {
-		const expression = invoke.srcExpression?.expr;
-		if (!expression) continue;
-		for (const candidate of candidates) if (new RegExp(`\\b${candidate}\\b`).test(expression)) imports.add(candidate);
-	}
-	return imports;
-}
-function buildSetupObject(schemas, impls, options) {
-	const setup = {};
-	if (options.xstateVersion === 6) {
-		const schemasBlock = buildV6SchemasBlock(schemas, options);
-		if (schemasBlock) setup.schemas = schemasBlock;
-	} else {
-		const types = buildTypesBlock(schemas, options);
-		if (types) setup.types = types;
-	}
-	if (impls?.actions.length) setup.actions = buildActionsBlock(impls.actions, options);
-	if (impls?.guards.length) setup.guards = buildGuardsBlock(impls.guards, options);
-	if (impls?.actors.length) setup.actors = buildActorsBlock(impls.actors, options);
-	if (impls?.delays.length) setup.delays = buildDelaysBlock(impls.delays);
-	return setup;
-}
-function buildTypesBlock(schemas, options) {
-	if (!schemas || !options.includeTypeSyntax) return void 0;
-	const types = {};
-	const contextType = contextSchemaToTSType(schemas.context);
-	if (contextType) types.context = raw(`{} as ${contextType}`);
-	const eventsType = eventsSchemaToTSType(schemas.events);
-	if (eventsType) types.events = raw(`{} as\n    | ${eventsType}`);
-	if (schemas.input) types.input = raw(`{} as ${jsonSchemaToTSType(schemas.input)}`);
-	if (schemas.output) types.output = raw(`{} as ${jsonSchemaToTSType(schemas.output)}`);
-	return Object.keys(types).length > 0 ? types : void 0;
-}
-function buildV6SchemasBlock(schemas, options) {
-	if (!schemas || !options.includeTypeSyntax) return void 0;
-	const result = {};
-	const contextType = contextSchemaToTSType(schemas.context);
-	if (contextType) result.context = raw(`types<${contextType}>()`);
-	if (schemas.events && Object.keys(schemas.events).length > 0) result.events = Object.fromEntries(Object.entries(schemas.events).map(([eventType, schema]) => [eventType, raw(`types<${eventPayloadSchemaToTSType(schema)}>()`)]));
-	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 > 0 ? result : void 0;
-}
-function eventPayloadSchemaToTSType(schema) {
-	const props = schema.properties ?? {};
-	const payloadProps = Object.fromEntries(Object.entries(props).filter(([key]) => key !== "type"));
-	if (Object.keys(payloadProps).length === 0) return "{}";
-	return jsonSchemaToTSType({
-		...schema,
-		properties: payloadProps,
-		required: Array.isArray(schema.required) ? schema.required.filter((key) => key !== "type") : void 0
-	});
-}
-function hasSchemaProperties(schema) {
-	if (!schema) return false;
-	if (schema.type === "object" || schema.properties) {
-		const props = schema.properties;
-		return !!props && Object.keys(props).length > 0;
-	}
-	return true;
-}
-function buildActionsBlock(actions, options) {
-	const block = {};
-	for (const implementation of actions) if (implementation.code?.body) {
-		const inlineExpression = getInlineExpression(implementation.code.body);
-		if (inlineExpression) {
-			block[implementation.name] = raw(inlineExpression);
-			continue;
-		}
-		const params = hasSchemaProperties(implementation.paramsSchema) ? options.includeTypeSyntax ? `, params: ${jsonSchemaToTSType(implementation.paramsSchema)}` : ", params" : "";
-		block[implementation.name] = raw(`function ({ context, event }${params ? params : ""}) {\n  ${dedent(implementation.code.body)}\n}`);
-	} else block[implementation.name] = raw(`function ({ context, event }) {\n  // TODO: implement ${implementation.name}\n}`);
-	return block;
-}
-function buildGuardsBlock(guards, options) {
-	const block = {};
-	for (const guard of guards) if (guard.code?.body) {
-		const inlineExpression = getInlineExpression(guard.code.body);
-		if (inlineExpression) {
-			block[guard.name] = raw(inlineExpression);
-			continue;
-		}
-		const params = hasSchemaProperties(guard.paramsSchema) ? options.includeTypeSyntax ? `, params: ${jsonSchemaToTSType(guard.paramsSchema)}` : ", params" : "";
-		block[guard.name] = raw(`function ({ context, event }${params ? params : ""}) {\n  ${dedent(guard.code.body)}\n}`);
-	} else block[guard.name] = raw(`function ({ context, event }) {\n  // TODO: implement ${guard.name}\n  return false;\n}`);
-	return block;
-}
-function buildActorsBlock(actors, options) {
-	const block = {};
-	for (const actor of actors) if (actor.code?.body) {
-		const inputType = options.includeTypeSyntax && hasSchemaProperties(actor.inputSchema) ? `: ${jsonSchemaToTSType(actor.inputSchema)}` : "";
-		block[actor.name] = raw(`fromPromise(async ({ input }${inputType ? `: { input${inputType} }` : ""}) => {\n  ${dedent(actor.code.body)}\n})`);
-	} else block[actor.name] = raw(`fromPromise(async ({ input }) => {\n  // TODO: implement ${actor.name}\n})`);
-	return block;
-}
-function buildDelaysBlock(delays) {
-	const block = {};
-	for (const delay of delays) if (delay.code?.body) {
-		const inlineExpression = getInlineExpression(delay.code.body);
-		if (inlineExpression) {
-			block[delay.name] = raw(inlineExpression);
-			continue;
-		}
-		block[delay.name] = raw(`function ({ context, event }) {\n  ${dedent(delay.code.body)}\n}`);
-	} else block[delay.name] = raw(`function () {\n  // TODO: implement ${delay.name}\n  return 1000;\n}`);
-	return block;
-}
-/**
-* Returns the implementation to emit verbatim when `body` is already a complete
-* expression, so it is NOT wrapped in another `function ({ context, event }) { ... }`.
-* Handles two cases:
-*  - `export default <expr>` → the inner expression.
-*  - a bare function/arrow expression (e.g. a guard captured via `fn.toString()`
-*    on import) → the expression itself.
-* Returns undefined for a plain statement body, which still needs wrapping.
-*/
-function getInlineExpression(code) {
-	const stripped = stripExportDefault(code);
-	if (stripped !== code.trim()) return stripped;
-	return isCompleteFunctionExpression(stripped) ? stripped : void 0;
-}
-/** True when `code` is a single function or arrow-function expression. */
-function isCompleteFunctionExpression(code) {
-	const candidate = code.trim().replace(/;$/, "");
-	const source = ts.createSourceFile("impl.ts", `(${candidate})`, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-	if ((source.parseDiagnostics ?? []).length > 0 || source.statements.length !== 1) return false;
-	const [statement] = source.statements;
-	if (!statement || !ts.isExpressionStatement(statement)) return false;
-	let expression = statement.expression;
-	if (ts.isParenthesizedExpression(expression)) expression = expression.expression;
-	return ts.isFunctionExpression(expression) || ts.isArrowFunction(expression);
-}
-const XSTATE_V6_FN_TRANSITION_META = "@statelyai.xstate.v6.fnTransition";
-const XSTATE_V6_FN_SOURCE_META = "@statelyai.xstate.v6.fnSource";
-function sourceFile(source) {
-	return ts.createSourceFile("machine.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-}
-function propName(name) {
-	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
-	return null;
-}
-function unwrapExpression(node) {
-	if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node) || ts.isParenthesizedExpression(node)) return unwrapExpression(node.expression);
-	return node;
-}
-function propertyContext(parent, key) {
-	if (parent.invokeValue && key === "src") return {
-		v6: parent.v6,
-		actorSourceValue: true
-	};
-	if (parent.transitionMap) return {
-		v6: parent.v6,
-		transitionValue: true
-	};
-	if (parent.transitionValue && key === "actions") return {
-		v6: parent.v6,
-		actionValue: true
-	};
-	if (parent.transitionValue && key === "context") return {
-		v6: parent.v6,
-		assignmentMap: true,
-		transitionContext: true
-	};
-	if (parent.assignmentMap) return {
-		v6: parent.v6,
-		assignmentValue: true
-	};
-	if (key === "meta") return {
-		v6: parent.v6,
-		metaValue: true
-	};
-	if (parent.transitionValue && key === "to") return {
-		v6: parent.v6,
-		transitionValue: true
-	};
-	if (key === "entry" || key === "exit") return {
-		v6: parent.v6,
-		actionValue: true
-	};
-	if (key === "input" || key === "output") return {
-		v6: parent.v6,
-		ioValue: true
-	};
-	if (parent.ioValue || parent.ioPropertyValue) return {
-		v6: parent.v6,
-		ioPropertyValue: true
-	};
-	if (key === "invoke") return {
-		v6: parent.v6,
-		invokeValue: true
-	};
-	if (key === "timeout") return {
-		v6: parent.v6,
-		timeoutValue: true
-	};
-	if (key === "route") return {
-		v6: parent.v6,
-		routeValue: true
-	};
-	if (key === "on" || key === "after") return {
-		v6: parent.v6,
-		transitionMap: true
-	};
-	if (key === "always" || key === "choice" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout") return {
-		v6: parent.v6,
-		transitionValue: true
-	};
-	return { v6: parent.v6 };
-}
-function fallbackFunctionTransition(fn, actions = []) {
-	return {
-		...actions.length ? { actions } : void 0,
-		meta: {
-			[XSTATE_V6_FN_TRANSITION_META]: true,
-			[XSTATE_V6_FN_SOURCE_META]: fn.getText()
-		}
-	};
-}
-function conditionText(cond) {
-	return cond.negated ? `!(${cond.text})` : cond.text;
-}
-function simplifyConditions(conds) {
-	const seen = /* @__PURE__ */ new Set();
-	return conds.filter((cond) => {
-		if (cond.negated) return false;
-		const key = conditionText(cond);
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	});
-}
-function hashString(value) {
-	let hash = 5381;
-	for (let i = 0; i < value.length; i++) hash = hash * 33 ^ value.charCodeAt(i);
-	return (hash >>> 0).toString(36);
-}
-function inlineGuardCode(params, condition) {
-	return `${params} => ${condition}`;
-}
-function guardFromConditions(conds, params) {
-	const simplified = simplifyConditions(conds);
-	if (simplified.length === 0) return void 0;
-	const code = inlineGuardCode(params, simplified.map(conditionText).join(" && "));
-	return {
-		type: `inline:${hashString(code)}`,
-		code
-	};
-}
-function wrapAssignExpression(expr) {
-	return `{{ ${expr.trim()} }}`;
-}
-function hasSpreadAssignment(node) {
-	return node.properties.some((property) => ts.isSpreadAssignment(property));
-}
-function mergeActions(left, right) {
-	return [...left ?? [], ...right];
-}
-function transitionFromValue(value, actions) {
-	if (typeof value === "string") {
-		if (actions.length === 0) return value;
-		return {
-			target: value,
-			actions
-		};
-	}
-	if (!value || typeof value !== "object" || Array.isArray(value)) return actions.length ? { actions } : null;
-	const record = { ...value };
-	if (actions.length) record.actions = mergeActions(Array.isArray(record.actions) ? record.actions : record.actions ? [record.actions] : void 0, actions);
-	return record;
-}
-function expressionBranches(expression, bindings, depth) {
-	const node = unwrapExpression(expression);
-	if (ts.isConditionalExpression(node)) {
-		const cond = node.condition.getText();
-		return [...expressionBranches(node.whenTrue, bindings, depth + 1).map((branch) => ({
-			...branch,
-			conds: [{ text: cond }, ...branch.conds]
-		})), ...expressionBranches(node.whenFalse, bindings, depth + 1).map((branch) => ({
-			...branch,
-			conds: [{
-				text: cond,
-				negated: true
-			}, ...branch.conds]
-		}))];
-	}
-	if (ts.isBinaryExpression(node) && (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === ts.SyntaxKind.BarBarToken)) {
-		const cond = node.left.getText();
-		if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) return [...expressionBranches(node.right, bindings, depth + 1).map((branch) => ({
-			...branch,
-			conds: [{ text: cond }, ...branch.conds]
-		})), {
-			conds: [{
-				text: cond,
-				negated: true
-			}],
-			actions: []
-		}];
-		return [{
-			conds: [{ text: cond }],
-			actions: [],
-			result: node.left.getText()
-		}, ...expressionBranches(node.right, bindings, depth + 1).map((branch) => ({
-			...branch,
-			conds: [{
-				text: cond,
-				negated: true
-			}, ...branch.conds]
-		}))];
-	}
-	if (ts.isObjectLiteralExpression(node)) {
-		const targetProperty = node.properties.find((property) => ts.isPropertyAssignment(property) && propName(property.name) === "target");
-		const target = targetProperty ? unwrapExpression(targetProperty.initializer) : null;
-		if (target && (ts.isConditionalExpression(target) || ts.isBinaryExpression(target) && (target.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || target.operatorToken.kind === ts.SyntaxKind.BarBarToken))) return expressionBranches(target, bindings, depth + 1).map((branch) => ({
-			...branch,
-			result: objectLiteralToValue(node, bindings, {
-				v6: true,
-				transitionValue: true
-			}, depth + 1, new Map([["target", branch.result]]))
-		}));
-	}
-	return [{
-		conds: [],
-		actions: [],
-		result: expressionToValue(node, bindings, {
-			v6: true,
-			transitionValue: true
-		}, depth + 1)
-	}];
-}
-function mergeBranchPrefix(prefix, branch) {
-	return {
-		conds: [...prefix.conds, ...branch.conds],
-		actions: [...prefix.actions, ...branch.actions],
-		result: branch.result,
-		unknown: prefix.unknown || branch.unknown
-	};
-}
-function expressionStatementAction(statement, enqName, bindings) {
-	const expression = unwrapExpression(statement.expression);
-	if (!ts.isCallExpression(expression)) return null;
-	const callee = expression.expression;
-	if (ts.isIdentifier(callee) && callee.text === enqName) return {
-		type: "xstate.expr",
-		params: {
-			code: expression.getText(),
-			lang: "ts"
+function expressionStatementAction(statement, enqName, bindings) {
+	const expression = unwrapExpression(statement.expression);
+	if (!ts.isCallExpression(expression)) return null;
+	const callee = expression.expression;
+	if (ts.isIdentifier(callee) && callee.text === enqName) return {
+		type: "xstate.expr",
+		params: {
+			code: expression.getText(),
+			lang: "ts"
 		}
 	};
 	if (!ts.isPropertyAccessExpression(callee)) return null;
@@ -3916,400 +3305,883 @@ function expressionStatementAction(statement, enqName, bindings) {
 	if (method === "spawn") return {
 		type: "xstate.spawnChild",
 		params: {
-			src: value(0),
-			...spreadOpts(1)
+			src: value(0),
+			...spreadOpts(1)
+		}
+	};
+	if (method === "stop") return {
+		type: "xstate.stopChild",
+		params: { actorRef: value(0) }
+	};
+	return {
+		type: "xstate.expr",
+		params: {
+			code: expression.getText(),
+			lang: "ts"
+		}
+	};
+}
+function statementBranches(statements, bindings, enqName, prefixes = [{
+	conds: [],
+	actions: []
+}]) {
+	let open = prefixes;
+	const done = [];
+	const scopedBindings = new Map(bindings);
+	for (const statement of statements) {
+		const nextOpen = [];
+		for (const prefix of open) {
+			if (ts.isVariableStatement(statement)) {
+				for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) scopedBindings.set(declaration.name.text, declaration.initializer);
+				nextOpen.push(prefix);
+				continue;
+			}
+			if (ts.isReturnStatement(statement)) {
+				if (!statement.expression) {
+					done.push({
+						...prefix,
+						result: void 0
+					});
+					continue;
+				}
+				for (const branch of expressionBranches(statement.expression, scopedBindings, 0)) done.push(mergeBranchPrefix(prefix, branch));
+				continue;
+			}
+			if (ts.isExpressionStatement(statement)) {
+				const action = expressionStatementAction(statement, enqName, scopedBindings);
+				if (action) {
+					nextOpen.push({
+						...prefix,
+						actions: [...prefix.actions, action]
+					});
+					continue;
+				}
+			}
+			if (ts.isIfStatement(statement)) {
+				const cond = statement.expression.getText();
+				const thenBranches = statementBranches(ts.isBlock(statement.thenStatement) ? statement.thenStatement.statements : [statement.thenStatement], scopedBindings, enqName, [{
+					...prefix,
+					conds: [...prefix.conds, { text: cond }]
+				}]);
+				const elseStatements = statement.elseStatement ? ts.isBlock(statement.elseStatement) ? statement.elseStatement.statements : [statement.elseStatement] : [];
+				const elseBranches = elseStatements.length > 0 ? statementBranches(elseStatements, scopedBindings, enqName, [{
+					...prefix,
+					conds: [...prefix.conds, {
+						text: cond,
+						negated: true
+					}]
+				}]) : [{
+					...prefix,
+					conds: [...prefix.conds, {
+						text: cond,
+						negated: true
+					}]
+				}];
+				for (const branch of [...thenBranches, ...elseBranches]) if ("result" in branch) done.push(branch);
+				else nextOpen.push(branch);
+				continue;
+			}
+			if (ts.isSwitchStatement(statement)) {
+				const expr = statement.expression.getText();
+				const prior = [];
+				for (const clause of statement.caseBlock.clauses) {
+					const ownCond = ts.isCaseClause(clause) ? { text: `${expr} === ${clause.expression.getText()}` } : null;
+					const conds = ownCond ? [...prior, ownCond] : prior.length ? [...prior] : [];
+					const branches = statementBranches(clause.statements, scopedBindings, enqName, [{
+						...prefix,
+						conds: [...prefix.conds, ...conds]
+					}]);
+					for (const branch of branches) if ("result" in branch) done.push(branch);
+					else nextOpen.push(branch);
+					if (ownCond) prior.push({
+						...ownCond,
+						negated: true
+					});
+				}
+				continue;
+			}
+			nextOpen.push({
+				...prefix,
+				unknown: true
+			});
+		}
+		open = nextOpen;
+	}
+	return [...done, ...open];
+}
+function enqueueParamName(fn) {
+	const param = fn.parameters[1];
+	return param && ts.isIdentifier(param.name) ? param.name.text : "enq";
+}
+function guardParams(fn) {
+	const param = fn.parameters[0];
+	if (!param) return "()";
+	return `(${param.getText()})`;
+}
+function normalizeFunctionTransition(fn, bindings, depth) {
+	const preservedActions = fn.body && ts.isBlock(fn.body) && fn.body.statements.some((statement) => ts.isExpressionStatement(statement)) ? [enqueueAction(fn)] : [];
+	const transitions = (ts.isArrowFunction(fn) && !ts.isBlock(fn.body) ? expressionBranches(fn.body, bindings, depth + 1) : fn.body && ts.isBlock(fn.body) ? statementBranches(fn.body.statements, bindings, enqueueParamName(fn)) : []).filter((branch) => !branch.unknown).map((branch) => {
+		const transition = transitionFromValue(branch.result, branch.actions.length ? preservedActions : []);
+		if (!transition) return null;
+		if (typeof transition === "string") {
+			const guard = guardFromConditions(branch.conds, guardParams(fn));
+			return guard ? {
+				target: transition,
+				guard
+			} : transition;
+		}
+		const guard = guardFromConditions(branch.conds, guardParams(fn));
+		return guard ? {
+			...transition,
+			guard
+		} : transition;
+	}).filter((transition) => Boolean(transition));
+	if (transitions.length === 1) return transitions[0];
+	if (transitions.length > 1) return transitions;
+	return fallbackFunctionTransition(fn, preservedActions);
+}
+function inlineAction(fn) {
+	return {
+		type: "xstate.expr",
+		params: {
+			code: fn.getText(),
+			lang: "ts"
 		}
 	};
-	if (method === "stop") return {
-		type: "xstate.stopChild",
-		params: { actorRef: value(0) }
-	};
+}
+function enqueueAction(fn) {
 	return {
-		type: "xstate.expr",
+		type: "xstate.enqueue",
 		params: {
-			code: expression.getText(),
+			code: fn.getText(),
 			lang: "ts"
 		}
 	};
 }
-function statementBranches(statements, bindings, enqName, prefixes = [{
-	conds: [],
-	actions: []
-}]) {
-	let open = prefixes;
-	const done = [];
-	const scopedBindings = new Map(bindings);
-	for (const statement of statements) {
-		const nextOpen = [];
-		for (const prefix of open) {
-			if (ts.isVariableStatement(statement)) {
-				for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) scopedBindings.set(declaration.name.text, declaration.initializer);
-				nextOpen.push(prefix);
-				continue;
-			}
-			if (ts.isReturnStatement(statement)) {
-				if (!statement.expression) {
-					done.push({
-						...prefix,
-						result: void 0
-					});
-					continue;
-				}
-				for (const branch of expressionBranches(statement.expression, scopedBindings, 0)) done.push(mergeBranchPrefix(prefix, branch));
-				continue;
-			}
-			if (ts.isExpressionStatement(statement)) {
-				const action = expressionStatementAction(statement, enqName, scopedBindings);
-				if (action) {
-					nextOpen.push({
-						...prefix,
-						actions: [...prefix.actions, action]
-					});
-					continue;
-				}
+function inlineCodeExpression(expr) {
+	return {
+		"@type": "code",
+		lang: "ts",
+		expr
+	};
+}
+function normalizeFunctionAction(fn, _bindings) {
+	return enqueueAction(fn);
+}
+function objectLiteralToValue(node, bindings, context, depth, overrides = /* @__PURE__ */ new Map()) {
+	const result = {};
+	for (const property of node.properties) {
+		if (ts.isSpreadAssignment(property)) {
+			const spread = expressionToValue(property.expression, bindings, context, depth + 1);
+			if (spread && typeof spread === "object" && !Array.isArray(spread)) Object.assign(result, spread);
+			continue;
+		}
+		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) continue;
+		const key = propName(property.name);
+		if (!key) continue;
+		if (overrides.has(key)) {
+			result[key] = overrides.get(key);
+			continue;
+		}
+		if (ts.isShorthandPropertyAssignment(property)) {
+			result[key] = expressionToValue(property.name, bindings, propertyContext(context, key), depth + 1);
+			continue;
+		}
+		result[key] = expressionToValue(property.initializer, bindings, propertyContext(context, key), depth + 1);
+	}
+	if (context.transitionValue && "to" in result) {
+		const to = result.to;
+		const { to: _to, ...rest } = result;
+		if (typeof to === "string") return {
+			...rest,
+			target: to
+		};
+		if (Array.isArray(to)) return to.map((item) => typeof item === "string" ? {
+			...rest,
+			target: item
+		} : item && typeof item === "object" ? {
+			...rest,
+			...item
+		} : rest);
+		if (to && typeof to === "object" && !Array.isArray(to)) return {
+			...rest,
+			...to
+		};
+	}
+	return result;
+}
+function expressionToValue(expression, bindings, context = {}, depth = 0) {
+	if (depth > 30) return void 0;
+	const node = unwrapExpression(expression);
+	if (context.actorSourceValue) {
+		if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+		if (ts.isIdentifier(node)) {
+			const binding = bindings.get(node.text);
+			if (binding && !ts.isFunctionDeclaration(binding)) return inlineCodeExpression(unwrapExpression(binding).getText());
+		}
+		return inlineCodeExpression(node.getText());
+	}
+	if (context.routeValue && !ts.isObjectLiteralExpression(node)) {
+		if (ts.isIdentifier(node)) {
+			const binding = bindings.get(node.text);
+			if (binding && !ts.isFunctionDeclaration(binding)) return expressionToValue(binding, bindings, context, depth + 1);
+		}
+		return inlineCodeExpression(node.getText());
+	}
+	if (context.timeoutValue && (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isCallExpression(node))) return inlineCodeExpression(node.getText());
+	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.ioPropertyValue) {
+		if (ts.isIdentifier(node) && node.text === "undefined") return void 0;
+		if (ts.isIdentifier(node)) {
+			const binding = bindings.get(node.text);
+			if (binding && !ts.isFunctionDeclaration(binding)) return expressionToValue(binding, bindings, context, depth + 1);
+		}
+		if (!ts.isObjectLiteralExpression(node) && !ts.isArrayLiteralExpression(node)) return inlineCodeExpression(node.getText());
+	}
+	if (context.assignmentValue) {
+		if (ts.isIdentifier(node) && node.text === "undefined") return void 0;
+		if (ts.isIdentifier(node)) {
+			const binding = bindings.get(node.text);
+			if (binding && !ts.isFunctionDeclaration(binding)) return expressionToValue(binding, bindings, context, depth + 1);
+		}
+		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);
+		if (binding) {
+			if (ts.isFunctionDeclaration(binding)) {
+				if (context.metaValue) return inlineCodeExpression(binding.name?.text ?? node.getText());
+				if (context.v6 && context.transitionValue) return normalizeFunctionTransition(binding, bindings, depth + 1);
+				if (context.v6 && context.actionValue) return normalizeFunctionAction(binding, bindings);
+				return binding.name?.text ?? node.text;
 			}
-			if (ts.isIfStatement(statement)) {
-				const cond = statement.expression.getText();
-				const thenBranches = statementBranches(ts.isBlock(statement.thenStatement) ? statement.thenStatement.statements : [statement.thenStatement], scopedBindings, enqName, [{
-					...prefix,
-					conds: [...prefix.conds, { text: cond }]
-				}]);
-				const elseStatements = statement.elseStatement ? ts.isBlock(statement.elseStatement) ? statement.elseStatement.statements : [statement.elseStatement] : [];
-				const elseBranches = elseStatements.length > 0 ? statementBranches(elseStatements, scopedBindings, enqName, [{
-					...prefix,
-					conds: [...prefix.conds, {
-						text: cond,
-						negated: true
-					}]
-				}]) : [{
-					...prefix,
-					conds: [...prefix.conds, {
-						text: cond,
-						negated: true
-					}]
-				}];
-				for (const branch of [...thenBranches, ...elseBranches]) if ("result" in branch) done.push(branch);
-				else nextOpen.push(branch);
-				continue;
+			return expressionToValue(binding, bindings, context, depth + 1);
+		}
+		return context.metaValue ? inlineCodeExpression(node.getText()) : node.text;
+	}
+	if (ts.isObjectLiteralExpression(node)) return objectLiteralToValue(node, bindings, context, depth);
+	if (ts.isArrayLiteralExpression(node)) {
+		const values = node.elements.map((element) => expressionToValue(element, bindings, context, depth + 1));
+		return context.actionValue ? values.flat() : values;
+	}
+	if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+		if (context.metaValue) return inlineCodeExpression(node.getText());
+		if (context.v6 && context.transitionValue) return normalizeFunctionTransition(node, bindings, depth);
+		if (context.v6 && context.actionValue) return normalizeFunctionAction(node, bindings);
+		return node.getText();
+	}
+	if (ts.isCallExpression(node)) {
+		if (context.metaValue) return inlineCodeExpression(node.getText());
+		if (ts.isIdentifier(node.expression)) {
+			const binding = bindings.get(node.expression.text);
+			if (binding && isFunctionBinding(binding)) return evaluateFunctionCall(binding, node.arguments, bindings, context, depth + 1);
+		}
+		if (ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "createStateConfig") {
+			const configArg = node.arguments.length > 1 ? node.arguments[1] : node.arguments[0];
+			return configArg ? expressionToValue(configArg, bindings, { v6: context.v6 }, depth + 1) : {};
+		}
+		if (context.actionValue) return inlineAction(node);
+		const callee = node.expression.getText();
+		const type = callee.includes(".") ? callee.split(".").pop() : callee;
+		return { type: type === "assign" ? "xstate.assign" : type };
+	}
+	return context.metaValue ? inlineCodeExpression(node.getText()) : node.getText();
+}
+function isFunctionBinding(binding) {
+	return ts.isArrowFunction(binding) || ts.isFunctionExpression(binding) || ts.isFunctionDeclaration(binding);
+}
+function evaluateFunctionCall(fn, args, bindings, context, depth) {
+	const scopedBindings = new Map(bindings);
+	for (const [index, parameter] of fn.parameters.entries()) {
+		if (!ts.isIdentifier(parameter.name)) continue;
+		const argument = args[index];
+		if (argument) scopedBindings.set(parameter.name.text, argument);
+		else if (parameter.initializer) scopedBindings.set(parameter.name.text, parameter.initializer);
+	}
+	if (ts.isArrowFunction(fn) && !ts.isBlock(fn.body)) return expressionToValue(fn.body, scopedBindings, context, depth + 1);
+	if (context.v6 && context.transitionValue) return normalizeFunctionTransition(fn, scopedBindings, depth + 1);
+	if (context.v6 && context.actionValue) return normalizeFunctionAction(fn, scopedBindings);
+	return context.metaValue ? inlineCodeExpression(fn.getText()) : fn.name?.getText() ?? fn.getText();
+}
+function collectBindings(file) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of file.statements) {
+		if (ts.isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) bindings.set(declaration.name.text, declaration.initializer);
+			continue;
+		}
+		if (ts.isFunctionDeclaration(statement) && statement.name) bindings.set(statement.name.text, statement);
+	}
+	return bindings;
+}
+function isCreateMachineCall(node) {
+	const expression = node.expression;
+	if (ts.isIdentifier(expression)) return expression.text === "createMachine";
+	if (ts.isPropertyAccessExpression(expression)) return expression.name.text === "createMachine";
+	return false;
+}
+function hasV6Syntax(source) {
+	const file = sourceFile(source);
+	const bindings = collectBindings(file);
+	let found = false;
+	function containsFunction(expression, seenBindings = /* @__PURE__ */ new Set()) {
+		if (ts.isFunctionDeclaration(expression)) return true;
+		const node = unwrapExpression(expression);
+		if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) return true;
+		if (ts.isIdentifier(node)) {
+			if (seenBindings.has(node.text)) return false;
+			const binding = bindings.get(node.text);
+			if (!binding) return false;
+			return containsFunction(binding, new Set([...seenBindings, node.text]));
+		}
+		if (ts.isObjectLiteralExpression(node)) return node.properties.some((property) => {
+			if (ts.isPropertyAssignment(property)) return containsFunction(property.initializer, seenBindings);
+			if (ts.isShorthandPropertyAssignment(property)) return containsFunction(property.name, seenBindings);
+			if (ts.isSpreadAssignment(property)) return containsFunction(property.expression, seenBindings);
+			return false;
+		});
+		if (ts.isArrayLiteralExpression(node)) return node.elements.some((element) => ts.isExpression(element) && containsFunction(element, seenBindings));
+		if (ts.isCallExpression(node)) return ts.isIdentifier(node.expression) && containsFunction(node.expression, seenBindings) || node.arguments.some((argument) => ts.isExpression(argument) && containsFunction(argument, seenBindings));
+		return false;
+	}
+	function visit(node) {
+		if (found) return;
+		if (ts.isPropertyAssignment(node) && (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name))) {
+			const key = node.name.text;
+			if (key === "triggers" || key === "internalEvents" || key === "matches" || key === "actorSources" || key === "timeout" || key === "onTimeout" || key === "choice" || key === "route") {
+				found = true;
+				return;
 			}
-			if (ts.isSwitchStatement(statement)) {
-				const expr = statement.expression.getText();
-				const prior = [];
-				for (const clause of statement.caseBlock.clauses) {
-					const ownCond = ts.isCaseClause(clause) ? { text: `${expr} === ${clause.expression.getText()}` } : null;
-					const conds = ownCond ? [...prior, ownCond] : prior.length ? [...prior] : [];
-					const branches = statementBranches(clause.statements, scopedBindings, enqName, [{
-						...prefix,
-						conds: [...prefix.conds, ...conds]
-					}]);
-					for (const branch of branches) if ("result" in branch) done.push(branch);
-					else nextOpen.push(branch);
-					if (ownCond) prior.push({
-						...ownCond,
-						negated: true
-					});
-				}
-				continue;
+			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)) && containsFunction(node.initializer)) {
+				found = true;
+				return;
 			}
-			nextOpen.push({
-				...prefix,
-				unknown: true
-			});
 		}
-		open = nextOpen;
+		ts.forEachChild(node, visit);
 	}
-	return [...done, ...open];
+	visit(file);
+	return found;
 }
-function enqueueParamName(fn) {
-	const param = fn.parameters[1];
-	return param && ts.isIdentifier(param.name) ? param.name.text : "enq";
+function detectXStateSourceProfile(source) {
+	return hasV6Syntax(source) ? "xstate-v6-alpha" : "xstate-v5";
 }
-function guardParams(fn) {
-	const param = fn.parameters[0];
-	if (!param) return "()";
-	return `(${param.getText()})`;
+function xstateSourceToConfig(source, options = {}) {
+	const [config] = extractXStateMachineConfigs(source, options);
+	if (!config) throw new Error("No createMachine(...) or setup(...).createMachine(...) call found.");
+	return config;
 }
-function normalizeFunctionTransition(fn, bindings, depth) {
-	const preservedActions = fn.body && ts.isBlock(fn.body) && fn.body.statements.some((statement) => ts.isExpressionStatement(statement)) ? [enqueueAction(fn)] : [];
-	const transitions = (ts.isArrowFunction(fn) && !ts.isBlock(fn.body) ? expressionBranches(fn.body, bindings, depth + 1) : fn.body && ts.isBlock(fn.body) ? statementBranches(fn.body.statements, bindings, enqueueParamName(fn)) : []).filter((branch) => !branch.unknown).map((branch) => {
-		const transition = transitionFromValue(branch.result, branch.actions.length ? preservedActions : []);
-		if (!transition) return null;
-		if (typeof transition === "string") {
-			const guard = guardFromConditions(branch.conds, guardParams(fn));
-			return guard ? {
-				target: transition,
-				guard
-			} : transition;
+/**
+* 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 = {}) {
+	const file = sourceFile(source);
+	const bindings = collectBindings(file);
+	const found = [];
+	const profile = options.profile === "auto" || !options.profile ? detectXStateSourceProfile(source) : options.profile;
+	function visit(node) {
+		if (!ts.isCallExpression(node) || !isCreateMachineCall(node)) {
+			ts.forEachChild(node, visit);
+			return;
 		}
-		const guard = guardFromConditions(branch.conds, guardParams(fn));
-		return guard ? {
-			...transition,
-			guard
-		} : transition;
-	}).filter((transition) => Boolean(transition));
-	if (transitions.length === 1) return transitions[0];
-	if (transitions.length > 1) return transitions;
-	return fallbackFunctionTransition(fn, preservedActions);
+		const arg = node.arguments[0];
+		if (!arg) return;
+		const value = expressionToValue(arg, bindings, { v6: profile === "xstate-v6-alpha" });
+		if (value && typeof value === "object" && !Array.isArray(value)) found.push(value);
+	}
+	visit(file);
+	return found;
 }
-function inlineAction(fn) {
-	return {
-		type: "xstate.expr",
-		params: {
-			code: fn.getText(),
-			lang: "ts"
-		}
-	};
+function jsonSchemaToTSType(schema) {
+	if (!schema) return "unknown";
+	if (schema.enum) return schema.enum.map((v) => typeof v === "string" ? `'${v}'` : String(v)).join(" | ");
+	if (schema.const !== void 0) return typeof schema.const === "string" ? `'${schema.const}'` : String(schema.const);
+	if (schema.oneOf) return schema.oneOf.map((s) => jsonSchemaToTSType(resolveDef(s))).join(" | ");
+	if (schema.anyOf) return schema.anyOf.map((s) => jsonSchemaToTSType(resolveDef(s))).join(" | ");
+	if (schema.allOf) return schema.allOf.map((s) => jsonSchemaToTSType(resolveDef(s))).join(" & ");
+	if (schema.type === "array") return `Array<${jsonSchemaToTSType(resolveDef(schema.items))}>`;
+	if (Array.isArray(schema.type)) return schema.type.map((t) => primitiveType(t)).join(" | ");
+	if (schema.type === "object" || schema.properties) return objectType(schema);
+	if (schema.type) return primitiveType(schema.type);
+	return "unknown";
 }
-function enqueueAction(fn) {
+function primitiveType(type) {
+	switch (type) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		default: return "unknown";
+	}
+}
+function objectType(schema) {
+	const props = schema.properties;
+	if (!props || Object.keys(props).length === 0) {
+		if (schema.additionalProperties) return `Record<string, ${jsonSchemaToTSType(resolveDef(schema.additionalProperties))}>`;
+		return "Record<string, unknown>";
+	}
+	const required = getRequiredKeys(schema);
+	return `{ ${Object.entries(props).map(([key, def]) => {
+		const type = jsonSchemaToTSType(resolveDef(def));
+		return `${key}${isRequiredProperty(key, def, required) ? "" : "?"}: ${type}`;
+	}).join("; ")} }`;
+}
+function resolveDef(def) {
+	if (!def) return void 0;
+	if (Array.isArray(def)) return resolveDef(def[0]);
+	if (typeof def === "boolean") return void 0;
+	return def;
+}
+/**
+* Build an inline context type string from the schemas.context record.
+* Each key is a context property name, value is its JSONSchema7.
+*/
+function contextSchemaToTSType(context) {
+	if (!context || Object.keys(context).length === 0) return null;
+	return `{ ${Object.entries(context).map(([key, schema]) => {
+		return `${key}: ${jsonSchemaToTSType(schema)}`;
+	}).join("; ")} }`;
+}
+/**
+* Build an event union type from the schemas.events record.
+* Each key is the event type name, value describes the payload properties.
+*/
+function eventsSchemaToTSType(events) {
+	if (!events || Object.keys(events).length === 0) return null;
+	return Object.entries(events).map(([eventType, schema]) => {
+		const props = schema.properties;
+		if (!props || Object.keys(props).length === 0) return `{ type: '${eventType}' }`;
+		const required = getRequiredKeys(schema);
+		const extraProps = Object.entries(props).filter(([k]) => k !== "type").map(([key, def]) => {
+			const type = jsonSchemaToTSType(resolveDef(def));
+			return `${key}${isRequiredProperty(key, def, required) ? "" : "?"}: ${type}`;
+		});
+		if (extraProps.length === 0) return `{ type: '${eventType}' }`;
+		return `{ type: '${eventType}'; ${extraProps.join("; ")} }`;
+	}).join("\n  | ");
+}
+function getRequiredKeys(schema) {
+	return new Set(Array.isArray(schema.required) ? schema.required : []);
+}
+function isRequiredProperty(key, def, required) {
+	if (required.has(key)) return true;
+	return typeof def === "object" && def !== null && def.required === true;
+}
+function graphToXStateTS(graph, options = {}) {
+	const { exportStyle = "named", targetLanguage = "typescript", xstateVersion = 5, ...configOptions } = options;
+	const schemas = graph.data.schemas;
+	const impls = filterInlineImplementations(graph.data.implementations);
+	const supportsTypeSyntax = targetLanguage === "typescript";
+	const hasSchemas = !!(schemas && (schemas.context || schemas.events || schemas.input || schemas.output));
+	const hasActions = !!impls?.actions.length;
+	const hasGuards = !!impls?.guards.length;
+	const hasActors = !!impls?.actors.length;
+	const hasDelays = !!impls?.delays.length;
+	const hasSetup = hasSchemas || hasActions || hasGuards || hasActors || hasDelays;
+	const builtInActions = getUsedBuiltInActions(graph, xstateVersion);
+	const actorSourceImports = getActorSourceImports(graph);
+	const imports = buildImports({
+		hasSetup,
+		hasActors,
+		actors: impls?.actors ?? [],
+		builtInActions,
+		actorSourceImports,
+		usesTypes: xstateVersion === 6 && supportsTypeSyntax && hasSchemas
+	});
+	const machineConfig = xstateVersion === 6 ? toV6MachineConfig(graphToMachineConfig(graph, configOptions)) : toV5MachineConfig(graphToMachineConfig(graph, configOptions));
+	let machineExpr;
+	if (hasSetup) {
+		const setupObj = buildSetupObject(schemas, impls, {
+			includeTypeSyntax: supportsTypeSyntax,
+			xstateVersion
+		});
+		const configStr = serializeJS(machineConfig, 2);
+		machineExpr = `setup(${serializeJS(setupObj, 0)}).createMachine(${configStr})`;
+	} else machineExpr = `createMachine(${serializeJS(machineConfig, 0)})`;
+	const lines = [];
+	lines.push(imports);
+	lines.push("");
+	lines.push(`const machine = ${machineExpr};`);
+	if (exportStyle === "named") {
+		lines.push("");
+		lines.push("export { machine };");
+	} else if (exportStyle === "default") {
+		lines.push("");
+		lines.push("export default machine;");
+	}
+	return lines.join("\n") + "\n";
+}
+function filterInlineImplementations(impls) {
+	if (!impls) return impls;
 	return {
-		type: "xstate.enqueue",
-		params: {
-			code: fn.getText(),
-			lang: "ts"
-		}
+		...impls,
+		actions: impls.actions.filter((action) => !action.name.startsWith("inline:")),
+		guards: impls.guards.filter((guard) => !guard.name.startsWith("inline:")),
+		delays: impls.delays.filter((delay) => !delay.name.startsWith("inline:"))
 	};
 }
-function inlineCodeExpression(expr) {
-	return {
-		"@type": "code",
-		lang: "ts",
-		expr
-	};
+/** Map from xstate action type to the import name */
+const BUILTIN_ACTION_IMPORTS = {
+	"xstate.raise": "raise",
+	"xstate.sendTo": "sendTo",
+	"xstate.cancel": "cancel",
+	"xstate.emit": "emit",
+	"xstate.spawnChild": "spawnChild",
+	"xstate.stopChild": "stopChild",
+	"xstate.log": "log",
+	"xstate.assign": "assign"
+};
+/** Check inline action/entry/exit code for references to xstate builtins */
+function scanInlineCodeForBuiltins(code, used) {
+	const expr = stripExportDefault(code);
+	for (const importName of Object.values(BUILTIN_ACTION_IMPORTS)) if (new RegExp(`\\b${importName}\\b`).test(expr)) used.add(importName);
+}
+function getExprActionCode(action) {
+	return action.type === "xstate.expr" && typeof action.params?.code === "string" ? action.params.code : void 0;
 }
-function normalizeFunctionAction(fn, _bindings) {
-	return enqueueAction(fn);
+function getUsedBuiltInActions(graph, xstateVersion) {
+	const used = /* @__PURE__ */ new Set();
+	if (xstateVersion === 6) return used;
+	for (const node of graph.nodes) for (const action of [...node.data.entry ?? [], ...node.data.exit ?? []]) {
+		const imp = BUILTIN_ACTION_IMPORTS[action.type];
+		if (imp) used.add(imp);
+		const exprCode = getExprActionCode(action);
+		if (exprCode) scanInlineCodeForBuiltins(exprCode, used);
+	}
+	for (const edge of graph.edges) for (const action of edge.data.actions ?? []) {
+		const imp = BUILTIN_ACTION_IMPORTS[action.type];
+		if (imp) used.add(imp);
+		const exprCode = getExprActionCode(action);
+		if (exprCode) scanInlineCodeForBuiltins(exprCode, used);
+	}
+	return used;
 }
-function objectLiteralToValue(node, bindings, context, depth, overrides = /* @__PURE__ */ new Map()) {
+function toV5MachineConfig(machineConfig) {
+	return mapMachineActionFields(machineConfig, (actions, wasArray) => {
+		const mapped = actions.map(unwrapDirectEnqExpression);
+		return wasArray ? mapped : mapped[0];
+	});
+}
+function toV6MachineConfig(machineConfig) {
+	return mapV6MachineConfig(machineConfig);
+}
+function mapV6MachineConfig(value, context = {}) {
+	if (Array.isArray(value)) return value.map((item) => mapV6MachineConfig(item, context));
+	if (!value || typeof value !== "object") return value;
+	if (context.transitionValue) return toV6TransitionValue(value);
 	const result = {};
-	for (const property of node.properties) {
-		if (ts.isSpreadAssignment(property)) {
-			const spread = expressionToValue(property.expression, bindings, context, depth + 1);
-			if (spread && typeof spread === "object" && !Array.isArray(spread)) Object.assign(result, spread);
+	for (const [key, item] of Object.entries(value)) {
+		if (key === "entry" || key === "exit" || key === "actions") {
+			result[key] = toV6ActionField(Array.isArray(item) ? item : item === void 0 ? [] : [item]);
 			continue;
 		}
-		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) continue;
-		const key = propName(property.name);
-		if (!key) continue;
-		if (overrides.has(key)) {
-			result[key] = overrides.get(key);
+		if (key === "on" || key === "after") {
+			result[key] = mapV6TransitionMap(item);
 			continue;
 		}
-		if (ts.isShorthandPropertyAssignment(property)) {
-			result[key] = expressionToValue(property.name, bindings, propertyContext(context, key), depth + 1);
+		if (key === "always" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout") {
+			result[key] = mapV6MachineConfig(item, { transitionValue: true });
 			continue;
 		}
-		result[key] = expressionToValue(property.initializer, bindings, propertyContext(context, key), depth + 1);
-	}
-	if (context.transitionValue && "to" in result) {
-		const to = result.to;
-		const { to: _to, ...rest } = result;
-		if (typeof to === "string") return {
-			...rest,
-			target: to
-		};
-		if (Array.isArray(to)) return to.map((item) => typeof item === "string" ? {
-			...rest,
-			target: item
-		} : item && typeof item === "object" ? {
-			...rest,
-			...item
-		} : rest);
-		if (to && typeof to === "object" && !Array.isArray(to)) return {
-			...rest,
-			...to
-		};
+		result[key] = mapV6MachineConfig(item);
 	}
 	return result;
 }
-function expressionToValue(expression, bindings, context = {}, depth = 0) {
-	if (depth > 30) return void 0;
-	const node = unwrapExpression(expression);
-	if (context.actorSourceValue) {
-		if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
-		if (ts.isIdentifier(node)) {
-			const binding = bindings.get(node.text);
-			if (binding && !ts.isFunctionDeclaration(binding)) return inlineCodeExpression(unwrapExpression(binding).getText());
-		}
-		return inlineCodeExpression(node.getText());
+function mapV6TransitionMap(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	const result = {};
+	for (const [key, item] of Object.entries(value)) result[key] = mapV6MachineConfig(item, { transitionValue: true });
+	return result;
+}
+function toV6TransitionValue(value) {
+	if (Array.isArray(value)) return value.map((item) => toV6TransitionValue(item));
+	if (!value || typeof value !== "object") return value;
+	const transition = value;
+	if (transition.guard || transition.description || transition.input !== void 0) return mapV6MachineConfig(transition);
+	const target = transition.target;
+	const context = transition.context;
+	const actionsValue = transition.actions;
+	const actions = Array.isArray(actionsValue) ? actionsValue : actionsValue === void 0 ? [] : [actionsValue];
+	if (actions.length === 0 && typeof target === "string" && context === void 0 && !transition.reenter && !transition.meta) return target;
+	if (actions.length === 0 && target === void 0 && context === void 0) return mapV6MachineConfig(transition);
+	return buildV6ActionFunction(actions, {
+		target: typeof target === "string" ? target : void 0,
+		reenter: transition.reenter === true,
+		meta: transition.meta,
+		context
+	}) ?? mapV6MachineConfig(transition);
+}
+function toV6ActionField(actions) {
+	if (actions.length === 1) {
+		const expr = inlineExpr(actions[0]);
+		if (expr && isCompleteFunctionExpression(stripExportDefault(expr))) return raw(stripExportDefault(expr));
 	}
-	if (context.routeValue && !ts.isObjectLiteralExpression(node)) {
-		if (ts.isIdentifier(node)) {
-			const binding = bindings.get(node.text);
-			if (binding && !ts.isFunctionDeclaration(binding)) return expressionToValue(binding, bindings, context, depth + 1);
-		}
-		return inlineCodeExpression(node.getText());
+	return buildV6ActionFunction(actions) ?? actions;
+}
+function buildV6ActionFunction(actions, transition) {
+	const effects = actions.map(actionToV6Effect);
+	if (effects.some((effect) => !effect)) return void 0;
+	const statements = effects.flatMap((effect) => effect?.statements ?? []);
+	let returnValue;
+	let contextValue;
+	for (const effect of effects) {
+		returnValue = effect?.returnValue ?? returnValue;
+		contextValue = effect?.contextValue ?? contextValue;
 	}
-	if (context.timeoutValue && (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isCallExpression(node))) return inlineCodeExpression(node.getText());
-	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.ioPropertyValue) {
-		if (ts.isIdentifier(node) && node.text === "undefined") return void 0;
-		if (ts.isIdentifier(node)) {
-			const binding = bindings.get(node.text);
-			if (binding && !ts.isFunctionDeclaration(binding)) return expressionToValue(binding, bindings, context, depth + 1);
-		}
-		if (!ts.isObjectLiteralExpression(node) && !ts.isArrayLiteralExpression(node)) return inlineCodeExpression(node.getText());
+	if (transition) returnValue = buildV6TransitionReturnValue(transition, transition.context === void 0 ? contextValue : serializeJS(unwrapTemplateExpressions(transition.context)));
+	if (statements.length === 0 && !returnValue) return void 0;
+	return raw(`(_, enq) => {\n${[...statements.map((statement) => `  ${statement};`), ...returnValue ? [`  return ${returnValue};`] : []].join("\n")}\n}`);
+}
+function unwrapTemplateExpressions(value) {
+	if (typeof value === "string") {
+		const match = value.match(/^\{\{\s*([\s\S]*?)\s*\}\}$/);
+		return match?.[1] ? raw(match[1]) : value;
 	}
-	if (context.assignmentValue) {
-		if (ts.isIdentifier(node) && node.text === "undefined") return void 0;
-		if (ts.isIdentifier(node)) {
-			const binding = bindings.get(node.text);
-			if (binding && !ts.isFunctionDeclaration(binding)) return expressionToValue(binding, bindings, context, depth + 1);
+	if (Array.isArray(value)) return value.map(unwrapTemplateExpressions);
+	if (!value || typeof value !== "object") return value;
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, unwrapTemplateExpressions(item)]));
+}
+function buildV6TransitionReturnValue(transition, contextValue) {
+	if (!transition.reenter && !transition.meta && !contextValue) return transition.target ? `{ target: ${serializeJS(transition.target)} }` : void 0;
+	return serializeJS({
+		target: transition.target,
+		reenter: transition.reenter ? true : void 0,
+		meta: transition.meta,
+		context: contextValue ? raw(contextValue) : void 0
+	});
+}
+function mapMachineActionFields(value, mapActions) {
+	if (Array.isArray(value)) return value.map((item) => mapMachineActionFields(item, mapActions));
+	if (!value || typeof value !== "object") return value;
+	const result = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (key === "entry" || key === "exit" || key === "actions") {
+			const wasArray = Array.isArray(item);
+			result[key] = mapActions(wasArray ? item : item === void 0 ? [] : [item], wasArray);
+			continue;
 		}
-		return wrapAssignExpression(node.getText());
+		result[key] = mapMachineActionFields(item, mapActions);
 	}
-	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);
-		if (binding) {
-			if (ts.isFunctionDeclaration(binding)) {
-				if (context.metaValue) return inlineCodeExpression(binding.name?.text ?? node.getText());
-				if (context.v6 && context.transitionValue) return normalizeFunctionTransition(binding, bindings, depth + 1);
-				if (context.v6 && context.actionValue) return normalizeFunctionAction(binding, bindings);
-				return binding.name?.text ?? node.text;
-			}
-			return expressionToValue(binding, bindings, context, depth + 1);
+	return result;
+}
+function unwrapDirectEnqExpression(action) {
+	const expr = inlineExpr(action);
+	if (!expr) return action;
+	const match = expr.match(/^enq\(([\s\S]*)\)$/);
+	return match?.[1] ? raw(match[1]) : action;
+}
+function inlineExpr(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const directive = value;
+	return directive["@type"] === "code" && typeof directive.expr === "string" ? directive.expr : void 0;
+}
+function actionToV6Effect(action) {
+	const expr = inlineExpr(action);
+	if (expr) {
+		if (expr.startsWith("enq(") || expr.startsWith("enq.")) return { statements: [expr] };
+		const builtIn = expr.match(/^(raise|emit|sendTo|cancel|log|spawnChild|stopChild)\(([\s\S]*)\)$/);
+		if (builtIn) {
+			const [, name, args] = builtIn;
+			return { statements: [`enq.${name === "spawnChild" ? "spawn" : name === "stopChild" ? "stop" : name}(${args})`] };
 		}
-		return context.metaValue ? inlineCodeExpression(node.getText()) : node.text;
+		return { statements: [`enq(${expr})`] };
 	}
-	if (ts.isObjectLiteralExpression(node)) return objectLiteralToValue(node, bindings, context, depth);
-	if (ts.isArrayLiteralExpression(node)) {
-		const values = node.elements.map((element) => expressionToValue(element, bindings, context, depth + 1));
-		return context.actionValue ? values.flat() : values;
+	if (!action || typeof action !== "object" || Array.isArray(action)) return null;
+	const record = action;
+	const type = record.type;
+	if (typeof type !== "string") return null;
+	const params = record.params && typeof record.params === "object" && !Array.isArray(record.params) ? record.params : {};
+	if (type === "xstate.raise") {
+		const options = actionOptions(params, ["event"]);
+		return { statements: [`enq.raise(${serializeJS(params.event)}${options})`] };
+	}
+	if (type === "xstate.emit") return { statements: [`enq.emit(${serializeJS(params.event)})`] };
+	if (type === "xstate.sendTo") {
+		const options = actionOptions(params, ["to", "event"]);
+		return { statements: [`enq.sendTo(${serializeJS(params.to)}, ${serializeJS(params.event)}${options})`] };
+	}
+	if (type === "xstate.cancel") return { statements: [`enq.cancel(${serializeJS(params.sendId)})`] };
+	if (type === "xstate.log") return { statements: [`enq.log(${serializeJS(params.label)})`] };
+	if (type === "xstate.spawnChild") {
+		const options = actionOptions(params, ["src"]);
+		return { statements: [`enq.spawn(${serializeJS(params.src)}${options})`] };
+	}
+	if (type === "xstate.stopChild") return { statements: [`enq.stop(${serializeJS(params.actorRef)})`] };
+	if (type === "xstate.assign") {
+		const contextValue = serializeJS(params.assignment ?? params);
+		return {
+			contextValue,
+			returnValue: `{ context: ${contextValue} }`
+		};
+	}
+	return null;
+}
+function actionOptions(params, consumedKeys) {
+	const rest = Object.fromEntries(Object.entries(params).filter(([key, value]) => !consumedKeys.includes(key) && value !== void 0));
+	return Object.keys(rest).length ? `, ${serializeJS(rest)}` : "";
+}
+function buildImports({ hasSetup, hasActors, actors, builtInActions, actorSourceImports, usesTypes }) {
+	const xstateImports = [];
+	if (hasSetup) xstateImports.push("setup");
+	else xstateImports.push("createMachine");
+	for (const name of builtInActions) xstateImports.push(name);
+	for (const name of actorSourceImports) xstateImports.push(name);
+	if (usesTypes) xstateImports.push("types");
+	if (hasActors) {
+		if (actors.length > 0) xstateImports.push("fromPromise");
 	}
-	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();
+	return `import { ${[...new Set(xstateImports)].join(", ")} } from 'xstate';`;
+}
+function getActorSourceImports(graph) {
+	const imports = /* @__PURE__ */ new Set();
+	const candidates = [
+		"createAsyncLogic",
+		"fromPromise",
+		"fromCallback",
+		"fromObservable",
+		"fromEventObservable",
+		"fromTransition"
+	];
+	for (const node of graph.nodes) for (const invoke of node.data.invokes ?? []) {
+		const expression = invoke.srcExpression?.expr;
+		if (!expression) continue;
+		for (const candidate of candidates) if (new RegExp(`\\b${candidate}\\b`).test(expression)) imports.add(candidate);
 	}
-	if (ts.isCallExpression(node)) {
-		if (context.metaValue) return inlineCodeExpression(node.getText());
-		if (ts.isIdentifier(node.expression)) {
-			const binding = bindings.get(node.expression.text);
-			if (binding && isFunctionBinding(binding)) return evaluateFunctionCall(binding, node.arguments, bindings, context, depth + 1);
-		}
-		if (ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "createStateConfig") {
-			const configArg = node.arguments.length > 1 ? node.arguments[1] : node.arguments[0];
-			return configArg ? expressionToValue(configArg, bindings, { v6: context.v6 }, depth + 1) : {};
-		}
-		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 imports;
+}
+function buildSetupObject(schemas, impls, options) {
+	const setup = {};
+	if (options.xstateVersion === 6) {
+		const schemasBlock = buildV6SchemasBlock(schemas, options);
+		if (schemasBlock) setup.schemas = schemasBlock;
+	} else {
+		const types = buildTypesBlock(schemas, options);
+		if (types) setup.types = types;
 	}
-	return context.metaValue ? inlineCodeExpression(node.getText()) : node.getText();
+	if (impls?.actions.length) setup.actions = buildActionsBlock(impls.actions, options);
+	if (impls?.guards.length) setup.guards = buildGuardsBlock(impls.guards, options);
+	if (impls?.actors.length) setup.actors = buildActorsBlock(impls.actors, options);
+	if (impls?.delays.length) setup.delays = buildDelaysBlock(impls.delays);
+	return setup;
 }
-function isFunctionBinding(binding) {
-	return ts.isArrowFunction(binding) || ts.isFunctionExpression(binding) || ts.isFunctionDeclaration(binding);
+function buildTypesBlock(schemas, options) {
+	if (!schemas || !options.includeTypeSyntax) return void 0;
+	const types = {};
+	const contextType = contextSchemaToTSType(schemas.context);
+	if (contextType) types.context = raw(`{} as ${contextType}`);
+	const eventsType = eventsSchemaToTSType(schemas.events);
+	if (eventsType) types.events = raw(`{} as\n    | ${eventsType}`);
+	if (schemas.input) types.input = raw(`{} as ${jsonSchemaToTSType(schemas.input)}`);
+	if (schemas.output) types.output = raw(`{} as ${jsonSchemaToTSType(schemas.output)}`);
+	return Object.keys(types).length > 0 ? types : void 0;
 }
-function evaluateFunctionCall(fn, args, bindings, context, depth) {
-	const scopedBindings = new Map(bindings);
-	for (const [index, parameter] of fn.parameters.entries()) {
-		if (!ts.isIdentifier(parameter.name)) continue;
-		const argument = args[index];
-		if (argument) scopedBindings.set(parameter.name.text, argument);
-		else if (parameter.initializer) scopedBindings.set(parameter.name.text, parameter.initializer);
+function buildV6SchemasBlock(schemas, options) {
+	if (!schemas || !options.includeTypeSyntax) return void 0;
+	const result = {};
+	const contextType = contextSchemaToTSType(schemas.context);
+	if (contextType) result.context = raw(`types<${contextType}>()`);
+	if (schemas.events && Object.keys(schemas.events).length > 0) result.events = Object.fromEntries(Object.entries(schemas.events).map(([eventType, schema]) => [eventType, raw(`types<${eventPayloadSchemaToTSType(schema)}>()`)]));
+	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 > 0 ? result : void 0;
+}
+function eventPayloadSchemaToTSType(schema) {
+	const props = schema.properties ?? {};
+	const payloadProps = Object.fromEntries(Object.entries(props).filter(([key]) => key !== "type"));
+	if (Object.keys(payloadProps).length === 0) return "{}";
+	return jsonSchemaToTSType({
+		...schema,
+		properties: payloadProps,
+		required: Array.isArray(schema.required) ? schema.required.filter((key) => key !== "type") : void 0
+	});
+}
+function hasSchemaProperties(schema) {
+	if (!schema) return false;
+	if (schema.type === "object" || schema.properties) {
+		const props = schema.properties;
+		return !!props && Object.keys(props).length > 0;
 	}
-	if (ts.isArrowFunction(fn) && !ts.isBlock(fn.body)) return expressionToValue(fn.body, scopedBindings, context, depth + 1);
-	if (context.v6 && context.transitionValue) return normalizeFunctionTransition(fn, scopedBindings, depth + 1);
-	if (context.v6 && context.actionValue) return normalizeFunctionAction(fn, scopedBindings);
-	return context.metaValue ? inlineCodeExpression(fn.getText()) : fn.name?.getText() ?? fn.getText();
+	return true;
 }
-function collectBindings(file) {
-	const bindings = /* @__PURE__ */ new Map();
-	for (const statement of file.statements) {
-		if (ts.isVariableStatement(statement)) {
-			for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) bindings.set(declaration.name.text, declaration.initializer);
+function buildActionsBlock(actions, options) {
+	const block = {};
+	for (const implementation of actions) if (implementation.code?.body) {
+		const inlineExpression = getInlineExpression(implementation.code.body);
+		if (inlineExpression) {
+			block[implementation.name] = raw(inlineExpression);
 			continue;
 		}
-		if (ts.isFunctionDeclaration(statement) && statement.name) bindings.set(statement.name.text, statement);
-	}
-	return bindings;
-}
-function isCreateMachineCall(node) {
-	const expression = node.expression;
-	if (ts.isIdentifier(expression)) return expression.text === "createMachine";
-	if (ts.isPropertyAccessExpression(expression)) return expression.name.text === "createMachine";
-	return false;
+		const params = hasSchemaProperties(implementation.paramsSchema) ? options.includeTypeSyntax ? `, params: ${jsonSchemaToTSType(implementation.paramsSchema)}` : ", params" : "";
+		block[implementation.name] = raw(`function ({ context, event }${params ? params : ""}) {\n  ${dedent(implementation.code.body)}\n}`);
+	} else block[implementation.name] = raw(`function ({ context, event }) {\n  // TODO: implement ${implementation.name}\n}`);
+	return block;
 }
-function hasV6Syntax(source) {
-	const file = sourceFile(source);
-	const bindings = collectBindings(file);
-	let found = false;
-	function containsFunction(expression, seenBindings = /* @__PURE__ */ new Set()) {
-		if (ts.isFunctionDeclaration(expression)) return true;
-		const node = unwrapExpression(expression);
-		if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) return true;
-		if (ts.isIdentifier(node)) {
-			if (seenBindings.has(node.text)) return false;
-			const binding = bindings.get(node.text);
-			if (!binding) return false;
-			return containsFunction(binding, new Set([...seenBindings, node.text]));
-		}
-		if (ts.isObjectLiteralExpression(node)) return node.properties.some((property) => {
-			if (ts.isPropertyAssignment(property)) return containsFunction(property.initializer, seenBindings);
-			if (ts.isShorthandPropertyAssignment(property)) return containsFunction(property.name, seenBindings);
-			if (ts.isSpreadAssignment(property)) return containsFunction(property.expression, seenBindings);
-			return false;
-		});
-		if (ts.isArrayLiteralExpression(node)) return node.elements.some((element) => ts.isExpression(element) && containsFunction(element, seenBindings));
-		if (ts.isCallExpression(node)) return ts.isIdentifier(node.expression) && containsFunction(node.expression, seenBindings) || node.arguments.some((argument) => ts.isExpression(argument) && containsFunction(argument, seenBindings));
-		return false;
-	}
-	function visit(node) {
-		if (found) return;
-		if (ts.isPropertyAssignment(node) && (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name))) {
-			const key = node.name.text;
-			if (key === "triggers" || key === "internalEvents" || key === "matches" || key === "actorSources" || key === "timeout" || key === "onTimeout" || key === "choice" || key === "route") {
-				found = true;
-				return;
-			}
-			if ((key === "on" || key === "after" || key === "always" || key === "choice" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout" || key === "entry" || key === "exit" || key === "actions" && !ts.isObjectLiteralExpression(node.initializer)) && containsFunction(node.initializer)) {
-				found = true;
-				return;
-			}
+function buildGuardsBlock(guards, options) {
+	const block = {};
+	for (const guard of guards) if (guard.code?.body) {
+		const inlineExpression = getInlineExpression(guard.code.body);
+		if (inlineExpression) {
+			block[guard.name] = raw(inlineExpression);
+			continue;
 		}
-		ts.forEachChild(node, visit);
-	}
-	visit(file);
-	return found;
+		const params = hasSchemaProperties(guard.paramsSchema) ? options.includeTypeSyntax ? `, params: ${jsonSchemaToTSType(guard.paramsSchema)}` : ", params" : "";
+		block[guard.name] = raw(`function ({ context, event }${params ? params : ""}) {\n  ${dedent(guard.code.body)}\n}`);
+	} else block[guard.name] = raw(`function ({ context, event }) {\n  // TODO: implement ${guard.name}\n  return false;\n}`);
+	return block;
 }
-function detectXStateSourceProfile(source) {
-	return hasV6Syntax(source) ? "xstate-v6-alpha" : "xstate-v5";
+function buildActorsBlock(actors, options) {
+	const block = {};
+	for (const actor of actors) if (actor.code?.body) {
+		const inputType = options.includeTypeSyntax && hasSchemaProperties(actor.inputSchema) ? `: ${jsonSchemaToTSType(actor.inputSchema)}` : "";
+		block[actor.name] = raw(`fromPromise(async ({ input }${inputType ? `: { input${inputType} }` : ""}) => {\n  ${dedent(actor.code.body)}\n})`);
+	} else block[actor.name] = raw(`fromPromise(async ({ input }) => {\n  // TODO: implement ${actor.name}\n})`);
+	return block;
 }
-function xstateSourceToConfig(source, options = {}) {
-	const [config] = extractXStateMachineConfigs(source, options);
-	if (!config) throw new Error("No createMachine(...) or setup(...).createMachine(...) call found.");
-	return config;
+function buildDelaysBlock(delays) {
+	const block = {};
+	for (const delay of delays) if (delay.code?.body) {
+		const inlineExpression = getInlineExpression(delay.code.body);
+		if (inlineExpression) {
+			block[delay.name] = raw(inlineExpression);
+			continue;
+		}
+		block[delay.name] = raw(`function ({ context, event }) {\n  ${dedent(delay.code.body)}\n}`);
+	} else block[delay.name] = raw(`function () {\n  // TODO: implement ${delay.name}\n  return 1000;\n}`);
+	return block;
 }
 /**
-* Extract every XState machine config from source without executing code.
-* XState 5/6 syntax is inferred structurally unless a profile is supplied.
+* Returns the implementation to emit verbatim when `body` is already a complete
+* expression, so it is NOT wrapped in another `function ({ context, event }) { ... }`.
+* Handles two cases:
+*  - `export default <expr>` → the inner expression.
+*  - a bare function/arrow expression (e.g. a guard captured via `fn.toString()`
+*    on import) → the expression itself.
+* Returns undefined for a plain statement body, which still needs wrapping.
 */
-function extractXStateMachineConfigs(source, options = {}) {
-	const file = sourceFile(source);
-	const bindings = collectBindings(file);
-	const found = [];
-	const profile = options.profile === "auto" || !options.profile ? detectXStateSourceProfile(source) : options.profile;
-	function visit(node) {
-		if (!ts.isCallExpression(node) || !isCreateMachineCall(node)) {
-			ts.forEachChild(node, visit);
-			return;
-		}
-		const arg = node.arguments[0];
-		if (!arg) return;
-		const value = expressionToValue(arg, bindings, { v6: profile === "xstate-v6-alpha" });
-		if (value && typeof value === "object" && !Array.isArray(value)) found.push(value);
-	}
-	visit(file);
-	return found;
+function getInlineExpression(code) {
+	const stripped = stripExportDefault(code);
+	if (stripped !== code.trim()) return stripped;
+	return isCompleteFunctionExpression(stripped) ? stripped : void 0;
+}
+/** True when `code` is a single function or arrow-function expression. */
+function isCompleteFunctionExpression(code) {
+	const candidate = code.trim().replace(/;$/, "");
+	const source = ts.createSourceFile("impl.ts", `(${candidate})`, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+	if ((source.parseDiagnostics ?? []).length > 0 || source.statements.length !== 1) return false;
+	const [statement] = source.statements;
+	if (!statement || !ts.isExpressionStatement(statement)) return false;
+	let expression = statement.expression;
+	if (ts.isParenthesizedExpression(expression)) expression = expression.expression;
+	return ts.isFunctionExpression(expression) || ts.isArrowFunction(expression);
 }
 const colorSchema = _enum([
 	"green",
@@ -4553,7 +4425,12 @@ const machineFormatSchema = _enum([
 	"scxml",
 	"mermaid"
 ]);
-const xstateSourceProfileSchema = _enum(["auto", ...MACHINE_PROFILES]);
+const canonicalMachineProfileSchema = custom((value) => typeof value === "string" && /^@statelyai\/xstate@\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value), "Expected an exact @statelyai/xstate profile reference.");
+const xstateSourceProfileSchema = union([
+	literal("auto"),
+	_enum(LEGACY_MACHINE_PROFILES),
+	canonicalMachineProfileSchema
+]);
 const machineInputSchema = object({
 	machine: union([record(string(), unknown()), string()]),
 	format: machineFormatSchema.optional(),
@@ -5078,4 +4955,4 @@ function getScriptKind(fileName) {
 }
 
 //#endregion
-export { RawCode as a, eventsSchemaToTSType as c, jsonSchemaToTSType as d, raw as f, INLINE_EXPRESSION_DIRECTIVE_FIELDS as i, graphToMachineConfig as l, xstateSourceToConfig as m, getStatelyPragma as n, contextSchemaToTSType as o, serializeJS as p, upsertStatelyPragma as r, detectXStateSourceProfile as s, findStatelyPragmaAttachments as t, graphToXStateTS as u };
+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 };