@statelyai/sdk 0.20.2 → 0.21.0

package/dist/{statelyPragma-Cnj58Rua.mjs → statelyPragma-mii-qTXd.mjs}

@@ -1,6 +1,5 @@
 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
@@ -2636,7 +2635,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(", ")} }`;
@@ -3013,6 +3013,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",
@@ -3037,16 +3154,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) {
@@ -3060,7 +3260,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
@@ -3078,6 +3464,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
@@ -3124,14 +3518,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;
@@ -3152,7 +3543,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);
@@ -3188,7 +3579,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]
@@ -3201,7 +3592,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]
@@ -3259,7 +3650,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"
 		}
 	};
@@ -3269,7 +3660,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);
@@ -3358,7 +3749,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 }]
@@ -3382,7 +3773,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;
@@ -3419,9 +3817,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));
@@ -3438,7 +3838,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 {
@@ -3483,11 +3883,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;
@@ -3513,6 +3926,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)) {
@@ -3534,6 +3964,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)) {
@@ -3548,7 +3982,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());
@@ -3628,10 +4062,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);
@@ -3652,8 +4096,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") {
@@ -3665,9 +4117,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) {
@@ -3695,7 +4157,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;
@@ -3777,7 +4250,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";
@@ -3789,12 +4263,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));
@@ -3875,9 +4351,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") {
@@ -3903,7 +4379,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);
@@ -3920,6 +4396,148 @@ 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
+	};
+}
+const V6_ARG_BINDINGS = [
+	"context",
+	"event",
+	"actions",
+	"children",
+	"self",
+	"system"
+];
+const V6_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function inferV6ArgBindings(code) {
+	return V6_ARG_BINDINGS.filter((name) => new RegExp(`\\b${name}\\b`).test(code));
+}
+/** Splits a destructuring pattern body on its top-level commas. */
+function splitV6PatternEntries(body) {
+	const entries = [];
+	let depth = 0;
+	let start = 0;
+	let quote;
+	for (let index = 0; index < body.length; index++) {
+		const char = body[index];
+		if (quote) {
+			if (char === "\\") index++;
+			else if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") quote = char;
+		else if (char === "{" || char === "[" || char === "(") depth++;
+		else if (char === "}" || char === "]" || char === ")") {
+			depth--;
+			if (depth < 0) return void 0;
+		} else if (char === "," && depth === 0) {
+			entries.push(body.slice(start, index));
+			start = index + 1;
+		}
+	}
+	if (depth !== 0 || quote) return void 0;
+	entries.push(body.slice(start));
+	return entries.map((entry) => entry.trim()).filter(Boolean);
+}
+/** Local name a destructuring entry binds, or `undefined` if not a plain one. */
+function getV6PatternBinding(entry) {
+	const colon = entry.indexOf(":");
+	const name = (colon < 0 ? entry : entry.slice(colon + 1)).split("=")[0].trim();
+	return V6_IDENTIFIER.test(name) ? name : void 0;
+}
+/**
+* Unions the bindings referenced by generated code into the parameter authored
+* on a guard, so a collapsed transition function never references unbound
+* variables. Returns `undefined` when the authored parameter cannot be
+* extended safely, in which case the transition array is kept as-is.
+*/
+function mergeV6FirstParam(authoredFirstParam, inferred) {
+	if (!authoredFirstParam) return {
+		firstParam: inferred.length ? `{ ${inferred.join(", ")} }` : "_",
+		prelude: []
+	};
+	if (inferred.length === 0) return {
+		firstParam: authoredFirstParam,
+		prelude: []
+	};
+	if (V6_IDENTIFIER.test(authoredFirstParam)) {
+		if (inferred.includes(authoredFirstParam)) return void 0;
+		return {
+			firstParam: authoredFirstParam,
+			prelude: [`const { ${inferred.join(", ")} } = ${authoredFirstParam};`]
+		};
+	}
+	if (!authoredFirstParam.startsWith("{") || !authoredFirstParam.endsWith("}")) return;
+	const entries = splitV6PatternEntries(authoredFirstParam.slice(1, -1));
+	if (!entries) return void 0;
+	const bound = new Set(entries.map(getV6PatternBinding).filter((name) => name !== void 0));
+	const missing = inferred.filter((name) => !bound.has(name));
+	if (missing.length === 0) return {
+		firstParam: authoredFirstParam,
+		prelude: []
+	};
+	const restIndex = entries.findIndex((entry) => entry.startsWith("..."));
+	return {
+		firstParam: `{ ${(restIndex < 0 ? [...entries, ...missing] : [
+			...entries.slice(0, restIndex),
+			...missing,
+			...entries.slice(restIndex)
+		]).join(", ")} }`,
+		prelude: []
+	};
+}
+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;
+		branches.push({
+			condition: guard.condition,
+			body
+		});
+	}
+	if (branches.length === 0) return;
+	const generated = branches.flatMap((branch) => branch.body).join("\n");
+	const merged = mergeV6FirstParam(authoredFirstParam, inferV6ArgBindings(generated));
+	if (!merged) return;
+	const lines = merged.prelude.map((statement) => `  ${statement}`);
+	for (const branch of branches) if (branch.condition === "true") lines.push(...branch.body.map((line) => `  ${line}`));
+	else {
+		lines.push(`  if (${branch.condition}) {`);
+		lines.push(...branch.body.map((line) => `    ${line}`));
+		lines.push("  }");
+	}
+	return raw(`(${merged.firstParam}, enq) => {\n${lines.join("\n")}\n}`);
+}
 function toV6ActionField(actions) {
 	if (actions.length === 1) {
 		const expr = inlineExpr(actions[0]);
@@ -3930,16 +4548,33 @@ 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 bindings = inferV6ArgBindings([...statements, returnValue ?? ""].join("\n"));
+	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") {
@@ -3987,6 +4622,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) {
@@ -4016,45 +4653,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;
 }
@@ -4141,11 +4860,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) {
@@ -4154,6 +4889,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;
@@ -4170,17 +4910,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([