@statelyai/sdk 0.24.0 → 0.26.0

package/dist/{statelyPragma-0djA1cnm.mjs → statelyPragma-B-axv279.mjs}

@@ -1,5 +1,6 @@
 import { a as discriminatedUnion, c as object, d as union, f as unknown, i as custom, l as record, n as array, o as literal, r as boolean, s as number, t as _enum, u as string } from "./openapi-BTDjYWXd.mjs";
 import ts from "typescript";
+import "xstate";
 import "xstate/graph";
 
 //#region ../../node_modules/.pnpm/js-yaml@4.2.0/node_modules/js-yaml/dist/js-yaml.mjs
@@ -2881,8 +2882,8 @@ function graphToMachineConfig(graph, options = {}) {
 				id: inv.invocationId ?? inv.id,
 				...inv.registryKey ? { registryKey: inv.registryKey } : void 0,
 				...inv.timeout !== void 0 ? { timeout: inv.timeout } : void 0,
-				...inv.input ? { input: inv.input } : void 0,
-				...inv.output ? { output: inv.output } : void 0
+				...inv.input !== void 0 ? { input: inv.input } : void 0,
+				...inv.output !== void 0 ? { output: inv.output } : void 0
 			})) } : void 0,
 			...node.data.output !== void 0 ? { output: node.data.output } : void 0,
 			...tags?.length ? { tags: tags.map(tagToString) } : void 0,
