@statelyai/sdk 0.20.1 → 0.20.3

package/dist/{statelyPragma-CIzsR_Sx.mjs → statelyPragma-Cesya0Pk.mjs}

@@ -1,5 +1,6 @@
 import { a as discriminatedUnion, c as object, d as union, f as unknown, i as custom, l as record, n as array, o as literal, r as boolean, s as number, t as _enum, u as string } from "./schemas-b9wG-zYl.mjs";
 import ts from "typescript";
+import "xstate";
 import "xstate/graph";
 
 //#region ../../node_modules/.pnpm/js-yaml@4.2.0/node_modules/js-yaml/dist/js-yaml.mjs
@@ -2333,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",
@@ -2517,6 +2349,8 @@ const LAYOUT_KEYS = {
 		"y",
 		"width",
 		"height",
+		"points",
+		"routing",
 		"style",
 		"color"
 	]
@@ -2802,7 +2636,8 @@ function formatEventParam(event) {
 	return "undefined";
 }
 function formatStringParam(value) {
-	return typeof value === "string" ? `'${value}'` : "undefined";
+	if (typeof value === "string") return `'${value}'`;
+	return isCodeExpression$1(value) ? serializeJS(value) : "undefined";
 }
 function formatInlineObject(value) {
 	return `{ ${Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => `${formatObjectKey(key)}: ${serializeJS(item)}`).join(", ")} }`;
@@ -3165,7 +3000,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;
@@ -3179,6 +3014,123 @@ const INLINE_EXPRESSION_DIRECTIVE_FIELDS = [
 	"initialInput",
 	"route"
 ];
+const EXACT_SEMVER$1 = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function parseProfileSpecifier(specifier) {
+	const separator = specifier.lastIndexOf("@");
+	const name = specifier.slice(0, separator);
+	const version = specifier.slice(separator + 1);
+	if (separator <= 0 || !/^@[^/]+\/[^@/]+$/.test(name) || !version) throw new Error(`Invalid profile specifier: ${specifier}`);
+	return {
+		name,
+		version,
+		kind: EXACT_SEMVER$1.test(version) ? "exact" : "range"
+	};
+}
+function normalizeProfileRef(profile) {
+	return profile === "xstate-v5" || profile === "xstate-v6-alpha" ? normalizeMachineProfile(profile) : profile;
+}
+/** Stately's semantic projection of the LangGraph 1.x APIs across runtimes. */
+const LANGGRAPH_PROFILE = "@statelyai/langgraph@1.0.0";
+const LANGGRAPH_PROFILE_MANIFEST = {
+	profile: LANGGRAPH_PROFILE,
+	name: "LangGraph",
+	description: "LangGraph 1.x graph semantics for Python and JavaScript/TypeScript source.",
+	restrictFormatsToListed: true,
+	authoring: {
+		terminology: {
+			node: "node",
+			edge: "edge",
+			graph: "graph"
+		},
+		nodeTypes: [
+			{
+				kind: "node",
+				label: "Node",
+				description: "Graph API node",
+				authorable: true
+			},
+			{
+				kind: "task",
+				label: "Task",
+				description: "Functional API task",
+				authorable: true
+			},
+			{
+				kind: "entrypoint",
+				label: "Entrypoint",
+				description: "Functional API entrypoint",
+				authorable: true
+			},
+			{
+				kind: "agent",
+				label: "Agent",
+				description: "Prebuilt agent",
+				authorable: true
+			},
+			{
+				kind: "end",
+				label: "END",
+				description: "Terminal sentinel",
+				authorable: true,
+				terminal: true
+			}
+		],
+		edgeTypes: [
+			{
+				kind: "edge",
+				label: "Edge",
+				description: "Direct route",
+				authorable: true
+			},
+			{
+				kind: "conditional",
+				label: "Conditional edge",
+				description: "Runtime-routed branch",
+				authorable: true
+			},
+			{
+				kind: "call",
+				label: "Call",
+				description: "Functional API call",
+				authorable: true
+			}
+		],
+		attachments: {},
+		supportsInitialNode: false,
+		supportsTargetlessEdges: false,
+		supportsReenterEdges: false
+	},
+	operations: {
+		simulate: false,
+		validate: false,
+		export: false
+	},
+	formats: [
+		{
+			format: "python",
+			import: true,
+			export: false,
+			sourcePreserving: true
+		},
+		{
+			format: "typescript",
+			import: true,
+			export: false,
+			sourcePreserving: true
+		},
+		{
+			format: "javascript",
+			import: true,
+			export: false,
+			sourcePreserving: true
+		}
+	],
+	features: {
+		graphApi: true,
+		functionalApi: true,
+		prebuiltAgents: true
+	}
+};
 const XSTATE_FORMATS = [
 	{
 		format: "typescript",
@@ -3203,16 +3155,99 @@ const XSTATE_FORMATS = [
 		export: true
 	}
 ];
+const XSTATE_AUTHORING = {
+	terminology: {
+		node: "state",
+		edge: "transition",
+		graph: "machine"
+	},
+	nodeTypes: [
+		{
+			kind: "normal",
+			label: "Normal",
+			description: "Basic state",
+			authorable: true,
+			canContain: true
+		},
+		{
+			kind: "parallel",
+			label: "Parallel",
+			description: "Concurrent child states",
+			authorable: true,
+			canContain: true
+		},
+		{
+			kind: "final",
+			label: "Final",
+			description: "Terminal state",
+			authorable: true,
+			terminal: true
+		},
+		{
+			kind: "history",
+			label: "History",
+			description: "Restores previous state",
+			authorable: true
+		},
+		{
+			kind: "choice",
+			label: "Choice",
+			description: "Guarded eventless routing",
+			authorable: true
+		}
+	],
+	edgeTypes: [{
+		kind: "transition",
+		label: "Transition",
+		authorable: true
+	}],
+	attachments: {
+		actions: true,
+		guards: true,
+		invokes: true,
+		tags: true
+	},
+	supportsInitialNode: true,
+	supportsTargetlessEdges: true,
+	supportsReenterEdges: true
+};
 const XSTATE_PROFILE_MANIFESTS = [{
 	profile: XSTATE_V5_PROFILE,
 	name: "XState v5",
-	formats: [...XSTATE_FORMATS]
+	formats: [...XSTATE_FORMATS],
+	authoring: XSTATE_AUTHORING,
+	operations: {
+		simulate: true,
+		validate: true,
+		export: true
+	}
 }, {
 	profile: XSTATE_V6_PROFILE,
 	name: "XState v6",
-	formats: [...XSTATE_FORMATS]
+	formats: [...XSTATE_FORMATS],
+	authoring: XSTATE_AUTHORING,
+	operations: {
+		simulate: true,
+		validate: true,
+		export: true
+	}
 }];
-const PROFILE_MANIFESTS = new Map(XSTATE_PROFILE_MANIFESTS.map((manifest) => [manifest.profile, manifest]));
+const PROFILE_MANIFESTS = new Map([...XSTATE_PROFILE_MANIFESTS, LANGGRAPH_PROFILE_MANIFEST].map((manifest) => [manifest.profile, manifest]));
+function getProfileManifest(profile) {
+	return PROFILE_MANIFESTS.get(profile);
+}
+function isXStateV6ProfileRef(profile) {
+	let current = normalizeProfileRef(profile);
+	const seen = /* @__PURE__ */ new Set();
+	while (!seen.has(current)) {
+		if (isXStateV6Profile(current)) return true;
+		seen.add(current);
+		const parent = getProfileManifest(current)?.extends;
+		if (!parent || parseProfileSpecifier(parent).kind !== "exact") return false;
+		current = parent;
+	}
+	return false;
+}
 const XSTATE_V6_FN_TRANSITION_META = "@statelyai.xstate.v6.fnTransition";
 const XSTATE_V6_FN_SOURCE_META = "@statelyai.xstate.v6.fnSource";
 function sourceFile(source) {
@@ -3226,7 +3261,193 @@ function unwrapExpression(node) {
 	if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node) || ts.isParenthesizedExpression(node)) return unwrapExpression(node.expression);
 	return node;
 }
+function canReplaceIdentifier(node) {
+	const parent = node.parent;
+	if (ts.isPropertyAccessExpression(parent) && parent.name === node) return false;
+	if (ts.isPropertyAssignment(parent) && parent.name === node) return false;
+	if (ts.isMethodDeclaration(parent) && parent.name === node) return false;
+	return true;
+}
+function bindingNameContains(name, identifier) {
+	if (ts.isIdentifier(name)) return name.text === identifier;
+	return name.elements.some((element) => ts.isBindingElement(element) && bindingNameContains(element.name, identifier));
+}
+function scopeBindsName(node, identifier) {
+	if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.parameters.some((parameter) => bindingNameContains(parameter.name, identifier))) return true;
+	if (ts.isCatchClause(node) && node.variableDeclaration) return bindingNameContains(node.variableDeclaration.name, identifier);
+	if (ts.isBlock(node)) return node.statements.some((statement) => {
+		if (ts.isVariableStatement(statement)) return statement.declarationList.declarations.some((declaration) => bindingNameContains(declaration.name, identifier));
+		return ts.isFunctionDeclaration(statement) && statement.name?.text === identifier;
+	});
+	if ((ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) && node.initializer && ts.isVariableDeclarationList(node.initializer)) return node.initializer.declarations.some((declaration) => bindingNameContains(declaration.name, identifier));
+	return false;
+}
+function isShadowedWithinExpression(node, expression) {
+	let ancestor = node.parent;
+	while (ancestor && ancestor !== expression.parent) {
+		if (scopeBindsName(ancestor, node.text)) return true;
+		ancestor = ancestor.parent;
+	}
+	return false;
+}
+function replacementText(node, expression) {
+	if (ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node) return `${node.text}: (${expression})`;
+	return `(${expression})`;
+}
+function isSafeInlineExpression(expression) {
+	let safe = true;
+	function visit(node) {
+		if (ts.isCallExpression(node) || ts.isNewExpression(node) || ts.isAwaitExpression(node) || ts.isYieldExpression(node) || ts.isDeleteExpression(node) || ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node) && (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) || ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) {
+			safe = false;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(expression);
+	return safe;
+}
+function hasUnsafeVariableInitializer(node) {
+	let unsafe = false;
+	function visit(current) {
+		if (unsafe) return;
+		if (current !== node && (ts.isArrowFunction(current) || ts.isFunctionExpression(current) || ts.isFunctionDeclaration(current))) return;
+		if (ts.isVariableDeclaration(current) && current.initializer && !isSafeInlineExpression(current.initializer)) {
+			unsafe = true;
+			return;
+		}
+		ts.forEachChild(current, visit);
+	}
+	visit(node);
+	return unsafe;
+}
+function resolvedExpressionText(expression, bindings, resolving = /* @__PURE__ */ new Set()) {
+	const source = expression.getSourceFile();
+	const start = expression.getStart(source);
+	const replacements = [];
+	function visit(node) {
+		if (ts.isIdentifier(node) && canReplaceIdentifier(node) && !isShadowedWithinExpression(node, expression)) {
+			const binding = bindings.get(node.text);
+			if (binding && !ts.isFunctionDeclaration(binding) && isSafeInlineExpression(binding) && binding !== expression && !resolving.has(node.text)) {
+				const nextResolving = new Set(resolving).add(node.text);
+				replacements.push({
+					start: node.getStart(source) - start,
+					end: node.getEnd() - start,
+					text: replacementText(node, resolvedExpressionText(binding, bindings, nextResolving))
+				});
+				return;
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(expression);
+	let result = expression.getText(source);
+	for (const replacement of replacements.sort((a, b) => b.start - a.start)) result = result.slice(0, replacement.start) + replacement.text + result.slice(replacement.end);
+	return result;
+}
+function typeNodeToJsonSchema(node) {
+	if (ts.isParenthesizedTypeNode(node)) return typeNodeToJsonSchema(node.type);
+	if (ts.isLiteralTypeNode(node)) {
+		const literal = node.literal;
+		if (ts.isStringLiteral(literal) || ts.isNumericLiteral(literal)) return { const: ts.isNumericLiteral(literal) ? Number(literal.text) : literal.text };
+		if (literal.kind === ts.SyntaxKind.TrueKeyword) return { const: true };
+		if (literal.kind === ts.SyntaxKind.FalseKeyword) return { const: false };
+		return null;
+	}
+	if (ts.isUnionTypeNode(node)) {
+		const members = node.types.map(typeNodeToJsonSchema);
+		if (members.some((member) => !member)) return null;
+		const constants = members.map((member) => member?.const);
+		if (constants.every((value) => value !== void 0)) return { enum: constants };
+		return { anyOf: members };
+	}
+	if (ts.isArrayTypeNode(node)) {
+		const items = typeNodeToJsonSchema(node.elementType);
+		return items ? {
+			type: "array",
+			items
+		} : null;
+	}
+	if (ts.isTupleTypeNode(node)) {
+		const items = node.elements.map((element) => typeNodeToJsonSchema(element));
+		if (items.some((item) => !item)) return null;
+		return {
+			type: "array",
+			items,
+			minItems: items.length,
+			maxItems: items.length
+		};
+	}
+	if (ts.isTypeLiteralNode(node)) {
+		const properties = {};
+		const required = [];
+		for (const member of node.members) {
+			if (!ts.isPropertySignature(member) || !member.type || !member.name) return null;
+			const name = propName(member.name);
+			const schema = typeNodeToJsonSchema(member.type);
+			if (!name || !schema) return null;
+			properties[name] = schema;
+			if (!member.questionToken) required.push(name);
+		}
+		return {
+			type: "object",
+			properties,
+			...required.length ? { required } : void 0,
+			additionalProperties: false
+		};
+	}
+	switch (node.kind) {
+		case ts.SyntaxKind.StringKeyword: return { type: "string" };
+		case ts.SyntaxKind.NumberKeyword: return { type: "number" };
+		case ts.SyntaxKind.BooleanKeyword: return { type: "boolean" };
+		case ts.SyntaxKind.NullKeyword: return { type: "null" };
+		case ts.SyntaxKind.UnknownKeyword:
+		case ts.SyntaxKind.AnyKeyword: return {};
+		default: return null;
+	}
+}
+function typesCallSchema(node) {
+	const value = unwrapExpression(node);
+	if (!ts.isCallExpression(value) || value.expression.getText() !== "types" || value.typeArguments?.length !== 1) return null;
+	return typeNodeToJsonSchema(value.typeArguments[0]);
+}
+function schemasObjectToValue(node) {
+	const value = unwrapExpression(node);
+	if (!ts.isObjectLiteralExpression(value)) return null;
+	const result = {};
+	for (const property of value.properties) {
+		if (!ts.isPropertyAssignment(property)) continue;
+		const key = propName(property.name);
+		if (!key) continue;
+		if (key === "events" && ts.isObjectLiteralExpression(property.initializer)) {
+			const events = {};
+			for (const eventProperty of property.initializer.properties) {
+				if (!ts.isPropertyAssignment(eventProperty)) continue;
+				const eventType = propName(eventProperty.name);
+				const schema = typesCallSchema(eventProperty.initializer);
+				if (eventType && schema) events[eventType] = schema;
+			}
+			result.events = events;
+			continue;
+		}
+		const schema = typesCallSchema(property.initializer);
+		if (!schema) continue;
+		result[key] = key === "context" ? schema.properties ?? {} : schema;
+	}
+	return result;
+}
 function propertyContext(parent, key) {
+	if (parent.setupValue && (key === "actions" || key === "guards" || key === "actors" || key === "delays")) return {
+		v6: parent.v6,
+		implementationMap: true
+	};
+	if (parent.implementationMap) return {
+		v6: parent.v6,
+		implementationValue: true
+	};
+	if (parent.effectArgumentValue) return {
+		v6: parent.v6,
+		effectArgumentValue: true
+	};
 	if (parent.invokeValue && key === "src") return {
 		v6: parent.v6,
 		actorSourceValue: true
@@ -3244,6 +3465,14 @@ function propertyContext(parent, key) {
 		assignmentMap: true,
 		transitionContext: true
 	};
+	if (key === "context") return {
+		v6: parent.v6,
+		machineContextValue: true
+	};
+	if (parent.transitionValue && key === "target") return {
+		v6: parent.v6,
+		targetValue: true
+	};
 	if (parent.assignmentMap) return {
 		v6: parent.v6,
 		assignmentValue: true
@@ -3290,14 +3519,11 @@ function propertyContext(parent, key) {
 	};
 	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 fallbackFunctionTransition(fn) {
+	return { meta: {
+		[XSTATE_V6_FN_TRANSITION_META]: true,
+		[XSTATE_V6_FN_SOURCE_META]: fn.getText()
+	} };
 }
 function conditionText(cond) {
 	return cond.negated ? `!(${cond.text})` : cond.text;
@@ -3318,7 +3544,7 @@ function hashString(value) {
 	return (hash >>> 0).toString(36);
 }
 function inlineGuardCode(params, condition) {
-	return `${params} => ${condition}`;
+	return `${params} => ${condition.trimStart().startsWith("{") ? `(${condition})` : condition}`;
 }
 function guardFromConditions(conds, params) {
 	const simplified = simplifyConditions(conds);
@@ -3354,7 +3580,7 @@ function transitionFromValue(value, actions) {
 function expressionBranches(expression, bindings, depth) {
 	const node = unwrapExpression(expression);
 	if (ts.isConditionalExpression(node)) {
-		const cond = node.condition.getText();
+		const cond = resolvedExpressionText(node.condition, bindings);
 		return [...expressionBranches(node.whenTrue, bindings, depth + 1).map((branch) => ({
 			...branch,
 			conds: [{ text: cond }, ...branch.conds]
@@ -3367,7 +3593,7 @@ function expressionBranches(expression, bindings, depth) {
 		}))];
 	}
 	if (ts.isBinaryExpression(node) && (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === ts.SyntaxKind.BarBarToken)) {
-		const cond = node.left.getText();
+		const cond = resolvedExpressionText(node.left, bindings);
 		if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) return [...expressionBranches(node.right, bindings, depth + 1).map((branch) => ({
 			...branch,
 			conds: [{ text: cond }, ...branch.conds]
@@ -3425,7 +3651,7 @@ function expressionStatementAction(statement, enqName, bindings) {
 	if (ts.isIdentifier(callee) && callee.text === enqName) return {
 		type: "xstate.expr",
 		params: {
-			code: expression.getText(),
+			code: resolvedExpressionText(expression, bindings),
 			lang: "ts"
 		}
 	};
@@ -3435,7 +3661,7 @@ function expressionStatementAction(statement, enqName, bindings) {
 	const args = expression.arguments;
 	const value = (index) => {
 		const arg = args[index];
-		return arg && ts.isExpression(arg) ? expressionToValue(arg, bindings, {}, 0) : void 0;
+		return arg && ts.isExpression(arg) ? expressionToValue(arg, bindings, { effectArgumentValue: true }, 0) : void 0;
 	};
 	const spreadOpts = (index) => {
 		const opts = value(index);
@@ -3524,7 +3750,7 @@ function statementBranches(statements, bindings, enqName, prefixes = [{
 				}
 			}
 			if (ts.isIfStatement(statement)) {
-				const cond = statement.expression.getText();
+				const cond = resolvedExpressionText(statement.expression, scopedBindings);
 				const thenBranches = statementBranches(ts.isBlock(statement.thenStatement) ? statement.thenStatement.statements : [statement.thenStatement], scopedBindings, enqName, [{
 					...prefix,
 					conds: [...prefix.conds, { text: cond }]
@@ -3548,7 +3774,14 @@ function statementBranches(statements, bindings, enqName, prefixes = [{
 				continue;
 			}
 			if (ts.isSwitchStatement(statement)) {
-				const expr = statement.expression.getText();
+				if (statement.caseBlock.clauses.some((clause) => clause.statements.length === 0)) {
+					nextOpen.push({
+						...prefix,
+						unknown: true
+					});
+					continue;
+				}
+				const expr = resolvedExpressionText(statement.expression, scopedBindings);
 				const prior = [];
 				for (const clause of statement.caseBlock.clauses) {
 					const ownCond = ts.isCaseClause(clause) ? { text: `${expr} === ${clause.expression.getText()}` } : null;
@@ -3585,9 +3818,11 @@ function guardParams(fn) {
 	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 (fn.body && ts.isBlock(fn.body) && hasUnsafeVariableInitializer(fn.body)) return fallbackFunctionTransition(fn);
+	const branches = 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)) : [];
+	if (branches.some((branch) => branch.unknown)) return fallbackFunctionTransition(fn);
+	const transitions = branches.map((branch) => {
+		const transition = transitionFromValue(branch.result, branch.actions);
 		if (!transition) return null;
 		if (typeof transition === "string") {
 			const guard = guardFromConditions(branch.conds, guardParams(fn));
@@ -3604,7 +3839,7 @@ function normalizeFunctionTransition(fn, bindings, depth) {
 	}).filter((transition) => Boolean(transition));
 	if (transitions.length === 1) return transitions[0];
 	if (transitions.length > 1) return transitions;
-	return fallbackFunctionTransition(fn, preservedActions);
+	return fallbackFunctionTransition(fn);
 }
 function inlineAction(fn) {
 	return {
@@ -3649,11 +3884,24 @@ function objectLiteralToValue(node, bindings, context, depth, overrides = /* @__
 			result[key] = overrides.get(key);
 			continue;
 		}
+		if (context.v6 && key === "schemas" && ts.isPropertyAssignment(property)) {
+			const schemas = schemasObjectToValue(property.initializer);
+			if (schemas) {
+				result[key] = schemas;
+				continue;
+			}
+		}
 		if (ts.isShorthandPropertyAssignment(property)) {
-			result[key] = expressionToValue(property.name, bindings, propertyContext(context, key), depth + 1);
+			const childContext = propertyContext(context, key);
+			const childValue = expressionToValue(property.name, bindings, childContext, depth + 1);
+			if (childContext.implementationValue && childValue === void 0) continue;
+			result[key] = childValue;
 			continue;
 		}
-		result[key] = expressionToValue(property.initializer, bindings, propertyContext(context, key), depth + 1);
+		const childContext = propertyContext(context, key);
+		const childValue = expressionToValue(property.initializer, bindings, childContext, depth + 1);
+		if (childContext.implementationValue && childValue === void 0) continue;
+		result[key] = childValue;
 	}
 	if (context.transitionValue && "to" in result) {
 		const to = result.to;
@@ -3679,6 +3927,23 @@ function objectLiteralToValue(node, bindings, context, depth, overrides = /* @__
 function expressionToValue(expression, bindings, context = {}, depth = 0) {
 	if (depth > 30) return void 0;
 	const node = unwrapExpression(expression);
+	if (context.implementationValue) {
+		if (ts.isIdentifier(node)) {
+			const binding = bindings.get(node.text);
+			if (binding) return inlineCodeExpression(ts.isFunctionDeclaration(binding) ? binding.getText() : unwrapExpression(binding).getText());
+			return;
+		}
+		return inlineCodeExpression(node.getText());
+	}
+	if (context.machineContextValue && (ts.isArrowFunction(node) || ts.isFunctionExpression(node))) return inlineCodeExpression(node.getText());
+	if (context.targetValue) {
+		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 expressionToValue(binding, bindings, context, depth + 1);
+		}
+		return inlineCodeExpression(resolvedExpressionText(node, bindings));
+	}
 	if (context.actorSourceValue) {
 		if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
 		if (ts.isIdentifier(node)) {
@@ -3700,6 +3965,10 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 	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.effectArgumentValue && !ts.isObjectLiteralExpression(node) && !ts.isArrayLiteralExpression(node)) {
+		if (ts.isIdentifier(node) && node.text === "undefined") return void 0;
+		return inlineCodeExpression(resolvedExpressionText(node, bindings));
+	}
 	if (context.ioPropertyValue) {
 		if (ts.isIdentifier(node) && node.text === "undefined") return void 0;
 		if (ts.isIdentifier(node)) {
@@ -3714,7 +3983,7 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 			const binding = bindings.get(node.text);
 			if (binding && !ts.isFunctionDeclaration(binding)) return expressionToValue(binding, bindings, context, depth + 1);
 		}
-		return wrapAssignExpression(node.getText());
+		return wrapAssignExpression(resolvedExpressionText(node, bindings));
 	}
 	if (context.transitionContext && !ts.isObjectLiteralExpression(node)) return inlineCodeExpression(node.getText());
 	if (context.ioValue && !ts.isObjectLiteralExpression(node)) return inlineCodeExpression(node.getText());
@@ -3794,10 +4063,20 @@ function isCreateMachineCall(node) {
 	if (ts.isPropertyAccessExpression(expression)) return expression.name.text === "createMachine";
 	return false;
 }
+function setupCallForCreateMachine(node, bindings) {
+	if (!ts.isPropertyAccessExpression(node.expression)) return null;
+	let receiver = unwrapExpression(node.expression.expression);
+	if (ts.isIdentifier(receiver)) {
+		const binding = bindings.get(receiver.text);
+		if (binding && !ts.isFunctionDeclaration(binding)) receiver = unwrapExpression(binding);
+	}
+	return ts.isCallExpression(receiver) && ts.isIdentifier(receiver.expression) && receiver.expression.text === "setup" ? receiver : null;
+}
 function hasV6Syntax(source) {
 	const file = sourceFile(source);
 	const bindings = collectBindings(file);
 	let found = false;
+	const visitedSyntaxBindings = /* @__PURE__ */ new Set();
 	function containsFunction(expression, seenBindings = /* @__PURE__ */ new Set()) {
 		if (ts.isFunctionDeclaration(expression)) return true;
 		const node = unwrapExpression(expression);
@@ -3818,8 +4097,16 @@ function hasV6Syntax(source) {
 		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) {
+	function visitSyntax(node) {
 		if (found) return;
+		if (ts.isIdentifier(node)) {
+			const binding = bindings.get(node.text);
+			if (binding && !visitedSyntaxBindings.has(binding)) {
+				visitedSyntaxBindings.add(binding);
+				visitSyntax(binding);
+			}
+			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") {
@@ -3831,9 +4118,19 @@ function hasV6Syntax(source) {
 				return;
 			}
 		}
-		ts.forEachChild(node, visit);
+		ts.forEachChild(node, visitSyntax);
 	}
-	visit(file);
+	function visitMachineCalls(node) {
+		if (ts.isCallExpression(node) && isCreateMachineCall(node)) {
+			const config = node.arguments[0];
+			if (config) visitSyntax(config);
+			const setupConfig = setupCallForCreateMachine(node, bindings)?.arguments[0];
+			if (setupConfig) visitSyntax(setupConfig);
+			return;
+		}
+		ts.forEachChild(node, visitMachineCalls);
+	}
+	visitMachineCalls(file);
 	return found;
 }
 function detectXStateSourceProfile(source) {
@@ -3861,7 +4158,18 @@ function extractXStateMachineConfigs(source, options = {}) {
 		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);
+		if (value && typeof value === "object" && !Array.isArray(value)) {
+			const setupArg = setupCallForCreateMachine(node, bindings)?.arguments[0];
+			const setupValue = setupArg ? expressionToValue(setupArg, bindings, {
+				v6: profile === "xstate-v6-alpha",
+				setupValue: true
+			}) : null;
+			const setupRecord = setupValue && typeof setupValue === "object" && !Array.isArray(setupValue) ? Object.fromEntries(Object.entries(setupValue).filter(([, item]) => !(item && typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 0))) : {};
+			found.push({
+				...setupRecord,
+				...value
+			});
+		}
 	}
 	visit(file);
 	return found;
@@ -3943,7 +4251,8 @@ function isRequiredProperty(key, def, required) {
 	return typeof def === "object" && def !== null && def.required === true;
 }
 function graphToXStateTS(graph, options = {}) {
-	const { exportStyle = "named", targetLanguage = "typescript", xstateVersion = 5, ...configOptions } = options;
+	const inferredXStateVersion = isXStateV6ProfileRef(graph.data.profile ?? "xstate-v5") ? 6 : 5;
+	const { exportStyle = "named", targetLanguage = "typescript", xstateVersion = inferredXStateVersion, ...configOptions } = options;
 	const schemas = graph.data.schemas;
 	const impls = filterInlineImplementations(graph.data.implementations);
 	const supportsTypeSyntax = targetLanguage === "typescript";
@@ -3955,12 +4264,14 @@ function graphToXStateTS(graph, options = {}) {
 	const hasSetup = hasSchemas || hasActions || hasGuards || hasActors || hasDelays;
 	const builtInActions = getUsedBuiltInActions(graph, xstateVersion);
 	const actorSourceImports = getActorSourceImports(graph);
+	const implementationImports = getImplementationImports(impls);
 	const imports = buildImports({
 		hasSetup,
 		hasActors,
 		actors: impls?.actors ?? [],
 		builtInActions,
 		actorSourceImports,
+		implementationImports,
 		usesTypes: xstateVersion === 6 && supportsTypeSyntax && hasSchemas
 	});
 	const machineConfig = xstateVersion === 6 ? toV6MachineConfig(graphToMachineConfig(graph, configOptions)) : toV5MachineConfig(graphToMachineConfig(graph, configOptions));
@@ -4041,9 +4352,9 @@ function toV6MachineConfig(machineConfig) {
 	return mapV6MachineConfig(machineConfig);
 }
 function mapV6MachineConfig(value, context = {}) {
+	if (context.transitionValue) return toV6TransitionValue(value);
 	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") {
@@ -4069,7 +4380,7 @@ function mapV6TransitionMap(value) {
 	return result;
 }
 function toV6TransitionValue(value) {
-	if (Array.isArray(value)) return value.map((item) => toV6TransitionValue(item));
+	if (Array.isArray(value)) return buildV6TransitionFunction(value) ?? 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);
@@ -4086,6 +4397,63 @@ function toV6TransitionValue(value) {
 		context
 	}) ?? mapV6MachineConfig(transition);
 }
+function guardCondition(value) {
+	const expression = inlineExpr(value);
+	if (!expression) return value === void 0 ? { condition: "true" } : null;
+	const arrow = expression.indexOf("=>");
+	if (arrow < 0) return null;
+	const params = expression.slice(0, arrow).trim();
+	const body = expression.slice(arrow + 2).trim();
+	if (body.startsWith("{")) return null;
+	return {
+		condition: body,
+		firstParam: params.startsWith("(") && params.endsWith(")") ? params.slice(1, -1).trim() : params
+	};
+}
+function buildV6TransitionFunction(transitions) {
+	const branches = [];
+	let authoredFirstParam;
+	for (const item of transitions) {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return;
+		const transition = item;
+		if (transition.description !== void 0 || transition.input !== void 0 || transition.matches !== void 0) return;
+		const guard = guardCondition(transition.guard);
+		if (!guard) return;
+		if (guard.firstParam) {
+			if (authoredFirstParam && authoredFirstParam !== guard.firstParam) return;
+			authoredFirstParam = guard.firstParam;
+		}
+		const actionValue = transition.actions;
+		const effects = (Array.isArray(actionValue) ? actionValue : actionValue === void 0 ? [] : [actionValue]).map(actionToV6Effect);
+		if (effects.some((effect) => !effect)) return;
+		const rendered = renderV6Effects(effects.filter((effect) => Boolean(effect)), transition.context === void 0 ? void 0 : serializeJS(unwrapTemplateExpressions(transition.context)));
+		const returnValue = buildV6TransitionReturnValue({
+			target: typeof transition.target === "string" ? transition.target : void 0,
+			reenter: transition.reenter === true,
+			meta: transition.meta
+		}, rendered.contextValue);
+		if (!returnValue) return;
+		const body = [...rendered.statements.map(formatV6Statement), `return ${returnValue};`];
+		if (body.length === 0) return;
+		if (guard.condition === "true") branches.push(...body.map((line) => `  ${line}`));
+		else {
+			branches.push(`  if (${guard.condition}) {`);
+			branches.push(...body.map((line) => `    ${line}`));
+			branches.push("  }");
+		}
+	}
+	if (branches.length === 0) return;
+	const referenced = branches.join("\n");
+	const inferredBindings = [
+		"context",
+		"event",
+		"actions",
+		"children",
+		"self",
+		"system"
+	].filter((name) => new RegExp(`\\b${name}\\b`).test(referenced));
+	return raw(`(${authoredFirstParam ?? (inferredBindings.length ? `{ ${inferredBindings.join(", ")} }` : "_")}, enq) => {\n${branches.join("\n")}\n}`);
+}
 function toV6ActionField(actions) {
 	if (actions.length === 1) {
 		const expr = inlineExpr(actions[0]);
@@ -4096,16 +4464,41 @@ function toV6ActionField(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;
+	const explicitContext = transition?.context === void 0 ? void 0 : serializeJS(unwrapTemplateExpressions(transition.context));
+	const rendered = renderV6Effects(effects.filter((effect) => Boolean(effect)), explicitContext);
+	const statements = rendered.statements;
+	let returnValue = rendered.contextValue ? `{ context: ${rendered.contextValue} }` : void 0;
+	if (transition) returnValue = buildV6TransitionReturnValue(transition, rendered.contextValue);
+	if (statements.length === 0 && !returnValue) return void 0;
+	const referenced = [...statements, returnValue ?? ""].join("\n");
+	const bindings = [
+		"context",
+		"event",
+		"actions",
+		"children",
+		"self",
+		"system"
+	].filter((name) => new RegExp(`\\b${name}\\b`).test(referenced));
+	return raw(`(${bindings.length ? `{ ${bindings.join(", ")} }` : "_"}, enq) => {\n${[...statements.map((statement) => `  ${formatV6Statement(statement)}`), ...returnValue ? [`  return ${returnValue};`] : []].join("\n")}\n}`);
+}
+function formatV6Statement(statement) {
+	return statement === "{" || statement === "}" || statement.endsWith(";") ? statement : `${statement};`;
+}
+function renderV6Effects(effects, finalContext) {
+	if (!(finalContext !== void 0 || effects.some((effect) => effect.contextValue))) return { statements: effects.flatMap((effect) => effect.statements ?? []) };
+	const statements = ["let nextContext = context"];
+	const inCurrentContext = (statement) => {
+		statements.push("{", "  const context = nextContext", `  ${statement}`, "}");
+	};
 	for (const effect of effects) {
-		returnValue = effect?.returnValue ?? returnValue;
-		contextValue = effect?.contextValue ?? contextValue;
+		for (const statement of effect.statements ?? []) inCurrentContext(statement);
+		if (effect.contextValue) inCurrentContext(`nextContext = { ...nextContext, ...(${effect.contextValue}) }`);
 	}
-	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}`);
+	if (finalContext !== void 0) inCurrentContext(`nextContext = { ...nextContext, ...(${finalContext}) }`);
+	return {
+		statements,
+		contextValue: "nextContext"
+	};
 }
 function unwrapTemplateExpressions(value) {
 	if (typeof value === "string") {
@@ -4153,6 +4546,8 @@ function inlineExpr(value) {
 function actionToV6Effect(action) {
 	const expr = inlineExpr(action);
 	if (expr) {
+		const assignment = getV6AssignmentContextValue(expr);
+		if (assignment) return { contextValue: assignment };
 		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) {
@@ -4182,45 +4577,127 @@ function actionToV6Effect(action) {
 		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} }`
-		};
-	}
+	if (type === "xstate.assign") return { contextValue: serializeJS(params.assignment ?? params) };
+	if (!type.startsWith("xstate.")) return { statements: [`enq(${/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(type) ? `actions.${type}` : `actions[${serializeJS(type)}]`}${Object.keys(params).length > 0 ? `, ${serializeJS(params)}` : ""})`] };
 	return null;
 }
+function getV6AssignmentArgs(code, includeAll = false) {
+	const entries = [
+		"context",
+		"event",
+		"self",
+		"children",
+		"system"
+	].filter((name) => includeAll || new RegExp(`\\b${name}\\b`).test(code));
+	if (includeAll || /\bspawn\b/.test(code)) entries.push("spawn: enq.spawn");
+	return `{ ${entries.join(", ")} }`;
+}
+function getV6AssignmentContextValue(code) {
+	const parsed = parseSingleExpression(code);
+	const expression = parsed?.expression;
+	if (!expression || !ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || expression.expression.text !== "assign" || expression.arguments.length !== 1) return;
+	const [assignment] = expression.arguments;
+	if (!assignment) return;
+	if (ts.isArrowFunction(assignment) || ts.isFunctionExpression(assignment)) {
+		const source = assignment.getText(parsed.source);
+		return `(${source})(${getV6AssignmentArgs(source)})`;
+	}
+	if (!ts.isObjectLiteralExpression(assignment)) return getDynamicV6AssignmentContextValue(assignment.getText(parsed.source));
+	const properties = [];
+	for (const property of assignment.properties) {
+		if (ts.isPropertyAssignment(property)) {
+			const value = property.initializer;
+			const source = value.getText(parsed.source);
+			properties.push(`${property.name.getText(parsed.source)}: ${ts.isArrowFunction(value) || ts.isFunctionExpression(value) ? `(${source})(${getV6AssignmentArgs(source)})` : source}`);
+			continue;
+		}
+		if (ts.isMethodDeclaration(property) && property.body) {
+			const source = property.getText(parsed.source);
+			const params = property.parameters.map((param) => param.getText(parsed.source)).join(", ");
+			properties.push(`${property.name.getText(parsed.source)}: (function (${params}) ${property.body.getText(parsed.source)})(${getV6AssignmentArgs(source)})`);
+			continue;
+		}
+		if (ts.isShorthandPropertyAssignment(property)) {
+			properties.push(property.getText(parsed.source));
+			continue;
+		}
+		return getDynamicV6AssignmentContextValue(assignment.getText(parsed.source));
+	}
+	return `{ ${properties.join(", ")} }`;
+}
+function getDynamicV6AssignmentContextValue(assignment) {
+	const args = getV6AssignmentArgs(assignment, true);
+	return `((assignment) => typeof assignment === 'function'
+    ? assignment(${args})
+    : Object.fromEntries(Object.entries(assignment).map(([key, value]) => [
+        key,
+        typeof value === 'function' ? value(${args}) : value,
+      ])))(${assignment})`;
+}
 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 }) {
+function buildImports({ hasSetup, hasActors, actors, builtInActions, actorSourceImports, implementationImports, 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);
+	for (const name of implementationImports) 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';`;
 }
+const XSTATE_ACTOR_LOGIC_HELPERS = new Set([
+	"createMachine",
+	"createAsyncLogic",
+	"fromPromise",
+	"fromCallback",
+	"fromObservable",
+	"fromEventObservable",
+	"fromTransition"
+]);
+const XSTATE_IMPLEMENTATION_HELPERS = new Set([
+	...Object.values(BUILTIN_ACTION_IMPORTS),
+	"enqueueActions",
+	"sendParent",
+	"forwardTo",
+	"stop",
+	"and",
+	"or",
+	"not",
+	"stateIn",
+	...XSTATE_ACTOR_LOGIC_HELPERS
+]);
+function getImplementationImports(impls) {
+	const imports = /* @__PURE__ */ new Set();
+	if (!impls) return imports;
+	for (const implementation of [
+		...impls.actions,
+		...impls.guards,
+		...impls.actors,
+		...impls.delays
+	]) {
+		const code = implementation.code?.body;
+		if (!code) continue;
+		const source = ts.createSourceFile("implementation.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+		function visit(node) {
+			if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && XSTATE_IMPLEMENTATION_HELPERS.has(node.expression.text)) imports.add(node.expression.text);
+			ts.forEachChild(node, visit);
+		}
+		visit(source);
+	}
+	return imports;
+}
 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);
+		for (const candidate of XSTATE_ACTOR_LOGIC_HELPERS) if (new RegExp(`\\b${candidate}\\b`).test(expression)) imports.add(candidate);
 	}
 	return imports;
 }
@@ -4307,11 +4784,27 @@ function buildGuardsBlock(guards, options) {
 function buildActorsBlock(actors, options) {
 	const block = {};
 	for (const actor of actors) if (actor.code?.body) {
+		const inlineExpression = getActorLogicExpression(actor.code.body);
+		if (inlineExpression) {
+			block[actor.name] = raw(inlineExpression);
+			continue;
+		}
+		const functionExpression = stripExportDefault(actor.code.body);
+		if (isCompleteFunctionExpression(functionExpression)) {
+			block[actor.name] = raw(`fromPromise(${functionExpression})`);
+			continue;
+		}
 		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 getActorLogicExpression(code) {
+	const parsed = parseSingleExpression(stripExportDefault(code));
+	const expression = parsed?.expression;
+	if (!parsed || !expression || !ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || !XSTATE_ACTOR_LOGIC_HELPERS.has(expression.expression.text)) return;
+	return parsed.candidate;
+}
 function buildDelaysBlock(delays) {
 	const block = {};
 	for (const delay of delays) if (delay.code?.body) {
@@ -4320,6 +4813,11 @@ function buildDelaysBlock(delays) {
 			block[delay.name] = raw(inlineExpression);
 			continue;
 		}
+		const constantExpression = getConstantImplementationExpression(delay.code.body);
+		if (constantExpression) {
+			block[delay.name] = raw(constantExpression);
+			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;
@@ -4336,17 +4834,37 @@ function buildDelaysBlock(delays) {
 function getInlineExpression(code) {
 	const stripped = stripExportDefault(code);
 	if (stripped !== code.trim()) return stripped;
-	return isCompleteFunctionExpression(stripped) ? stripped : void 0;
+	return isCompleteFunctionExpression(stripped) || isCompleteXStateHelperExpression(stripped) ? stripped : void 0;
 }
-/** True when `code` is a single function or arrow-function expression. */
-function isCompleteFunctionExpression(code) {
+function parseSingleExpression(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 source = ts.createSourceFile("implementation.ts", `(${candidate})`, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+	if ((source.parseDiagnostics ?? []).length > 0 || source.statements.length !== 1) return;
 	const [statement] = source.statements;
-	if (!statement || !ts.isExpressionStatement(statement)) return false;
+	if (!statement || !ts.isExpressionStatement(statement)) return;
 	let expression = statement.expression;
 	if (ts.isParenthesizedExpression(expression)) expression = expression.expression;
+	return {
+		candidate,
+		expression,
+		source
+	};
+}
+function getConstantImplementationExpression(code) {
+	const parsed = parseSingleExpression(code);
+	if (!parsed) return;
+	const { candidate, expression } = parsed;
+	if (ts.isStringLiteral(expression) || ts.isNumericLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression) || expression.kind === ts.SyntaxKind.TrueKeyword || expression.kind === ts.SyntaxKind.FalseKeyword || expression.kind === ts.SyntaxKind.NullKeyword || ts.isPrefixUnaryExpression(expression) && ts.isNumericLiteral(expression.operand)) return candidate;
+}
+function isCompleteXStateHelperExpression(code) {
+	const expression = parseSingleExpression(code)?.expression;
+	if (!expression) return false;
+	return ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && XSTATE_IMPLEMENTATION_HELPERS.has(expression.expression.text);
+}
+/** True when `code` is a single function or arrow-function expression. */
+function isCompleteFunctionExpression(code) {
+	const expression = parseSingleExpression(code)?.expression;
+	if (!expression) return false;
 	return ts.isFunctionExpression(expression) || ts.isArrowFunction(expression);
 }
 const colorSchema = _enum([