@statelyai/sdk 0.28.0 → 0.29.1

package/dist/{statelyPragma-ByF0-L-N.mjs → statelyPragma-p1vu8PmH.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 "./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
@@ -3487,10 +3486,16 @@ function singleOrArrayRecord(record) {
 * Remove empty arrays/objects/strings, unwrap single-element arrays.
 * Matches studio's simplifyAttributes behavior.
 */
+/**
+* Keys whose empty object value is authored, not incidental: `context: {}`
+* declares that the machine has context, so dropping it loses information.
+*/
+const KEEP_WHEN_EMPTY = new Set(["context"]);
 function simplifyAttributes(obj) {
 	for (const key of Object.keys(obj)) {
 		const value = obj[key];
 		if (value === void 0 || value === null) delete obj[key];
+		else if (KEEP_WHEN_EMPTY.has(key)) continue;
 		else if (Array.isArray(value)) {
 			if (value.length === 0) delete obj[key];
 			else if (value.length === 1) obj[key] = value[0];
@@ -3535,7 +3540,7 @@ function deepSimplify(config) {
 	return config;
 }
 function buildMeta(meta, color) {
-	if (isCodeExpression$3(meta)) return meta;
+	if (isCodeExpression$4(meta)) return meta;
 	const result = {};
 	if (meta) {
 		for (const [k, v] of Object.entries(meta)) if (v !== void 0 && v !== null) result[k] = v;
@@ -3543,7 +3548,7 @@ function buildMeta(meta, color) {
 	if (color) result["@statelyai.color"] = color;
 	return Object.keys(result).length > 0 ? result : void 0;
 }
-function isCodeExpression$3(value) {
+function isCodeExpression$4(value) {
 	return Boolean(value && typeof value === "object" && !Array.isArray(value) && value["@type"] === "code" && typeof value.expr === "string");
 }
 /** Format event param — supports { type: string } (new) and plain string (legacy) */
@@ -3554,7 +3559,7 @@ function formatEventParam(event) {
 }
 function formatStringParam(value) {
 	if (typeof value === "string") return `'${value}'`;
-	return isCodeExpression$3(value) ? serializeJS(value) : "undefined";
+	return isCodeExpression$4(value) ? serializeJS(value) : "undefined";
 }
 function formatInlineObject(value) {
 	return `{ ${Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => `${formatObjectKey(key)}: ${serializeJS(item)}`).join(", ")} }`;
@@ -3589,7 +3594,11 @@ const builtInActionParamSchemas = {
 	}),
 	"xstate.stopChild": object({ actorRef: string().optional() }),
 	"xstate.log": object({ label: string().optional() }),
-	"xstate.assign": object({ assignment: record(string(), unknown()).optional() }).catchall(unknown())
+	"xstate.assign": object({ assignment: record(string(), unknown()).optional() }).catchall(unknown()),
+	"xstate.choose": object({ branches: array(object({
+		guard: unknown().optional(),
+		actions: array(unknown()).optional()
+	})).optional() })
 };
 const XSTATE_BUILT_IN_ACTIONS = {
 	"xstate.enqueue": {
@@ -3685,6 +3694,16 @@ const XSTATE_BUILT_IN_ACTIONS = {
 			return `log(${(params?.label ? `'${params.label}'` : void 0) ?? ""})`;
 		}
 	},
+	"xstate.choose": {
+		package: "xstate",
+		version: "^5",
+		import: "enqueueActions",
+		importKind: "named",
+		paramsSchema: builtInActionParamSchemas["xstate.choose"],
+		emit(params) {
+			return emitChooseBranches(params?.branches ?? []);
+		}
+	},
 	"xstate.assign": {
 		package: "xstate",
 		version: "^5",
@@ -3692,7 +3711,7 @@ const XSTATE_BUILT_IN_ACTIONS = {
 		importKind: "named",
 		paramsSchema: builtInActionParamSchemas["xstate.assign"],
 		emit(params) {
-			if (isCodeExpression$3(params?.assignment)) return `assign(${serializeJS(params.assignment)})`;
+			if (isCodeExpression$4(params?.assignment)) return `assign(${serializeJS(params.assignment)})`;
 			const assignments = params?.assignment && typeof params.assignment === "object" && !Array.isArray(params.assignment) ? params.assignment : params;
 			const entries = Object.entries(assignments ?? {}).filter(([k, v]) => k && v !== void 0);
 			if (entries.length === 0) return "assign({})";
@@ -3703,6 +3722,35 @@ const XSTATE_BUILT_IN_ACTIONS = {
 function isBuiltInActionType(type) {
 	return type in XSTATE_BUILT_IN_ACTIONS;
 }
+/** Lower `xstate.choose` branches to an `enqueueActions` if/else-if chain. */
+function emitChooseBranches(branches) {
+	const lines = [];
+	const indent = (depth) => "  ".repeat(depth);
+	const serializeEnqueued = (action, depth) => {
+		if (action && typeof action === "object" && !Array.isArray(action) && Object.keys(action).length === 1 && typeof action.type === "string") return serializeJS(action.type);
+		return serializeJS(action, depth * 2);
+	};
+	const body = (actions, depth) => (actions ?? []).map((action) => `${indent(depth)}enqueue(${serializeEnqueued(action, depth)});`);
+	let closed = false;
+	let opened = false;
+	for (const branch of branches) {
+		if (closed) break;
+		if (branch.guard === void 0) {
+			if (opened) {
+				lines.push(`  } else {`);
+				lines.push(...body(branch.actions, 2));
+				lines.push("  }");
+			} else lines.push(...body(branch.actions, 1));
+			closed = true;
+			continue;
+		}
+		lines.push(`  ${opened ? "} else if" : "if"} (check(${serializeJS(branch.guard)})) {`);
+		lines.push(...body(branch.actions, 2));
+		opened = true;
+	}
+	if (opened && !closed) lines.push("  }");
+	return `enqueueActions(({ check, enqueue }) => {\n${lines.join("\n")}\n})`;
+}
 function emitBuiltInAction(type, params) {
 	return XSTATE_BUILT_IN_ACTIONS[type].emit(params);
 }
@@ -3743,8 +3791,12 @@ function serializeGuard(guard, asTypeRef) {
 * Converts a built-in xstate ActionItem to a code expression directive,
 * or returns a plain { type, params } object for user-defined actions.
 */
-function serializeActionItem(action) {
+function serializeActionItem(action, keepChooseStructured = false) {
 	const { type, params } = action;
+	if (keepChooseStructured && type === "xstate.choose") return {
+		type,
+		params
+	};
 	if (type === "xstate.enqueue" && typeof params?.code === "string") return inlineCodeExpression$1(params.code);
 	const exprCode = type === "xstate.expr" && typeof params?.code === "string" ? params.code : void 0;
 	if (isBuiltInActionType(type)) {
@@ -3770,7 +3822,8 @@ function tagToString(tag) {
 }
 function graphToMachineConfig(graph, options = {}) {
 	const v6 = isXStateV6Profile(graph.data.profile);
-	const { showDescriptions = true, showMeta = true, inlineGuardsAsTypeRef = false } = options;
+	const { showDescriptions = true, showMeta = true, inlineGuardsAsTypeRef = false, keepChooseStructured = false } = options;
+	const serializeAction = (action) => serializeActionItem(action, keepChooseStructured);
 	const config = {};
 	function getNodeConfig(node) {
 		const nodeConfig = node.parentId ? {} : config;
@@ -3790,11 +3843,11 @@ function graphToMachineConfig(graph, options = {}) {
 				target: initialNode.data.key,
 				input: node.data.initialInput
 			} : initialNode.data.key : void 0,
-			target: nodeType === "history" && initialNode ? initialNode.data.key : void 0,
+			target: nodeType === "history" && initialNode ? resolveTransitionTarget(graph, node, initialNode) : void 0,
 			...node.data.timeout !== void 0 ? { timeout: node.data.timeout } : void 0,
 			...node.data.route !== void 0 ? { route: node.data.route } : void 0,
-			...node.data.entry?.length ? { entry: node.data.entry.map(serializeActionItem) } : void 0,
-			...node.data.exit?.length ? { exit: node.data.exit.map(serializeActionItem) } : void 0,
+			...node.data.entry?.length ? { entry: node.data.entry.map(serializeAction) } : void 0,
+			...node.data.exit?.length ? { exit: node.data.exit.map(serializeAction) } : void 0,
 			...node.data.invokes?.length ? { invoke: node.data.invokes.map((inv) => ({
 				src: inv.srcExpression ?? inv.src,
 				id: inv.invocationId ?? inv.id,
@@ -3833,7 +3886,7 @@ function graphToMachineConfig(graph, options = {}) {
 					guard: edge.data.guard ? serializeGuard(edge.data.guard, inlineGuardsAsTypeRef) : void 0,
 					...edge.data.context !== void 0 ? { context: edge.data.context } : void 0,
 					...edge.data.input !== void 0 ? { input: edge.data.input } : void 0,
-					actions: edge.data.actions?.length ? edge.data.actions.map(serializeActionItem) : void 0,
+					actions: edge.data.actions?.length ? edge.data.actions.map(serializeAction) : void 0,
 					description: edge.data.description ?? void 0,
 					...transitionMeta ? { meta: transitionMeta } : void 0
 				};
@@ -4212,7 +4265,8 @@ function isShadowedWithinExpression(node, expression) {
 	}
 	return false;
 }
-function replacementText(node, expression) {
+function replacementText(node, expression, nested = true) {
+	if (!nested) return expression;
 	if (ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node) return `${node.text}: (${expression})`;
 	return `(${expression})`;
 }
@@ -4254,7 +4308,7 @@ function resolvedExpressionText(expression, bindings, resolving = /* @__PURE__ *
 				replacements.push({
 					start: node.getStart(source) - start,
 					end: node.getEnd() - start,
-					text: replacementText(node, resolvedExpressionText(binding, bindings, nextResolving))
+					text: replacementText(node, resolvedExpressionText(binding, bindings, nextResolving), node !== expression)
 				});
 				return;
 			}
@@ -4359,6 +4413,15 @@ function schemasObjectToValue(node) {
 }
 function propertyContext(parent, key) {
 	const inherited = parent.imports ? { imports: parent.imports } : {};
+	if (parent.statesMap) return {
+		...inherited,
+		v6: parent.v6
+	};
+	if (key === "states") return {
+		...inherited,
+		v6: parent.v6,
+		statesMap: true
+	};
 	if (parent.machineValue && (key === "actors" || key === "actorSources")) return {
 		...inherited,
 		v6: parent.v6,
@@ -4497,9 +4560,40 @@ function hashString(value) {
 function inlineGuardCode(params, condition) {
 	return `${params} => ${condition.trimStart().startsWith("{") ? `(${condition})` : condition}`;
 }
+function namedReferenceName(node, objectName) {
+	if (!node) return null;
+	const target = unwrapExpression(node);
+	if (ts.isElementAccessExpression(target) && ts.isIdentifier(target.expression) && target.expression.text === objectName && ts.isStringLiteralLike(target.argumentExpression)) return target.argumentExpression.text;
+	if (ts.isPropertyAccessExpression(target) && ts.isIdentifier(target.expression) && target.expression.text === objectName) return target.name.text;
+	return null;
+}
+function namedReferenceParams(node, bindings) {
+	if (!node) return {};
+	const target = unwrapExpression(node);
+	if (!ts.isObjectLiteralExpression(target) && !ts.isArrayLiteralExpression(target)) return {};
+	const value = expressionToValue(target, bindings, { effectArgumentValue: true }, 0);
+	return value && typeof value === "object" ? value : {};
+}
+function namedGuardFromCondition(text) {
+	const [statement] = ts.createSourceFile("guard.ts", text, ts.ScriptTarget.Latest, true).statements;
+	if (!statement || !ts.isExpressionStatement(statement)) return void 0;
+	const call = unwrapExpression(statement.expression);
+	if (!ts.isCallExpression(call)) return void 0;
+	const name = namedReferenceName(call.expression, "guards");
+	if (!name) return void 0;
+	return {
+		type: name,
+		params: namedReferenceParams(call.arguments[1], /* @__PURE__ */ new Map())
+	};
+}
 function guardFromConditions(conds, params) {
 	const simplified = simplifyConditions(conds);
 	if (simplified.length === 0) return void 0;
+	const only = simplified.length === 1 ? simplified[0] : void 0;
+	if (only) {
+		const named = namedGuardFromCondition(conditionText(only));
+		if (named) return named;
+	}
 	const code = inlineGuardCode(params, simplified.map(conditionText).join(" && "));
 	return {
 		type: `inline:${hashString(code)}`,
@@ -4599,13 +4693,20 @@ function expressionStatementAction(statement, enqName, bindings) {
 	const expression = unwrapExpression(statement.expression);
 	if (!ts.isCallExpression(expression)) return null;
 	const callee = expression.expression;
-	if (ts.isIdentifier(callee) && callee.text === enqName) return {
-		type: "xstate.expr",
-		params: {
-			code: resolvedExpressionText(expression, bindings),
-			lang: "ts"
-		}
-	};
+	if (ts.isIdentifier(callee) && callee.text === enqName) {
+		const actionName = namedReferenceName(expression.arguments[0], "actions");
+		if (actionName) return {
+			type: actionName,
+			params: namedReferenceParams(expression.arguments[1], bindings)
+		};
+		return {
+			type: "xstate.expr",
+			params: {
+				code: resolvedExpressionText(expression, bindings),
+				lang: "ts"
+			}
+		};
+	}
 	if (!ts.isPropertyAccessExpression(callee)) return null;
 	if (!ts.isIdentifier(callee.expression) || callee.expression.text !== enqName) return null;
 	const method = callee.name.text;
@@ -4813,6 +4914,79 @@ function normalizeFunctionTransition(fn, bindings, depth) {
 	if (transitions.length > 1) return transitions;
 	return fallbackFunctionTransition(fn);
 }
+/**
+* XState v5 has no `choose()`, so `xstate.choose` is exported as the canonical
+* `enqueueActions(({ check, enqueue }) => { if (check(g)) { enqueue(a); } ... })`
+* if/else-if chain. Read exactly that shape back into structured branches so
+* the action round-trips; anything else stays an opaque inline action.
+*/
+function chooseActionFromEnqueueActions(node, bindings) {
+	if (!ts.isIdentifier(node.expression) || node.expression.text !== "enqueueActions" || node.arguments.length !== 1) return null;
+	const fn = unwrapExpression(node.arguments[0]);
+	if (!ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn)) return null;
+	if (fn.parameters.length !== 1) return null;
+	const pattern = fn.parameters[0].name;
+	if (!ts.isObjectBindingPattern(pattern)) return null;
+	const bound = /* @__PURE__ */ new Map();
+	for (const element of pattern.elements) {
+		if (element.dotDotDotToken || !ts.isIdentifier(element.name)) return null;
+		const key = element.propertyName ? propName(element.propertyName) : element.name.text;
+		if (!key) return null;
+		bound.set(key, element.name.text);
+	}
+	const checkName = bound.get("check");
+	const enqueueName = bound.get("enqueue");
+	if (!checkName || !enqueueName || bound.size !== 2) return null;
+	const body = fn.body;
+	if (!body || !ts.isBlock(body)) return null;
+	const enqueuedAction = (statement) => {
+		if (!ts.isExpressionStatement(statement)) return null;
+		const call = unwrapExpression(statement.expression);
+		if (!ts.isCallExpression(call) || !ts.isIdentifier(call.expression) || call.expression.text !== enqueueName || call.arguments.length !== 1) return null;
+		const value = expressionToValue(call.arguments[0], bindings, { effectArgumentValue: true }, 0);
+		return typeof value === "string" ? { type: value } : value;
+	};
+	const blockActions = (statements) => {
+		const actions = [];
+		for (const statement of statements) {
+			const action = enqueuedAction(statement);
+			if (action === null) return null;
+			actions.push(action);
+		}
+		return actions;
+	};
+	const branches = [];
+	const readChain = (statement) => {
+		const condition = unwrapExpression(statement.expression);
+		if (!ts.isCallExpression(condition) || !ts.isIdentifier(condition.expression) || condition.expression.text !== checkName || condition.arguments.length !== 1) return false;
+		if (!ts.isBlock(statement.thenStatement)) return false;
+		const actions = blockActions(statement.thenStatement.statements);
+		if (!actions) return false;
+		branches.push({
+			guard: expressionToValue(condition.arguments[0], bindings, { effectArgumentValue: true }, 0),
+			actions
+		});
+		const alternate = statement.elseStatement;
+		if (!alternate) return true;
+		if (ts.isIfStatement(alternate)) return readChain(alternate);
+		if (!ts.isBlock(alternate)) return false;
+		const elseActions = blockActions(alternate.statements);
+		if (!elseActions) return false;
+		branches.push({ actions: elseActions });
+		return true;
+	};
+	if (body.statements.length === 1 && ts.isIfStatement(body.statements[0])) {
+		if (!readChain(body.statements[0])) return null;
+	} else {
+		const actions = blockActions(body.statements);
+		if (!actions || actions.length === 0) return null;
+		branches.push({ actions });
+	}
+	return {
+		type: "xstate.choose",
+		params: { branches }
+	};
+}
 function inlineAction(fn) {
 	return {
 		type: "xstate.expr",
@@ -4859,7 +5033,34 @@ function codeImportsForExpression(expression, imports) {
 	visit(file);
 	return found.size ? [...found.values()] : void 0;
 }
-function normalizeFunctionAction(fn, _bindings) {
+/**
+* `entry: ({ actions }, enq) => { enq(actions['NAME'], params); ... }` is the
+* shape the exporter writes for a plain list of *named* actions, so it is
+* decomposed back into those actions instead of surviving as one opaque
+* `xstate.enqueue` code action. Direct `enq.raise(...)` / `enq(() => ...)`
+* bodies are deliberately left alone: they are authored code, not a list.
+*/
+function enqueuedNamedActions(fn, bindings) {
+	const body = fn.body;
+	if (!body || !ts.isBlock(body) || body.statements.length === 0) return null;
+	const enqName = enqueueParamName(fn);
+	const actions = [];
+	for (const statement of body.statements) {
+		if (!ts.isExpressionStatement(statement)) return null;
+		const expression = unwrapExpression(statement.expression);
+		if (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || expression.expression.text !== enqName) return null;
+		const name = namedReferenceName(expression.arguments[0], "actions");
+		if (!name) return null;
+		actions.push({
+			type: name,
+			params: namedReferenceParams(expression.arguments[1], bindings)
+		});
+	}
+	return actions;
+}
+function normalizeFunctionAction(fn, bindings) {
+	const actions = enqueuedNamedActions(fn, bindings);
+	if (actions) return actions.length === 1 ? actions[0] : actions;
 	return enqueueAction(fn);
 }
 function objectLiteralToValue(node, bindings, context, depth, overrides = /* @__PURE__ */ new Map()) {
@@ -4934,6 +5135,7 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 	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.isArrayLiteralExpression(node) && node.elements.length > 0 && node.elements.every((element) => ts.isStringLiteral(element) || ts.isNoSubstitutionTemplateLiteral(element))) return node.elements.map((element) => element.text);
 		if (ts.isIdentifier(node)) {
 			const binding = bindings.get(node.text);
 			if (binding && !ts.isFunctionDeclaration(binding)) return expressionToValue(binding, bindings, context, depth + 1);
@@ -4956,11 +5158,11 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 		return inlineCodeExpression(node.getText());
 	}
 	if (context.timeoutValue && (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isCallExpression(node))) return inlineCodeExpression(node.getText());
-	if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return context.ioValue ? inlineCodeExpression(JSON.stringify(node.text)) : node.text;
-	if (ts.isNumericLiteral(node)) return context.ioValue ? inlineCodeExpression(node.text) : Number(node.text);
-	if (node.kind === ts.SyntaxKind.TrueKeyword) return context.ioValue ? inlineCodeExpression("true") : true;
-	if (node.kind === ts.SyntaxKind.FalseKeyword) return context.ioValue ? inlineCodeExpression("false") : false;
-	if (node.kind === ts.SyntaxKind.NullKeyword) return context.ioValue ? inlineCodeExpression("null") : null;
+	if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+	if (ts.isNumericLiteral(node)) return Number(node.text);
+	if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+	if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+	if (node.kind === ts.SyntaxKind.NullKeyword) return null;
 	if (context.effectArgumentValue && !ts.isObjectLiteralExpression(node) && !ts.isArrayLiteralExpression(node)) {
 		if (ts.isIdentifier(node) && node.text === "undefined") return void 0;
 		return inlineCodeExpression(resolvedExpressionText(node, bindings));
@@ -5020,7 +5222,11 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 			const configArg = node.arguments.length > 1 ? node.arguments[1] : node.arguments[0];
 			return configArg ? expressionToValue(configArg, bindings, { v6: context.v6 }, depth + 1) : {};
 		}
-		if (context.actionValue) return inlineAction(node);
+		if (context.actionValue) {
+			const choose = chooseActionFromEnqueueActions(node, bindings);
+			if (choose) return choose;
+			return inlineAction(node);
+		}
 		const callee = node.expression.getText();
 		const type = callee.includes(".") ? callee.split(".").pop() : callee;
 		return { type: type === "assign" ? "xstate.assign" : type };
@@ -5118,16 +5324,53 @@ function hasV6Syntax(source) {
 			if (!binding) return false;
 			return containsFunction(binding, new Set([...seenBindings, node.text]));
 		}
-		if (ts.isObjectLiteralExpression(node)) return node.properties.some((property) => {
-			if (ts.isPropertyAssignment(property)) return containsFunction(property.initializer, seenBindings);
-			if (ts.isShorthandPropertyAssignment(property)) return containsFunction(property.name, seenBindings);
-			if (ts.isSpreadAssignment(property)) return containsFunction(property.expression, seenBindings);
-			return false;
-		});
 		if (ts.isArrayLiteralExpression(node)) return node.elements.some((element) => ts.isExpression(element) && containsFunction(element, seenBindings));
 		if (ts.isCallExpression(node)) return ts.isIdentifier(node.expression) && containsFunction(node.expression, seenBindings) || node.arguments.some((argument) => ts.isExpression(argument) && containsFunction(argument, seenBindings));
 		return false;
 	}
+	function containsEnqueueAction(expression, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(expression)) return false;
+		seen.add(expression);
+		const node = ts.isFunctionDeclaration(expression) ? expression : unwrapExpression(expression);
+		if (ts.isIdentifier(node)) {
+			const binding = bindings.get(node.text);
+			return binding ? containsEnqueueAction(binding, seen) : false;
+		}
+		if (ts.isArrayLiteralExpression(node)) return node.elements.some((element) => ts.isSpreadElement(element) ? containsEnqueueAction(element.expression, seen) : ts.isExpression(element) && containsEnqueueAction(element, seen));
+		if (!isFunctionBinding(node)) return false;
+		const enqueue = node.parameters[1]?.name;
+		if (!enqueue || !ts.isIdentifier(enqueue) || !node.body) return false;
+		const enqueueName = enqueue.text;
+		let callsEnqueue = false;
+		function visit(node) {
+			if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) return;
+			if (ts.isCallExpression(node)) {
+				const callee = node.expression;
+				const receiver = ts.isPropertyAccessExpression(callee) ? callee.expression : callee;
+				if (ts.isIdentifier(receiver) && receiver.text === enqueueName) callsEnqueue = true;
+			}
+			ts.forEachChild(node, visit);
+		}
+		visit(node.body);
+		return callsEnqueue;
+	}
+	function containsFunctionTransitionMap(expression, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(expression) || ts.isFunctionDeclaration(expression)) return false;
+		seen.add(expression);
+		const node = unwrapExpression(expression);
+		if (ts.isIdentifier(node)) {
+			const binding = bindings.get(node.text);
+			return binding ? containsFunctionTransitionMap(binding, seen) : false;
+		}
+		if (!ts.isObjectLiteralExpression(node)) return false;
+		return node.properties.some((property) => {
+			if (ts.isMethodDeclaration(property)) return true;
+			if (ts.isPropertyAssignment(property)) return containsFunction(property.initializer);
+			if (ts.isShorthandPropertyAssignment(property)) return containsFunction(property.name);
+			if (ts.isSpreadAssignment(property)) return containsFunctionTransitionMap(property.expression, seen);
+			return false;
+		});
+	}
 	function visitSyntax(node) {
 		if (found) return;
 		if (ts.isIdentifier(node)) {
@@ -5144,7 +5387,24 @@ function hasV6Syntax(source) {
 				found = true;
 				return;
 			}
-			if ((key === "on" || key === "after" || key === "always" || key === "choice" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout" || key === "entry" || key === "exit" || key === "actions" && !ts.isObjectLiteralExpression(node.initializer)) && containsFunction(node.initializer)) {
+			if ([
+				"entry",
+				"exit",
+				"actions"
+			].includes(key) && containsEnqueueAction(node.initializer)) {
+				found = true;
+				return;
+			}
+			if ((key === "on" || key === "after") && containsFunctionTransitionMap(node.initializer)) {
+				found = true;
+				return;
+			}
+			if ([
+				"always",
+				"onDone",
+				"onError",
+				"onSnapshot"
+			].includes(key) && containsFunction(node.initializer)) {
 				found = true;
 				return;
 			}
@@ -5499,7 +5759,7 @@ function graphToXStateTS(graph, options = {}) {
 	const inferredXStateVersion = isXStateV6ProfileRef(graph.data.profile ?? "xstate-v5") ? 6 : 5;
 	const { exportStyle = "named", targetLanguage = "typescript", xstateVersion = inferredXStateVersion, xstateV6SchemaFormat = "types", ...configOptions } = options;
 	const schemas = graph.data.schemas;
-	const impls = filterInlineImplementations(graph.data.implementations);
+	const impls = filterInlineImplementations$1(graph.data.implementations);
 	const supportsTypeSyntax = targetLanguage === "typescript";
 	const hasSchemas = !!(schemas && (schemas.context || schemas.events || schemas.input || schemas.output));
 	const hasStateSchemas = graph.nodes.some((node) => node.data.schemas);
@@ -5511,8 +5771,8 @@ function graphToXStateTS(graph, options = {}) {
 	const builtInActions = getUsedBuiltInActions(graph, xstateVersion);
 	const actorSourceImports = getActorSourceImports(graph);
 	const implementationImports = getImplementationImports(impls);
-	const codeImports = getCodeExpressionImports(graph);
-	const imports = buildImports({
+	const codeImports = getCodeExpressionImports$1(graph);
+	const imports = buildImports$1({
 		hasSetup,
 		hasActors,
 		actors: impls?.actors ?? [],
@@ -5524,7 +5784,10 @@ function graphToXStateTS(graph, options = {}) {
 		usesTypes: xstateVersion === 6 && supportsTypeSyntax && (hasSchemas || hasStateSchemas) && xstateV6SchemaFormat === "types",
 		usesZod: xstateVersion === 6 && (hasSchemas || hasStateSchemas) && xstateV6SchemaFormat === "zod"
 	});
-	const machineConfig = xstateVersion === 6 ? toV6MachineConfig(graphToMachineConfig(graph, configOptions)) : toV5MachineConfig(graphToMachineConfig(graph, configOptions));
+	const machineConfig = xstateVersion === 6 ? toV6MachineConfig(graphToMachineConfig(graph, {
+		...configOptions,
+		keepChooseStructured: true
+	})) : toV5MachineConfig(graphToMachineConfig(graph, configOptions));
 	if (xstateVersion === 6) stripStateSchemas(machineConfig);
 	let machineExpr;
 	if (hasSetup) {
@@ -5601,7 +5864,7 @@ function buildV6StateSchemasBlock(schemas, options) {
 	}
 	return Object.keys(result).length ? result : void 0;
 }
-function filterInlineImplementations(impls) {
+function filterInlineImplementations$1(impls) {
 	if (!impls) return impls;
 	return {
 		...impls,
@@ -5619,7 +5882,8 @@ const BUILTIN_ACTION_IMPORTS = {
 	"xstate.spawnChild": "spawnChild",
 	"xstate.stopChild": "stopChild",
 	"xstate.log": "log",
-	"xstate.assign": "assign"
+	"xstate.assign": "assign",
+	"xstate.choose": "enqueueActions"
 };
 /** Check inline action/entry/exit code for references to xstate builtins */
 function scanInlineCodeForBuiltins(code, used) {
@@ -5661,6 +5925,10 @@ function mapV6MachineConfig(value, context = {}) {
 	if (!value || typeof value !== "object") return value;
 	const result = {};
 	for (const [key, item] of Object.entries(value)) {
+		if (key === "states") {
+			result[key] = mapV6StatesMap(item);
+			continue;
+		}
 		if (key === "entry" || key === "exit" || key === "actions") {
 			result[key] = toV6ActionField(Array.isArray(item) ? item : item === void 0 ? [] : [item]);
 			continue;
@@ -5677,6 +5945,13 @@ function mapV6MachineConfig(value, context = {}) {
 	}
 	return result;
 }
+/** Walks a `states` map, treating every entry as a state node. */
+function mapV6StatesMap(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	const result = {};
+	for (const [key, item] of Object.entries(value)) result[key] = mapV6MachineConfig(item);
+	return result;
+}
 function mapV6TransitionMap(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
 	const result = {};
@@ -5863,6 +6138,7 @@ function buildV6TransitionFunction(transitions) {
 		});
 	}
 	if (branches.length === 0) return;
+	if (branches.slice(0, -1).some((branch) => branch.condition === "true")) return;
 	const generated = branches.flatMap((branch) => [branch.condition, ...branch.body]).join("\n");
 	let renderedBranches = branches;
 	let merged = mergeV6FirstParam(authoredFirstParam, inferV6ArgBindings(generated));
@@ -5904,19 +6180,21 @@ function buildV6ActionFunction(actions, transition) {
 	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};`;
+	const trimmed = statement.trim();
+	return trimmed.endsWith("{") || trimmed.startsWith("}") || trimmed.endsWith(";") ? statement : `${statement};`;
 }
 function renderV6Effects(effects, finalContext) {
-	if (!(finalContext !== void 0 || effects.some((effect) => effect.contextValue))) return { statements: effects.flatMap((effect) => effect.statements ?? []) };
+	if (!(finalContext !== void 0 || effects.some((effect) => effect.contextValue || effect.mutatesContext))) return { statements: effects.flatMap((effect) => effect.statements ?? []) };
 	const statements = ["let nextContext = context"];
-	const inCurrentContext = (statement) => {
-		statements.push("{", "  const context = nextContext", `  ${statement}`, "}");
+	const inCurrentContext = (body) => {
+		if (body.length === 0) return;
+		statements.push("{", "  const context = nextContext", ...body.map((line) => `  ${line}`), "}");
 	};
 	for (const effect of effects) {
-		for (const statement of effect.statements ?? []) inCurrentContext(statement);
-		if (effect.contextValue) inCurrentContext(`nextContext = { ...nextContext, ...(${effect.contextValue}) }`);
+		inCurrentContext(effect.statements ?? []);
+		if (effect.contextValue) inCurrentContext([`nextContext = { ...nextContext, ...(${effect.contextValue}) }`]);
 	}
-	if (finalContext !== void 0) inCurrentContext(`nextContext = { ...nextContext, ...(${finalContext}) }`);
+	if (finalContext !== void 0) inCurrentContext([`nextContext = { ...nextContext, ...(${finalContext}) }`]);
 	return {
 		statements,
 		contextValue: "nextContext"
@@ -5946,6 +6224,10 @@ function mapMachineActionFields(value, mapActions) {
 	if (!value || typeof value !== "object") return value;
 	const result = {};
 	for (const [key, item] of Object.entries(value)) {
+		if (key === "states" && item && typeof item === "object" && !Array.isArray(item)) {
+			result[key] = Object.fromEntries(Object.entries(item).map(([stateKey, state]) => [stateKey, mapMachineActionFields(state, mapActions)]));
+			continue;
+		}
 		if (key === "entry" || key === "exit" || key === "actions") {
 			const wasArray = Array.isArray(item);
 			result[key] = mapActions(wasArray ? item : item === void 0 ? [] : [item], wasArray);
@@ -5984,6 +6266,7 @@ function actionToV6Effect(action) {
 	const type = record.type;
 	if (typeof type !== "string") return null;
 	const params = record.params && typeof record.params === "object" && !Array.isArray(record.params) ? record.params : {};
+	const rawParams = record.params;
 	if (type === "xstate.raise") {
 		const options = actionOptions(params, ["event"]);
 		return { statements: [`enq.raise(${serializeJS(params.event)}${options})`] };
@@ -6000,8 +6283,49 @@ 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") 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)}` : ""})`] };
+	if (type === "xstate.choose") {
+		const branches = Array.isArray(params.branches) ? params.branches : [];
+		const statements = [];
+		let mutatesContext = false;
+		let opened = false;
+		for (const raw of branches) {
+			if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+			const branch = raw;
+			const effects = (Array.isArray(branch.actions) ? branch.actions : []).map(actionToV6Effect);
+			if (effects.some((effect) => !effect)) return null;
+			const body = effects.flatMap((effect) => {
+				const lines = [...effect.statements ?? []];
+				if (effect.mutatesContext) mutatesContext = true;
+				if (effect.contextValue) {
+					mutatesContext = true;
+					lines.push(`nextContext = { ...nextContext, ...(${effect.contextValue}) }`);
+				}
+				return lines;
+			});
+			if (branch.guard === void 0) {
+				if (opened) {
+					statements.push("} else {");
+					statements.push(...body.map((line) => `  ${line}`));
+					statements.push("}");
+				} else statements.push(...body);
+				opened = false;
+				break;
+			}
+			const guard = guardCondition(typeof branch.guard === "string" ? { type: branch.guard } : branch.guard);
+			if (!guard) return null;
+			statements.push(`${opened ? "} else if" : "if"} (${guard.condition}) {`);
+			statements.push(...body.map((line) => `  ${line}`));
+			opened = true;
+		}
+		if (opened) statements.push("}");
+		if (statements.length === 0) return null;
+		return mutatesContext ? {
+			statements,
+			mutatesContext
+		} : { statements };
+	}
+	if (type === "xstate.assign") return { contextValue: serializeJS(unwrapTemplateExpressions(params.assignment ?? params)) };
+	if (!type.startsWith("xstate.")) return { statements: [`enq(${/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(type) ? `actions.${type}` : `actions[${serializeJS(type)}]`}${(Array.isArray(rawParams) ? rawParams.length > 0 : Object.keys(params).length > 0) ? `, ${serializeJS(rawParams)}` : ""})`] };
 	return null;
 }
 function getV6AssignmentArgs(code, includeAll = false) {
@@ -6061,7 +6385,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, codeImports, xstateVersion, usesTypes, usesZod }) {
+function buildImports$1({ hasSetup, hasActors, actors, builtInActions, actorSourceImports, implementationImports, codeImports, xstateVersion, usesTypes, usesZod }) {
 	const xstateImports = [];
 	if (hasSetup) xstateImports.push("setup");
 	else xstateImports.push("createMachine");
@@ -6089,7 +6413,7 @@ function buildImports({ hasSetup, hasActors, actors, builtInActions, actorSource
 	if (usesZod && !externalImports.get("zod")?.has("z")) imports.push("import { z } from 'zod';");
 	return imports.join("\n");
 }
-function getCodeExpressionImports(graph) {
+function getCodeExpressionImports$1(graph) {
 	const imports = /* @__PURE__ */ new Map();
 	function visit(value) {
 		if (!value || typeof value !== "object") return;
@@ -6238,7 +6562,7 @@ function hasSchemaProperties(schema) {
 function buildActionsBlock(actions, options) {
 	const block = {};
 	for (const implementation of actions) if (implementation.code?.body) {
-		const inlineExpression = getInlineExpression(implementation.code.body);
+		const inlineExpression = getInlineExpression$1(implementation.code.body);
 		if (inlineExpression) {
 			block[implementation.name] = raw(inlineExpression);
 			continue;
@@ -6251,7 +6575,7 @@ function buildActionsBlock(actions, options) {
 function buildGuardsBlock(guards, options) {
 	const block = {};
 	for (const guard of guards) if (guard.code?.body) {
-		const inlineExpression = getInlineExpression(guard.code.body);
+		const inlineExpression = getInlineExpression$1(guard.code.body);
 		if (inlineExpression) {
 			block[guard.name] = raw(inlineExpression);
 			continue;
@@ -6289,7 +6613,7 @@ function getActorLogicExpression(code) {
 function buildDelaysBlock(delays) {
 	const block = {};
 	for (const delay of delays) if (delay.code?.body) {
-		const inlineExpression = getInlineExpression(delay.code.body);
+		const inlineExpression = getInlineExpression$1(delay.code.body);
 		if (inlineExpression) {
 			block[delay.name] = raw(inlineExpression);
 			continue;
@@ -6312,7 +6636,7 @@ function buildDelaysBlock(delays) {
 *    on import) → the expression itself.
 * Returns undefined for a plain statement body, which still needs wrapping.
 */
-function getInlineExpression(code) {
+function getInlineExpression$1(code) {
 	const stripped = stripExportDefault(code);
 	if (stripped !== code.trim()) return stripped;
 	return isCompleteFunctionExpression(stripped) || isCompleteXStateHelperExpression(stripped) ? stripped : void 0;
@@ -6348,6 +6672,624 @@ function isCompleteFunctionExpression(code) {
 	if (!expression) return false;
 	return ts.isFunctionExpression(expression) || ts.isArrowFunction(expression);
 }
+/**
+* Escapes text that is interpolated into a `/* ... *\/` marker so it cannot
+* close the comment early.
+*/
+function escapeMarkerText(text) {
+	return text.replace(/\*\//g, "*\\/");
+}
+/** Builds a `TODO: v5-only` block comment around untrusted text. */
+function v5OnlyMarker(detail) {
+	return `/* TODO: v5-only (${escapeMarkerText(detail)}); no XState v4 equivalent */`;
+}
+/**
+* Emits XState **v4** (deprecated) TypeScript for a graph.
+*
+* The v4 surface differs from v5 in ways this emitter downgrades:
+* `createMachine(config, options)` instead of `setup().createMachine()`,
+* `cond` instead of `guard`, `services` instead of `actors`, `internal: false`
+* instead of `reenter: true`, `done.invoke.X` / `error.platform.X` /
+* `done.state.X` event names, and positional `(context, event)` implementation
+* arguments (enabled by `predictableActionArguments`).
+*
+* Concepts with no v4 equivalent (`emit`, `spawnChild`, `enqueueActions`,
+* actor-logic creators such as `fromPromise`) are emitted verbatim with a
+* `// TODO: v5-only` marker rather than silently dropped.
+*/
+function graphToXStateV4TS(graph, options = {}) {
+	const { exportStyle = "named", targetLanguage = "typescript", ...configOptions } = options;
+	const supportsTypeSyntax = targetLanguage === "typescript";
+	const schemas = graph.data.schemas;
+	const impls = filterInlineImplementations(graph.data.implementations);
+	const rawConfig = graphToMachineConfig(graph, configOptions);
+	const services = {};
+	const config = transformState(rawConfig, { services });
+	const machineConfig = {};
+	if (config.id !== void 0) machineConfig.id = config.id;
+	machineConfig.predictableActionArguments = true;
+	machineConfig.preserveActionOrder = true;
+	const schemaBlock = supportsTypeSyntax ? buildSchemaBlock(schemas) : void 0;
+	if (schemaBlock) machineConfig.schema = schemaBlock;
+	for (const [key, value] of Object.entries(config)) {
+		if (key === "id") continue;
+		machineConfig[key] = value;
+	}
+	const machineOptions = buildMachineOptions(impls, services);
+	const configStr = serializeJS(machineConfig, 0);
+	const optionsStr = Object.keys(machineOptions).length ? serializeJS(machineOptions, 0) : void 0;
+	const machineExpr = optionsStr ? `createMachine(${configStr}, ${optionsStr})` : `createMachine(${configStr})`;
+	const lines = [
+		buildImports(machineExpr, getCodeExpressionImports(graph)),
+		"",
+		`const machine = ${machineExpr};`
+	];
+	if (exportStyle === "named") lines.push("", "export { machine };");
+	else if (exportStyle === "default") lines.push("", "export default machine;");
+	return lines.join("\n") + "\n";
+}
+/** Keys emitted by the shared config builder that v4 has no place for. */
+const DROPPED_STATE_KEYS = new Set([
+	"schemas",
+	"timeout",
+	"route",
+	"onTimeout",
+	"onSnapshot",
+	"version",
+	"options"
+]);
+function transformState(state, ctx, sourceKey) {
+	const result = {};
+	let choiceBranches;
+	for (const [key, value] of Object.entries(state)) {
+		if (value === void 0 || DROPPED_STATE_KEYS.has(key)) continue;
+		switch (key) {
+			case "type":
+				if (value !== "choice") result.type = value;
+				break;
+			case "choice":
+				choiceBranches = transformTransitionValue(value, sourceKey);
+				break;
+			case "initial":
+				result.initial = value && typeof value === "object" && !Array.isArray(value) ? value.target : value;
+				break;
+			case "output":
+				result.data = transformCodeValues(value);
+				break;
+			case "entry":
+			case "exit":
+				result[key] = transformActions(value);
+				break;
+			case "invoke":
+				result.invoke = transformInvoke(value, ctx, sourceKey);
+				break;
+			case "on":
+			case "after":
+				result[key] = transformTransitionMap(value, key === "on", sourceKey);
+				break;
+			case "always":
+			case "onDone":
+			case "onError":
+				result[key] = transformTransitionValue(value, sourceKey);
+				break;
+			case "states": {
+				const states = value;
+				result.states = Object.fromEntries(Object.entries(states).map(([stateKey, child]) => [stateKey, transformState(child, ctx, stateKey)]));
+				break;
+			}
+			default: result[key] = value;
+		}
+	}
+	if (choiceBranches !== void 0) {
+		const existing = result.always === void 0 ? [] : Array.isArray(result.always) ? result.always : [result.always];
+		const branches = Array.isArray(choiceBranches) ? choiceBranches : [choiceBranches];
+		result.always = [...existing, ...branches];
+	}
+	return result;
+}
+/** Rewrites embedded code expressions of a plain data value for v4. */
+function transformCodeValues(value) {
+	if (isCodeExpression$3(value)) return raw(toV4Code(value.expr));
+	if (Array.isArray(value)) return value.map(transformCodeValues);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, transformCodeValues(item)]));
+	return value;
+}
+/** v5 event names → their v4 spellings. */
+function toV4EventName(eventName) {
+	if (eventName.startsWith("xstate.done.actor.")) return `done.invoke.${eventName.slice(18)}`;
+	if (eventName.startsWith("xstate.error.actor.")) return `error.platform.${eventName.slice(19)}`;
+	if (eventName.startsWith("xstate.done.state.")) return `done.state.${eventName.slice(18)}`;
+	return eventName;
+}
+function transformTransitionMap(value, renameEvents, sourceKey) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => [renameEvents ? toV4EventName(key) : key, transformTransitionValue(item, sourceKey)]));
+}
+/**
+* True when a resolved v4 target points at the source state itself or one of
+* its descendants — the only targets for which `internal` changes behaviour.
+* Targets resolve against the source's parent, so a descendant of the source
+* is spelled `<sourceKey>.<child>` (or `.<child>` for root transitions).
+*/
+function targetsSelfOrDescendant(target, sourceKey) {
+	if (typeof target !== "string" || !target) return false;
+	if (sourceKey === void 0) return target.startsWith(".");
+	return target === sourceKey || target.startsWith(`${sourceKey}.`);
+}
+/** Renders a v6 `matches` guard as readable text for the TODO marker. */
+function describeMatches(matches) {
+	if (typeof matches === "string") return matches;
+	if (isCodeExpression$3(matches)) return matches.expr;
+	try {
+		return serializeJS(matches, 0).replace(/\s+/g, " ");
+	} catch {
+		return String(matches);
+	}
+}
+function transformTransitionValue(value, sourceKey) {
+	if (Array.isArray(value)) return value.map((item) => transformTransitionValue(item, sourceKey));
+	if (!value || typeof value !== "object") return value;
+	if (isCodeExpression$3(value)) return raw(toV4Code(value.expr));
+	const transition = value;
+	const result = {};
+	let reenter;
+	let contextUpdate;
+	let matches;
+	for (const [key, item] of Object.entries(transition)) {
+		if (item === void 0) continue;
+		switch (key) {
+			case "guard":
+				result.cond = transformGuard(item);
+				break;
+			case "reenter":
+				reenter = item;
+				break;
+			case "actions":
+				result.actions = transformActions(item);
+				break;
+			case "context":
+				contextUpdate = item;
+				break;
+			case "matches":
+				matches = item;
+				break;
+			case "input": break;
+			default: result[key] = item;
+		}
+	}
+	if (reenter === true) result.internal = false;
+	else if (targetsSelfOrDescendant(result.target, sourceKey)) result.internal = true;
+	if (matches !== void 0) {
+		const marker = v5OnlyMarker(`matches guard: ${describeMatches(matches)}`);
+		result.cond = result.cond === void 0 ? raw(`undefined ${marker}`) : raw(`${serializeJS(result.cond, 0)} ${marker}`);
+	}
+	if (contextUpdate !== void 0) {
+		const assignAction = raw(`assign(${serializeJS(transformCodeValues(contextUpdate), 0)})`);
+		result.actions = [...result.actions === void 0 ? [] : Array.isArray(result.actions) ? result.actions : [result.actions], assignAction];
+	}
+	return result;
+}
+/** v4 reads parameters off the action/cond object itself, so they are spread. */
+function toV4ParameterizedObject(value) {
+	const { type, params } = value;
+	if (typeof type !== "string") return value;
+	if (!params || typeof params !== "object") return type;
+	const v4Params = transformCodeValues(params);
+	const name = "type" in v4Params ? raw(`'${type}' ${v5OnlyMarker(`param named \`type\` collides with the ${JSON.stringify(type)} name`)}`) : type;
+	return {
+		...v4Params,
+		type: name
+	};
+}
+function transformGuard(guard) {
+	if (isCodeExpression$3(guard)) return raw(toV4Code(guard.expr));
+	if (guard && typeof guard === "object" && !Array.isArray(guard)) return toV4ParameterizedObject(guard);
+	return guard;
+}
+function transformActions(value) {
+	const wasArray = Array.isArray(value);
+	const mapped = (wasArray ? value : [value]).map(transformAction);
+	return wasArray ? mapped : mapped[0];
+}
+function transformAction(action) {
+	if (isCodeExpression$3(action)) return raw(toV4Code(action.expr));
+	if (action && typeof action === "object" && !Array.isArray(action)) return toV4ParameterizedObject(action);
+	return action;
+}
+function transformInvoke(value, ctx, sourceKey) {
+	if (Array.isArray(value)) return value.map((item) => transformInvoke(item, ctx, sourceKey));
+	if (!value || typeof value !== "object") return value;
+	const invoke = value;
+	const result = {};
+	for (const [key, item] of Object.entries(invoke)) {
+		if (item === void 0) continue;
+		switch (key) {
+			case "src":
+				if (isCodeExpression$3(item)) {
+					const name = typeof invoke.id === "string" && invoke.id ? invoke.id : `service${Object.keys(ctx.services).length + 1}`;
+					ctx.services[name] = raw(toV4Code(item.expr));
+					result.src = name;
+				} else result.src = item;
+				break;
+			case "input":
+				result.data = transformCodeValues(item);
+				break;
+			case "onDone":
+			case "onError":
+				result[key] = transformTransitionValue(item, sourceKey);
+				break;
+			case "output":
+			case "timeout":
+			case "registryKey":
+			case "onSnapshot":
+			case "onTimeout": break;
+			default: result[key] = item;
+		}
+	}
+	return result;
+}
+/** v5 helpers that exist in v4 under a different name. */
+const RENAMED_HELPERS = { stopChild: "stop" };
+/**
+* v4 helpers that are not root exports of `xstate@4`; they live on the
+* `actions` namespace export.
+*/
+const V4_ACTIONS_NAMESPACE_HELPERS = ["respond", "escalate"];
+/** v5-only helpers with no v4 equivalent. */
+const V5_ONLY_HELPERS = [
+	"emit",
+	"spawnChild",
+	"enqueueActions",
+	"fromPromise",
+	"fromCallback",
+	"fromObservable",
+	"fromEventObservable",
+	"fromTransition",
+	"createAsyncLogic"
+];
+/**
+* Bindings the emitter re-binds itself, so dropping them from a destructured
+* parameter list is not a loss the user has to act on.
+*/
+const REBOUND_BINDINGS = new Set(["params", "input"]);
+/** Bindings v4 passes positionally, so they survive the rewrite. */
+const V4_BOUND_BINDINGS = new Set(["context", "event"]);
+/**
+* Names that mark a destructured parameter list as a v5 implementation
+* signature rather than an object literal argument.
+*/
+const V5_DESTRUCTURED_BINDINGS = new Set([
+	"context",
+	"event",
+	"params",
+	"input",
+	"self",
+	"system",
+	"enqueue",
+	"spawn",
+	"emit",
+	"check",
+	"signal"
+]);
+/** Parses a snippet permissively so positions can be read off the AST. */
+function parseSnippet(source) {
+	return ts.createSourceFile("snippet.tsx", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+}
+/** True when the snippet parsed without syntax errors. */
+function parsedCleanly(sourceFile) {
+	const diagnostics = sourceFile.parseDiagnostics;
+	return !diagnostics || diagnostics.length === 0;
+}
+/**
+* The positional v4 parameter list for a v5 destructured binding list, or
+* `undefined` when the bindings are not a v5 implementation signature.
+*/
+function v4ParameterList(names) {
+	if (!names.length) return void 0;
+	if (!names.some((name) => V5_DESTRUCTURED_BINDINGS.has(name))) return;
+	if (names.includes("context")) return names.includes("event") ? "context, event" : "context";
+	return names.includes("event") ? "_, event" : "";
+}
+/**
+* Rewrites v5 destructured *parameter* lists (`({ context, event }) => ...`)
+* to positional v4 ones. Only parameter positions of functions and arrows are
+* touched, so a shorthand object *argument* such as `send({ context, event })`
+* is left alone. Bindings v4 cannot supply are collected into `dropped`.
+*/
+function rewriteDestructuredParameters(code, dropped) {
+	const sourceFile = parseSnippet(code);
+	const edits = [];
+	const visit = (node) => {
+		if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) {
+			const [parameter] = node.parameters;
+			if (parameter && node.parameters.length === 1 && !parameter.type && !parameter.initializer && !parameter.dotDotDotToken && ts.isObjectBindingPattern(parameter.name)) {
+				const elements = parameter.name.elements;
+				if (elements.every((element) => !element.propertyName && !element.initializer && !element.dotDotDotToken && ts.isIdentifier(element.name))) {
+					const names = elements.map((element) => element.name.getText());
+					const replacement = v4ParameterList(names);
+					if (replacement !== void 0) {
+						for (const name of names) if (!V4_BOUND_BINDINGS.has(name) && !REBOUND_BINDINGS.has(name)) dropped.add(name);
+						edits.push({
+							start: parameter.getStart(sourceFile),
+							end: parameter.getEnd(),
+							text: replacement
+						});
+					}
+				}
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	ts.forEachChild(sourceFile, visit);
+	let result = code;
+	for (const edit of edits.sort((a, b) => b.start - a.start)) result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+	return result;
+}
+/**
+* Rewrites a v5 implementation expression for v4: positional implementation
+* arguments, renamed helpers, and a marker on anything v4 cannot express.
+*/
+function toV4Code(code) {
+	const dropped = /* @__PURE__ */ new Set();
+	let result = rewriteDestructuredParameters(stripExportDefault(code), dropped);
+	for (const [from, to] of Object.entries(RENAMED_HELPERS)) result = result.replace(new RegExp(`\\b${from}\\(`, "g"), `${to}(`);
+	for (const helper of V4_ACTIONS_NAMESPACE_HELPERS) result = result.replace(new RegExp(`(?<!\\.)\\b${helper}\\(`, "g"), `actions.${helper}(`);
+	const unsupported = [...V5_ONLY_HELPERS.filter((helper) => new RegExp(`\\b${helper}\\s*\\(`).test(result)), ...dropped];
+	if (unsupported.length) result = `${result} ${v5OnlyMarker(unsupported.join(", "))}`;
+	return result;
+}
+/**
+* True when a body is a single expression, so `return` can be prefixed. Parsed
+* as `(body)`: a statement such as `if (x) run()` fails to parse that way, and
+* an object literal such as `{ a: 1 }` parses as an expression rather than a
+* block.
+*/
+function isBareExpression(body) {
+	const trimmed = body.trim();
+	if (!trimmed) return false;
+	const sourceFile = parseSnippet(`(${trimmed})`);
+	if (!parsedCleanly(sourceFile)) return false;
+	if (sourceFile.statements.length !== 1) return false;
+	const statement = sourceFile.statements[0];
+	return !!statement && ts.isExpressionStatement(statement) && ts.isParenthesizedExpression(statement.expression);
+}
+/** True when an implementation body reads a re-bound v5 binding. */
+function referencesBinding(body, name) {
+	return new RegExp(`\\b${name}\\b`).test(body);
+}
+/**
+* True when `name` is referenced free in a block body: it is read somewhere
+* that no enclosing declaration inside the body binds. Declarations tracked
+* are variable declarations, function/arrow/catch parameters, function and
+* class names, so a nested `(params) => params.id` shadows without suppressing
+* an outer read.
+*/
+function referencesFreeBinding(body, name) {
+	const sourceFile = parseSnippet(body);
+	const scopes = [/* @__PURE__ */ new Set()];
+	let found = false;
+	const declare = (bindingName) => {
+		if (ts.isIdentifier(bindingName)) {
+			scopes[scopes.length - 1]?.add(bindingName.text);
+			return;
+		}
+		for (const element of bindingName.elements) if (ts.isBindingElement(element)) declare(element.name);
+	};
+	const isDeclared = () => scopes.some((scope) => scope.has(name));
+	/** True when an identifier node is a value reference, not a name position. */
+	const isReference = (node) => {
+		const parent = node.parent;
+		if (!parent) return true;
+		if (ts.isPropertyAccessExpression(parent) && parent.name === node) return false;
+		if (ts.isQualifiedName(parent) && parent.right === node) return false;
+		if ((ts.isPropertyAssignment(parent) || ts.isMethodDeclaration(parent) || ts.isPropertyDeclaration(parent) || ts.isEnumMember(parent)) && parent.name === node) return false;
+		if (ts.isBindingElement(parent) && parent.propertyName === node) return false;
+		if (ts.isJsxAttribute(parent) && parent.name === node) return false;
+		if (ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent)) return false;
+		if ((ts.isVariableDeclaration(parent) || ts.isParameter(parent) || ts.isFunctionDeclaration(parent) || ts.isFunctionExpression(parent) || ts.isClassDeclaration(parent) || ts.isClassExpression(parent) || ts.isBindingElement(parent)) && parent.name === node) return false;
+		if (ts.isLabeledStatement(parent) && parent.label === node) return false;
+		return true;
+	};
+	const withScope = (run) => {
+		scopes.push(/* @__PURE__ */ new Set());
+		run();
+		scopes.pop();
+	};
+	const visit = (node) => {
+		if (found) return;
+		if (ts.isIdentifier(node)) {
+			if (node.text === name && isReference(node) && !isDeclared()) found = true;
+			return;
+		}
+		if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node)) {
+			if (ts.isFunctionDeclaration(node) && node.name) declare(node.name);
+			withScope(() => {
+				for (const parameter of node.parameters) declare(parameter.name);
+				if (ts.isFunctionExpression(node) && node.name) declare(node.name);
+				for (const parameter of node.parameters) if (parameter.initializer) visit(parameter.initializer);
+				if (node.body) visit(node.body);
+			});
+			return;
+		}
+		if (ts.isBlock(node) || ts.isCaseBlock(node)) {
+			withScope(() => ts.forEachChild(node, visit));
+			return;
+		}
+		if (ts.isCatchClause(node)) {
+			withScope(() => {
+				if (node.variableDeclaration) declare(node.variableDeclaration.name);
+				visit(node.block);
+			});
+			return;
+		}
+		if (ts.isVariableDeclaration(node)) {
+			if (node.initializer) visit(node.initializer);
+			declare(node.name);
+			return;
+		}
+		if ((ts.isClassDeclaration(node) || ts.isClassExpression(node)) && node.name) declare(node.name);
+		ts.forEachChild(node, visit);
+	};
+	ts.forEachChild(sourceFile, visit);
+	return found;
+}
+/**
+* True when the emitter should re-bind `name` around a block body: the body
+* reads it free and does not declare it itself.
+*/
+function needsRebind(body, name) {
+	return referencesFreeBinding(body, name);
+}
+function filterInlineImplementations(impls) {
+	if (!impls) return impls;
+	return {
+		...impls,
+		actions: impls.actions.filter((action) => !action.name.startsWith("inline:")),
+		guards: impls.guards.filter((guard) => !guard.name.startsWith("inline:")),
+		delays: impls.delays.filter((delay) => !delay.name.startsWith("inline:"))
+	};
+}
+function buildMachineOptions(impls, liftedServices) {
+	const result = {};
+	if (impls?.actions.length) result.actions = Object.fromEntries(impls.actions.map((action) => [action.name, raw(implementationFunction(action, "// TODO: implement"))]));
+	if (impls?.guards.length) result.guards = Object.fromEntries(impls.guards.map((guard) => [guard.name, raw(implementationFunction(guard, "// TODO: implement\n  return false;", "cond"))]));
+	const services = { ...liftedServices };
+	for (const actor of impls?.actors ?? []) services[actor.name] = raw(serviceImplementation(actor));
+	if (Object.keys(services).length) result.services = services;
+	if (impls?.delays.length) result.delays = Object.fromEntries(impls.delays.map((delay) => [delay.name, raw(implementationFunction(delay, "// TODO: implement\n  return 1000;", "delay"))]));
+	return result;
+}
+/**
+* Emits a v4 implementation. v4 calls actions/guards with
+* `(context, event, meta)`, where `meta.action` (actions, delays) and
+* `meta.cond` (guards) carry the action/cond object that parameters were
+* spread onto, so `params` is re-bound from there when the body reads it.
+*/
+function implementationFunction(implementation, todo, kind = "action") {
+	const body = implementation.code?.body;
+	if (!body) return `function (context, event) {\n  ${todo}\n}`;
+	const inline = getInlineExpression(body);
+	const canRebind = kind !== "delay";
+	const metaKey = kind === "cond" ? "cond" : "action";
+	const readsParams = inline ? referencesBinding(body, "params") : needsRebind(body, "params");
+	const usesParams = readsParams && canRebind;
+	const marker = readsParams && !canRebind ? ` ${PARAMS_IN_DELAY_MARKER}` : "";
+	if (inline) {
+		const converted = toV4Code(inline);
+		if (!usesParams) return `${converted}${marker}`;
+		return `function (context, event, meta) {\n  const params = meta.${metaKey};\n  return (${converted})(context, event);\n}`;
+	}
+	const code = toV4Code(dedent(body));
+	const statement = isBareExpression(code) ? `return ${code};` : code;
+	if (!usesParams) return `function (context, event) {\n  ${statement}\n}${marker}`;
+	return `function (context, event, meta) {\n  const params = meta.${metaKey};\n  ${statement}\n}`;
+}
+/** Marks a delay body that reads `params`, which v4 cannot supply. */
+const PARAMS_IN_DELAY_MARKER = "/* TODO: v5-only (params in delay); no XState v4 equivalent */";
+/**
+* Emits a v4 service. v4 invoke creators are called with
+* `(context, event, { data, src, meta })`, so a body reading v5 `input` gets it
+* re-bound from `meta.data` (what `invoke.data` resolves to).
+*/
+function serviceImplementation(actor) {
+	const body = actor.code?.body;
+	if (!body) return `async function (context, event) {\n  // TODO: implement ${actor.name}\n}`;
+	const inline = getInlineExpression(body);
+	const usesInput = inline ? referencesBinding(body, "input") : needsRebind(body, "input");
+	if (inline) {
+		if (!usesInput) return toV4Code(inline);
+		return `async function (context, event, meta) {\n  return (${stripExportDefault(inline)})({ context, event, input: meta.data });\n}`;
+	}
+	const code = toV4Code(dedent(body));
+	const statement = isBareExpression(code) ? `return ${code};` : code;
+	if (!usesInput) return `async function (context, event) {\n  ${statement}\n}`;
+	return `async function (context, event, meta) {\n  const input = meta.data;\n  ${statement}\n}`;
+}
+/** A body that is already a complete expression is emitted verbatim. */
+function getInlineExpression(code) {
+	const stripped = stripExportDefault(code);
+	if (stripped !== code.trim()) return stripped;
+	return /^\s*(async\s+)?(function\b|\(|[A-Za-z_$][\w$]*\s*=>)/.test(stripped) && !/;\s*\n/.test(stripped) ? stripped : void 0;
+}
+function buildSchemaBlock(schemas) {
+	if (!schemas) return void 0;
+	const result = {};
+	const contextType = contextSchemaToTSType(schemas.context);
+	if (contextType) result.context = raw(`{} as ${contextType}`);
+	const eventsType = eventsSchemaToTSType(schemas.events);
+	if (eventsType) result.events = raw(`{} as\n    | ${eventsType}`);
+	return Object.keys(result).length ? result : void 0;
+}
+/** Named exports of `xstate` v4 that generated code may reference. */
+const V4_XSTATE_HELPERS = [
+	"assign",
+	"raise",
+	"send",
+	"sendTo",
+	"sendParent",
+	"sendUpdate",
+	"forwardTo",
+	"log",
+	"cancel",
+	"stop",
+	"choose",
+	"pure",
+	"spawn",
+	"actions",
+	"doneInvoke",
+	"interpret"
+];
+function buildImports(machineExpr, codeImports) {
+	const xstateImports = new Set(["createMachine"]);
+	for (const helper of V4_XSTATE_HELPERS) if (new RegExp(`\\b${helper}\\s*\\(`).test(machineExpr)) xstateImports.add(helper);
+	if (/\bactions\s*\./.test(machineExpr)) xstateImports.add("actions");
+	const externalImports = /* @__PURE__ */ new Map();
+	for (const codeImport of codeImports) {
+		if ((codeImport.importKind ?? "named") !== "named") continue;
+		const specifier = codeImport.local && codeImport.local !== codeImport.import ? `${codeImport.import} as ${codeImport.local}` : codeImport.import;
+		if (codeImport.package === "xstate") {
+			if (V4_ACTIONS_NAMESPACE_HELPERS.includes(codeImport.import)) xstateImports.add("actions");
+			else if (V4_XSTATE_HELPERS.includes(codeImport.import)) xstateImports.add(specifier);
+			continue;
+		}
+		const names = externalImports.get(codeImport.package) ?? /* @__PURE__ */ new Set();
+		names.add(specifier);
+		externalImports.set(codeImport.package, names);
+	}
+	const imports = [`import { ${[...xstateImports].join(", ")} } from 'xstate';`];
+	for (const [packageName, names] of externalImports) imports.push(`import { ${[...names].sort().join(", ")} } from '${packageName}';`);
+	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);
+	}
+	visit(graph);
+	return [...imports.values()];
+}
+function isCodeExpression$3(value) {
+	return !!value && typeof value === "object" && value["@type"] === "code" && typeof value.expr === "string";
+}
 function getXStateFSMCompatibilityIssues(graph) {
 	const root = graph.nodes.find((node) => node.parentId == null);
 	if (!root) return ["missing root state"];
@@ -6636,6 +7578,7 @@ const validationIssueCodeSchema = _enum([
 	"missing_delay_implementation",
 	"invalid_final_transition",
 	"invalid_history_transition",
+	"invalid_choice_event",
 	"parallel_region_transition",
 	"duplicate_source_name",
 	"undefined_action",
@@ -6831,4 +7774,4 @@ function getScriptKind(fileName) {
 }
 
 //#endregion
-export { normalizeMachineProfile as _, RawCode as a, xstateSourceToConfig as b, detectXStateSourceProfile as c, getXStateFSMCompatibilityIssues as d, graphChangeToPatchesResult as f, jsonSchemaToTSType as g, graphToXStateTS as h, INLINE_EXPRESSION_DIRECTIVE_FIELDS as i, diffGraphsSemantically as l, graphToXStateFSM as m, getStatelyPragma as n, alignCompareGraphIds as o, graphToMachineConfig as p, upsertStatelyPragma as r, contextSchemaToTSType as s, findStatelyPragmaAttachments as t, eventsSchemaToTSType as u, raw as v, serializeJS as y };
+export { jsonSchemaToTSType as _, RawCode as a, serializeJS as b, detectXStateSourceProfile as c, getXStateFSMCompatibilityIssues as d, graphChangeToPatchesResult as f, graphToXStateV4TS as g, graphToXStateTS as h, INLINE_EXPRESSION_DIRECTIVE_FIELDS as i, diffGraphsSemantically as l, graphToXStateFSM as m, getStatelyPragma as n, alignCompareGraphIds as o, graphToMachineConfig as p, upsertStatelyPragma as r, contextSchemaToTSType as s, findStatelyPragmaAttachments as t, eventsSchemaToTSType as u, normalizeMachineProfile as v, xstateSourceToConfig as x, raw as y };