@@ -3436,88 +3437,117 @@ function schemasObjectToValue(node) {
 	return result;
 }
 function propertyContext(parent, key) {
+	const inherited = parent.imports ? { imports: parent.imports } : {};
+	if (parent.machineValue && (key === "actors" || key === "actorSources")) return {
+		...inherited,
+		v6: parent.v6,
+		implementationMap: true
+	};
 	if (parent.setupValue && (key === "actions" || key === "guards" || key === "actors" || key === "delays")) return {
+		...inherited,
 		v6: parent.v6,
 		implementationMap: true
 	};
 	if (parent.implementationMap) return {
+		...inherited,
 		v6: parent.v6,
 		implementationValue: true
 	};
 	if (parent.effectArgumentValue) return {
+		...inherited,
 		v6: parent.v6,
 		effectArgumentValue: true
 	};
 	if (parent.invokeValue && key === "src") return {
+		...inherited,
 		v6: parent.v6,
 		actorSourceValue: true
 	};
 	if (parent.transitionMap) return {
+		...inherited,
 		v6: parent.v6,
 		transitionValue: true
 	};
 	if (parent.transitionValue && key === "actions") return {
+		...inherited,
 		v6: parent.v6,
 		actionValue: true
 	};
 	if (parent.transitionValue && key === "context") return {
+		...inherited,
 		v6: parent.v6,
 		assignmentMap: true,
 		transitionContext: true
 	};
 	if (key === "context") return {
+		...inherited,
 		v6: parent.v6,
 		machineContextValue: true
 	};
 	if (parent.transitionValue && key === "target") return {
+		...inherited,
 		v6: parent.v6,
 		targetValue: true
 	};
 	if (parent.assignmentMap) return {
+		...inherited,
 		v6: parent.v6,
 		assignmentValue: true
 	};
 	if (key === "meta") return {
+		...inherited,
 		v6: parent.v6,
 		metaValue: true
 	};
 	if (parent.transitionValue && key === "to") return {
+		...inherited,
 		v6: parent.v6,
 		transitionValue: true
 	};
 	if (key === "entry" || key === "exit") return {
+		...inherited,
 		v6: parent.v6,
 		actionValue: true
 	};
 	if (key === "input" || key === "output") return {
+		...inherited,
 		v6: parent.v6,
 		ioValue: true
 	};
 	if (parent.ioValue || parent.ioPropertyValue) return {
+		...inherited,
 		v6: parent.v6,
 		ioPropertyValue: true
 	};
 	if (key === "invoke") return {
+		...inherited,
 		v6: parent.v6,
 		invokeValue: true
 	};
 	if (key === "timeout") return {
+		...inherited,
 		v6: parent.v6,
 		timeoutValue: true
 	};
 	if (key === "route") return {
+		...inherited,
 		v6: parent.v6,
 		routeValue: true
 	};
 	if (key === "on" || key === "after") return {
+		...inherited,
 		v6: parent.v6,
 		transitionMap: true
 	};
 	if (key === "always" || key === "choice" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout") return {
+		...inherited,
 		v6: parent.v6,
 		transitionValue: true
 	};
-	return { v6: parent.v6 };
+	return {
+		...inherited,
+		v6: parent.v6
+	};
 }
 function fallbackFunctionTransition(fn) {
 	return { meta: {
@@ -3531,7 +3561,7 @@ function conditionText(cond) {
 function simplifyConditions(conds) {
 	const seen = /* @__PURE__ */ new Set();
 	return conds.filter((cond) => {
-		if (cond.negated) return false;
+		if (cond.negated && !cond.preserveNegation) return false;
 		const key = conditionText(cond);
 		if (seen.has(key)) return false;
 		seen.add(key);
@@ -3755,18 +3785,21 @@ function statementBranches(statements, bindings, enqName, prefixes = [{
 					...prefix,
 					conds: [...prefix.conds, { text: cond }]
 				}]);
+				const thenHasEffectiveTransition = thenBranches.every((branch) => branch.result !== void 0 && branch.result !== null || branch.actions.length > 0);
 				const elseStatements = statement.elseStatement ? ts.isBlock(statement.elseStatement) ? statement.elseStatement.statements : [statement.elseStatement] : [];
 				const elseBranches = elseStatements.length > 0 ? statementBranches(elseStatements, scopedBindings, enqName, [{
 					...prefix,
 					conds: [...prefix.conds, {
 						text: cond,
-						negated: true
+						negated: true,
+						preserveNegation: !thenHasEffectiveTransition
 					}]
 				}]) : [{
 					...prefix,
 					conds: [...prefix.conds, {
 						text: cond,
-						negated: true
+						negated: true,
+						preserveNegation: !thenHasEffectiveTransition
 					}]
 				}];
 				for (const branch of [...thenBranches, ...elseBranches]) if ("result" in branch) done.push(branch);
@@ -3877,13 +3910,34 @@ function enqueueAction(fn) {
 		}
 	};
 }
-function inlineCodeExpression(expr) {
+function inlineCodeExpression(expr, imports) {
 	return {
 		"@type": "code",
 		lang: "ts",
-		expr
+		expr,
+		...imports?.length ? { imports } : {}
 	};
 }
+function codeImportsForExpression(expression, imports) {
+	if (!imports?.size) return void 0;
+	const sourceImports = imports;
+	const file = sourceFile(`(${expression})`);
+	const found = /* @__PURE__ */ new Map();
+	const expressionNode = file.statements[0] && ts.isExpressionStatement(file.statements[0]) ? file.statements[0].expression : void 0;
+	function visit(node) {
+		if (expressionNode && ts.isIdentifier(node) && sourceImports.has(node.text) && !isShadowedWithinExpression(node, expressionNode)) {
+			const parent = node.parent;
+			if (ts.isPropertyAccessExpression(parent) && parent.name === node || ts.isPropertyAssignment(parent) && parent.name === node) {
+				ts.forEachChild(node, visit);
+				return;
+			}
+			found.set(node.text, sourceImports.get(node.text));
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(file);
+	return found.size ? [...found.values()] : void 0;
+}
 function normalizeFunctionAction(fn, _bindings) {
 	return enqueueAction(fn);
 }
@@ -3948,10 +4002,13 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 	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());
+			if (binding) {
+				const code = ts.isFunctionDeclaration(binding) ? binding.getText() : unwrapExpression(binding).getText();
+				return inlineCodeExpression(code, codeImportsForExpression(code, context.imports));
+			}
 			return;
 		}
-		return inlineCodeExpression(node.getText());
+		return inlineCodeExpression(node.getText(), codeImportsForExpression(node.getText(), context.imports));
 	}
 	if (context.machineContextValue && (ts.isArrowFunction(node) || ts.isFunctionExpression(node))) return inlineCodeExpression(node.getText());
 	if (context.targetValue) {
@@ -4018,7 +4075,8 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 			}
 			return expressionToValue(binding, bindings, context, depth + 1);
 		}
-		return context.metaValue ? inlineCodeExpression(node.getText()) : node.text;
+		const imported = context.imports?.get(node.text);
+		return imported ? inlineCodeExpression(node.text, [imported]) : context.metaValue ? inlineCodeExpression(node.getText()) : node.text;
 	}
 	if (ts.isObjectLiteralExpression(node)) return objectLiteralToValue(node, bindings, context, depth);
 	if (ts.isArrayLiteralExpression(node)) {
@@ -4075,6 +4133,26 @@ function collectBindings(file) {
 	}
 	return bindings;
 }
+function collectSourceImports(file) {
+	const imports = /* @__PURE__ */ new Map();
+	for (const statement of file.statements) {
+		if (!ts.isImportDeclaration(statement)) continue;
+		const moduleSpecifier = statement.moduleSpecifier;
+		if (!ts.isStringLiteral(moduleSpecifier)) continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (!namedBindings || !ts.isNamedImports(namedBindings)) continue;
+		for (const element of namedBindings.elements) {
+			const imported = element.propertyName?.text ?? element.name.text;
+			imports.set(element.name.text, {
+				package: moduleSpecifier.text,
+				import: imported,
+				local: imported === element.name.text ? void 0 : element.name.text,
+				importKind: "named"
+			});
+		}
+	}
+	return imports;
+}
 function isCreateMachineCall(node) {
 	const expression = node.expression;
 	if (ts.isIdentifier(expression)) return isMachineFactoryName(expression.text);
@@ -4173,6 +4251,7 @@ function xstateSourceToConfig(source, options = {}) {
 function extractXStateMachineConfigs(source, options = {}) {
 	const file = sourceFile(source);
 	const bindings = collectBindings(file);
+	const imports = collectSourceImports(file);
 	const found = [];
 	const profile = options.profile === "auto" || !options.profile ? detectXStateSourceProfile(source) : options.profile;
 	function visit(node) {
@@ -4182,12 +4261,17 @@ function extractXStateMachineConfigs(source, options = {}) {
 		}
 		const arg = node.arguments[0];
 		if (!arg) return;
-		const value = expressionToValue(arg, bindings, { v6: profile === "xstate-v6-alpha" });
+		const value = expressionToValue(arg, bindings, {
+			v6: profile === "xstate-v6-alpha",
+			machineValue: true,
+			imports
+		});
 		if (value && typeof value === "object" && !Array.isArray(value)) {
 			const setupArg = setupCallForCreateMachine(node, bindings)?.arguments[0];
 			const setupValue = setupArg ? expressionToValue(setupArg, bindings, {
 				v6: profile === "xstate-v6-alpha",
-				setupValue: true
+				setupValue: true,
+				imports
 			}) : null;
 			const setupRecord = setupValue && typeof setupValue === "object" && !Array.isArray(setupValue) ? Object.fromEntries(Object.entries(setupValue).filter(([, item]) => !(item && typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 0))) : {};
 			found.push({
@@ -4231,7 +4315,7 @@ function objectType(schema) {
 	const required = getRequiredKeys(schema);
 	return `{ ${Object.entries(props).map(([key, def]) => {
 		const type = jsonSchemaToTSType(resolveDef(def));
-		return `${key}${isRequiredProperty(key, def, required) ? "" : "?"}: ${type}`;
+		return `${key}${isRequiredProperty$1(key, def, required) ? "" : "?"}: ${type}`;
 	}).join("; ")} }`;
 }
 function resolveDef(def) {
@@ -4262,7 +4346,7 @@ function eventsSchemaToTSType(events) {
 		const required = getRequiredKeys(schema);
 		const extraProps = Object.entries(props).filter(([k]) => k !== "type").map(([key, def]) => {
 			const type = jsonSchemaToTSType(resolveDef(def));
-			return `${key}${isRequiredProperty(key, def, required) ? "" : "?"}: ${type}`;
+			return `${key}${isRequiredProperty$1(key, def, required) ? "" : "?"}: ${type}`;
 		});
 		if (extraProps.length === 0) return `{ type: '${eventType}' }`;
 		return `{ type: '${eventType}'; ${extraProps.join("; ")} }`;
@@ -4271,13 +4355,138 @@ function eventsSchemaToTSType(events) {
 function getRequiredKeys(schema) {
 	return new Set(Array.isArray(schema.required) ? schema.required : []);
 }
-function isRequiredProperty(key, def, required) {
+function isRequiredProperty$1(key, def, required) {
 	if (required.has(key)) return true;
 	return typeof def === "object" && def !== null && def.required === true;
 }
+function jsonSchemaToZod(schema) {
+	if (!schema) return "z.unknown()";
+	if (schema.enum) return enumToZod(schema.enum);
+	if (schema.const !== void 0) return `z.literal(${serializeJS(schema.const)})`;
+	if (schema.oneOf) return xorToZod(schema.oneOf);
+	if (schema.anyOf) return unionToZod(schema.anyOf);
+	if (schema.allOf) {
+		const schemas = schema.allOf.map(definitionToZod);
+		if (schemas.length === 0) return "z.unknown()";
+		return schemas.slice(1).reduce((result, next) => `z.intersection(${result}, ${next})`, schemas[0]);
+	}
+	if (Array.isArray(schema.type)) return unionToZod(schema.type.map((type) => ({
+		...schema,
+		type
+	})));
+	if (schema.type === "array") {
+		const items = schema.items;
+		let result;
+		if (Array.isArray(items)) result = `z.tuple(${serializeJS(items.map((item) => raw(definitionToZod(item))))})`;
+		else result = `z.array(${definitionToZod(items)})`;
+		return applyArrayConstraints(result, schema);
+	}
+	if (schema.type === "object" || schema.properties) return objectToZod(schema);
+	if (schema.type) return primitiveToZod(schema, schema.type);
+	return "z.unknown()";
+}
+/** Build a required object schema from the graph's context property map. */
+function contextSchemaToZod(context) {
+	if (!context || Object.keys(context).length === 0) return null;
+	return `z.object(${serializeJS(Object.fromEntries(Object.entries(context).map(([key, schema]) => [key, raw(jsonSchemaToZod(schema))])))})`;
+}
+/** Build an event payload schema without duplicating the discriminant. */
+function eventSchemaToZod(schema) {
+	const properties = schema.properties ?? {};
+	const payloadProperties = Object.fromEntries(Object.entries(properties).filter(([key]) => key !== "type"));
+	return jsonSchemaToZod({
+		...schema,
+		properties: payloadProperties,
+		required: Array.isArray(schema.required) ? schema.required.filter((key) => key !== "type") : void 0
+	});
+}
+function objectToZod(schema) {
+	const properties = schema.properties ?? {};
+	const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+	let result = `z.object(${serializeJS(Object.fromEntries(Object.entries(properties).map(([key, definition]) => {
+		return [key, raw(`${definitionToZod(definition)}${isRequiredProperty(key, definition, required) ? "" : ".optional()"}`)];
+	})))})`;
+	if (schema.additionalProperties === false) result += ".strict()";
+	else if (schema.additionalProperties === true || schema.additionalProperties === void 0) result += ".passthrough()";
+	else if (schema.additionalProperties) result += `.catchall(${jsonSchemaToZod(schema.additionalProperties)})`;
+	return result;
+}
+function primitiveToZod(schema, type) {
+	let result;
+	switch (type) {
+		case "string":
+			result = "z.string()";
+			if (schema.format === "email") result += ".email()";
+			if (schema.format === "uri" || schema.format === "url") result += ".url()";
+			if (schema.format === "uuid") result += ".uuid()";
+			if (schema.format === "date-time") result += ".datetime({ offset: true })";
+			if (typeof schema.minLength === "number") result += `.min(${schema.minLength})`;
+			if (typeof schema.maxLength === "number") result += `.max(${schema.maxLength})`;
+			if (schema.pattern) result += `.regex(new RegExp(${serializeJS(schema.pattern)}))`;
+			break;
+		case "number":
+		case "integer":
+			result = "z.number()";
+			if (type === "integer") result += ".int()";
+			if (typeof schema.minimum === "number") result += `.min(${schema.minimum})`;
+			if (typeof schema.maximum === "number") result += `.max(${schema.maximum})`;
+			if (typeof schema.exclusiveMinimum === "number") result += `.gt(${schema.exclusiveMinimum})`;
+			if (typeof schema.exclusiveMaximum === "number") result += `.lt(${schema.exclusiveMaximum})`;
+			if (typeof schema.multipleOf === "number") result += `.multipleOf(${schema.multipleOf})`;
+			break;
+		case "boolean":
+			result = "z.boolean()";
+			break;
+		case "null":
+			result = "z.null()";
+			break;
+		case "object":
+			result = objectToZod(schema);
+			break;
+		default:
+			result = "z.unknown()";
+			break;
+	}
+	if (schema.default !== void 0) result += `.default(${serializeJS(schema.default)})`;
+	return result;
+}
+function applyArrayConstraints(result, schema) {
+	if (typeof schema.minItems === "number") result += `.min(${schema.minItems})`;
+	if (typeof schema.maxItems === "number") result += `.max(${schema.maxItems})`;
+	return result;
+}
+function enumToZod(values) {
+	if (values.length === 0) return "z.never()";
+	if (values.every((value) => typeof value === "string")) {
+		if (values.length === 1) return `z.literal(${serializeJS(values[0])})`;
+		return `z.enum(${serializeJS(values)})`;
+	}
+	return unionToZod(values.map((value) => ({ const: value })));
+}
+function unionToZod(definitions) {
+	const schemas = definitions.map(definitionToZod);
+	if (schemas.length === 0) return "z.never()";
+	if (schemas.length === 1) return schemas[0];
+	return `z.union(${serializeJS(schemas.map((schema) => raw(schema)))})`;
+}
+function xorToZod(definitions) {
+	const schemas = definitions.map(definitionToZod);
+	if (schemas.length === 0) return "z.never()";
+	if (schemas.length === 1) return schemas[0];
+	return `z.xor(${serializeJS(schemas.map((schema) => raw(schema)))})`;
+}
+function definitionToZod(definition) {
+	if (definition === false) return "z.never()";
+	if (definition === true || definition === void 0) return "z.unknown()";
+	return jsonSchemaToZod(definition);
+}
+function isRequiredProperty(key, definition, required) {
+	if (required.has(key)) return true;
+	return typeof definition === "object" && definition !== null && definition.required === true;
+}
 function graphToXStateTS(graph, options = {}) {
 	const inferredXStateVersion = isXStateV6ProfileRef(graph.data.profile ?? "xstate-v5") ? 6 : 5;
-	const { exportStyle = "named", targetLanguage = "typescript", xstateVersion = inferredXStateVersion, ...configOptions } = options;
+	const { exportStyle = "named", targetLanguage = "typescript", xstateVersion = inferredXStateVersion, xstateV6SchemaFormat = "types", ...configOptions } = options;
 	const schemas = graph.data.schemas;
 	const impls = filterInlineImplementations(graph.data.implementations);
 	const supportsTypeSyntax = targetLanguage === "typescript";
@@ -4286,10 +4495,11 @@ function graphToXStateTS(graph, options = {}) {
 	const hasGuards = !!impls?.guards.length;
 	const hasActors = !!impls?.actors.length;
 	const hasDelays = !!impls?.delays.length;
-	const hasSetup = hasSchemas || hasActions || hasGuards || hasActors || hasDelays;
+	const hasSetup = xstateVersion === 6 || hasSchemas || hasActions || hasGuards || hasActors || hasDelays;
 	const builtInActions = getUsedBuiltInActions(graph, xstateVersion);
 	const actorSourceImports = getActorSourceImports(graph);
 	const implementationImports = getImplementationImports(impls);
+	const codeImports = getCodeExpressionImports(graph);
 	const imports = buildImports({
 		hasSetup,
 		hasActors,
@@ -4297,14 +4507,18 @@ function graphToXStateTS(graph, options = {}) {
 		builtInActions,
 		actorSourceImports,
 		implementationImports,
-		usesTypes: xstateVersion === 6 && supportsTypeSyntax && hasSchemas
+		codeImports,
+		xstateVersion,
+		usesTypes: xstateVersion === 6 && supportsTypeSyntax && hasSchemas && xstateV6SchemaFormat === "types",
+		usesZod: xstateVersion === 6 && hasSchemas && xstateV6SchemaFormat === "zod"
 	});
 	const machineConfig = xstateVersion === 6 ? toV6MachineConfig(graphToMachineConfig(graph, configOptions)) : toV5MachineConfig(graphToMachineConfig(graph, configOptions));
 	let machineExpr;
 	if (hasSetup) {
 		const setupObj = buildSetupObject(schemas, impls, {
 			includeTypeSyntax: supportsTypeSyntax,
-			xstateVersion
+			xstateVersion,
+			xstateV6SchemaFormat
 		});
 		const configStr = serializeJS(machineConfig, 2);
 		machineExpr = `setup(${serializeJS(setupObj, 0)}).createMachine(${configStr})`;
@@ -4408,7 +4622,9 @@ function toV6TransitionValue(value) {
 	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);
+	if (transition.matches !== void 0) return buildV6TransitionFunction([transition]) ?? mapV6MachineConfig(transition);
+	if (transition.guard) return buildV6TransitionFunction([transition]) ?? mapV6MachineConfig(transition);
+	if (transition.description || transition.input !== void 0) return mapV6MachineConfig(transition);
 	const target = transition.target;
 	const context = transition.context;
 	const actionsValue = transition.actions;
@@ -4424,7 +4640,20 @@ function toV6TransitionValue(value) {
 }
 function guardCondition(value) {
 	const expression = inlineExpr(value);
-	if (!expression) return value === void 0 ? { condition: "true" } : null;
+	if (!expression) {
+		if (value === void 0) return { condition: "true" };
+		if (value && typeof value === "object" && !Array.isArray(value)) {
+			const guard = value;
+			if (typeof guard.type === "string") {
+				const params = guard.params === void 0 ? "" : `, ${serializeJS(guard.params)}`;
+				return {
+					condition: `guards[${serializeJS(guard.type)}]({ context, event }${params})`,
+					firstParam: "{ context, event, guards }"
+				};
+			}
+		}
+		return null;
+	}
 	const arrow = expression.indexOf("=>");
 	if (arrow < 0) return null;
 	const params = expression.slice(0, arrow).trim();
@@ -4432,13 +4661,28 @@ function guardCondition(value) {
 	if (body.startsWith("{")) return null;
 	return {
 		condition: body,
+		callCondition: `(${expression})({ context, event, input, output, actions, guards, children, self, system })`,
 		firstParam: params.startsWith("(") && params.endsWith(")") ? params.slice(1, -1).trim() : params
 	};
 }
+function matchesCondition(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const entries = Object.entries(value);
+	if (entries.length === 0) return "true";
+	return entries.map(([key, expected]) => `Object.is(event[${serializeJS(key)}], ${serializeJS(expected)})`).join(" && ");
+}
+function combineConditions(match, guard) {
+	if (!match || match === "true") return guard;
+	if (guard === "true") return match;
+	return `${match} && (${guard})`;
+}
 const V6_ARG_BINDINGS = [
 	"context",
 	"event",
+	"input",
+	"output",
 	"actions",
+	"guards",
 	"children",
 	"self",
 	"system"
@@ -4527,7 +4771,8 @@ function buildV6TransitionFunction(transitions) {
 	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 match = transition.matches === void 0 ? void 0 : matchesCondition(transition.matches);
+		if (match === null) return;
 		const guard = guardCondition(transition.guard);
 		if (!guard) return;
 		if (guard.firstParam) {
@@ -4538,25 +4783,35 @@ function buildV6TransitionFunction(transitions) {
 		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({
+		const effectiveReturnValue = 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};`];
+			meta: transition.meta,
+			input: transition.input
+		}, rendered.contextValue) ?? "{}";
+		const body = [...rendered.statements.map(formatV6Statement), `return ${effectiveReturnValue};`];
 		if (body.length === 0) return;
 		branches.push({
-			condition: guard.condition,
+			condition: combineConditions(match, guard.condition),
+			callCondition: guard.callCondition ? combineConditions(match, guard.callCondition) : void 0,
 			body
 		});
 	}
 	if (branches.length === 0) return;
-	const generated = branches.flatMap((branch) => branch.body).join("\n");
-	const merged = mergeV6FirstParam(authoredFirstParam, inferV6ArgBindings(generated));
+	const generated = branches.flatMap((branch) => [branch.condition, ...branch.body]).join("\n");
+	let renderedBranches = branches;
+	let merged = mergeV6FirstParam(authoredFirstParam, inferV6ArgBindings(generated));
+	if (!merged) {
+		if (branches.some((branch) => !branch.callCondition)) return;
+		renderedBranches = branches.map((branch) => ({
+			...branch,
+			condition: branch.callCondition
+		}));
+		merged = mergeV6FirstParam(void 0, inferV6ArgBindings(`${renderedBranches.map((branch) => branch.condition).join("\n")}\n${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}`));
+	for (const branch of renderedBranches) if (branch.condition === "true") lines.push(...branch.body.map((line) => `  ${line}`));
 	else {
 		lines.push(`  if (${branch.condition}) {`);
 		lines.push(...branch.body.map((line) => `    ${line}`));
@@ -4612,12 +4867,13 @@ function unwrapTemplateExpressions(value) {
 	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, unwrapTemplateExpressions(item)]));
 }
 function buildV6TransitionReturnValue(transition, contextValue) {
-	if (!transition.reenter && !transition.meta && !contextValue) return transition.target ? `{ target: ${serializeJS(transition.target)} }` : void 0;
+	if (!transition.reenter && !transition.meta && !contextValue && transition.input === void 0) return transition.target ? `{ target: ${serializeJS(transition.target)} }` : void 0;
 	return serializeJS({
 		target: transition.target,
 		reenter: transition.reenter ? true : void 0,
 		meta: transition.meta,
-		context: contextValue ? raw(contextValue) : void 0
+		context: contextValue ? raw(contextValue) : void 0,
+		input: transition.input === void 0 ? void 0 : unwrapTemplateExpressions(transition.input)
 	});
 }
 function mapMachineActionFields(value, mapActions) {
@@ -4740,7 +4996,7 @@ 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, implementationImports, usesTypes }) {
+function buildImports({ hasSetup, hasActors, actors, builtInActions, actorSourceImports, implementationImports, codeImports, xstateVersion, usesTypes, usesZod }) {
 	const xstateImports = [];
 	if (hasSetup) xstateImports.push("setup");
 	else xstateImports.push("createMachine");
@@ -4749,9 +5005,51 @@ function buildImports({ hasSetup, hasActors, actors, builtInActions, actorSource
 	for (const name of implementationImports) xstateImports.push(name);
 	if (usesTypes) xstateImports.push("types");
 	if (hasActors) {
-		if (actors.length > 0) xstateImports.push("fromPromise");
+		if (actors.length > 0) xstateImports.push(xstateVersion === 6 ? "createAsyncLogic" : "fromPromise");
+	}
+	const externalImports = /* @__PURE__ */ new Map();
+	for (const codeImport of codeImports) {
+		const specifier = codeImport.local && codeImport.local !== codeImport.import ? `${codeImport.import} as ${codeImport.local}` : codeImport.import;
+		if (codeImport.package === "xstate") {
+			if ((codeImport.importKind ?? "named") === "named") xstateImports.push(specifier);
+			continue;
+		}
+		if ((codeImport.importKind ?? "named") !== "named") continue;
+		const names = externalImports.get(codeImport.package) ?? /* @__PURE__ */ new Set();
+		names.add(specifier);
+		externalImports.set(codeImport.package, names);
+	}
+	const imports = [`import { ${[...new Set(xstateImports)].join(", ")} } from 'xstate';`];
+	for (const [packageName, names] of externalImports) imports.push(`import { ${[...names].sort().join(", ")} } from '${packageName}';`);
+	if (usesZod && !externalImports.get("zod")?.has("z")) imports.push("import { z } from 'zod';");
+	return imports.join("\n");
+}
+function getCodeExpressionImports(graph) {
+	const imports = /* @__PURE__ */ new Map();
+	function visit(value) {
+		if (!value || typeof value !== "object") return;
+		if (Array.isArray(value)) {
+			value.forEach(visit);
+			return;
+		}
+		const record = value;
+		if (Array.isArray(record.imports)) for (const item of record.imports) {
+			if (!item || typeof item !== "object") continue;
+			const candidate = item;
+			if (typeof candidate.package !== "string" || typeof candidate.import !== "string") continue;
+			const key = `${candidate.package}:${candidate.import}:${candidate.local ?? ""}:${candidate.importKind ?? "named"}`;
+			imports.set(key, {
+				package: candidate.package,
+				import: candidate.import,
+				local: candidate.local,
+				importKind: candidate.importKind,
+				version: candidate.version
+			});
+		}
+		Object.values(record).forEach(visit);
 	}
-	return `import { ${[...new Set(xstateImports)].join(", ")} } from 'xstate';`;
+	visit(graph);
+	return [...imports.values()];
 }
 const XSTATE_ACTOR_LOGIC_HELPERS = new Set([
 	"createMachine",
@@ -4814,7 +5112,10 @@ function buildSetupObject(schemas, impls, options) {
 	}
 	if (impls?.actions.length) setup.actions = buildActionsBlock(impls.actions, options);
 	if (impls?.guards.length) setup.guards = buildGuardsBlock(impls.guards, options);
-	if (impls?.actors.length) setup.actors = buildActorsBlock(impls.actors, options);
+	if (impls?.actors.length) setup.actors = buildActorsBlock(impls.actors, {
+		...options,
+		xstateVersion: options.xstateVersion
+	});
 	if (impls?.delays.length) setup.delays = buildDelaysBlock(impls.delays);
 	return setup;
 }
@@ -4830,7 +5131,9 @@ function buildTypesBlock(schemas, options) {
 	return Object.keys(types).length > 0 ? types : void 0;
 }
 function buildV6SchemasBlock(schemas, options) {
-	if (!schemas || !options.includeTypeSyntax) return void 0;
+	if (!schemas) return void 0;
+	if (options.xstateV6SchemaFormat === "zod") return buildV6ZodSchemasBlock(schemas);
+	if (!options.includeTypeSyntax) return void 0;
 	const result = {};
 	const contextType = contextSchemaToTSType(schemas.context);
 	if (contextType) result.context = raw(`types<${contextType}>()`);
@@ -4839,6 +5142,16 @@ function buildV6SchemasBlock(schemas, options) {
 	if (schemas.output) result.output = raw(`types<${jsonSchemaToTSType(schemas.output)}>()`);
 	return Object.keys(result).length > 0 ? result : void 0;
 }
+function buildV6ZodSchemasBlock(schemas) {
+	if (!schemas) return void 0;
+	const result = {};
+	const contextSchema = contextSchemaToZod(schemas.context);
+	if (contextSchema) result.context = raw(contextSchema);
+	if (schemas.events && Object.keys(schemas.events).length > 0) result.events = Object.fromEntries(Object.entries(schemas.events).map(([eventType, schema]) => [eventType, raw(eventSchemaToZod(schema))]));
+	if (schemas.input) result.input = raw(jsonSchemaToZod(schemas.input));
+	if (schemas.output) result.output = raw(jsonSchemaToZod(schemas.output));
+	return Object.keys(result).length > 0 ? result : void 0;
+}
 function eventPayloadSchemaToTSType(schema) {
 	const props = schema.properties ?? {};
 	const payloadProps = Object.fromEntries(Object.entries(props).filter(([key]) => key !== "type"));
@@ -4885,6 +5198,7 @@ function buildGuardsBlock(guards, options) {
 }
 function buildActorsBlock(actors, options) {
 	const block = {};
+	const actorFactory = options.xstateVersion === 6 ? "createAsyncLogic" : "fromPromise";
 	for (const actor of actors) if (actor.code?.body) {
 		const inlineExpression = getActorLogicExpression(actor.code.body);
 		if (inlineExpression) {
@@ -4893,12 +5207,12 @@ function buildActorsBlock(actors, options) {
 		}
 		const functionExpression = stripExportDefault(actor.code.body);
 		if (isCompleteFunctionExpression(functionExpression)) {
-			block[actor.name] = raw(`fromPromise(${functionExpression})`);
+			block[actor.name] = raw(options.xstateVersion === 6 ? `${actorFactory}({ run: ${functionExpression} })` : `${actorFactory}(${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})`);
+		block[actor.name] = raw(options.xstateVersion === 6 ? `${actorFactory}({ run: async ({ input }${inputType ? `: { input${inputType} }` : ""}) => {\n  ${dedent(actor.code.body)}\n} })` : `${actorFactory}(async ({ input }${inputType ? `: { input${inputType} }` : ""}) => {\n  ${dedent(actor.code.body)}\n})`);
+	} else block[actor.name] = raw(options.xstateVersion === 6 ? `${actorFactory}({ run: async ({ input }) => {\n  // TODO: implement ${actor.name}\n} })` : `${actorFactory}(async ({ input }) => {\n  // TODO: implement ${actor.name}\n})`);
 	return block;
 }
 function getActorLogicExpression(code) {