@statelyai/sdk 0.29.1 → 0.31.1

package/dist/{statelyPragma-p1vu8PmH.mjs → dist-wbhkeGh6.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
@@ -3166,6 +3167,10 @@ function graphChangeToPatchesResult(prevGraph, nextGraph) {
 		op: "deleteTransition",
 		transitionId: edge.id
 	});
+	if (prevGraph.data.profile !== nextGraph.data.profile) patches.push({
+		op: "setProfile",
+		profile: nextGraph.data.profile ?? "xstate-v5"
+	});
 	if (!isEqual(prevGraph.data.context, nextGraph.data.context)) patches.push({
 		op: "setContext",
 		context: nextGraph.data.context ?? null
@@ -3272,6 +3277,40 @@ function alignCompareGraphIds(base, compare, semanticBase, semanticCompare) {
 	}
 	return aligned;
 }
+const XSTATE_V5_PROFILE = "@statelyai/xstate@5.30.0";
+const XSTATE_V6_PROFILE = "@statelyai/xstate@6.0.0-alpha.51";
+const XSTATE_V6_BRANCH_DESCRIPTION_META = "@statelyai.branchDescription";
+const LEGACY_MACHINE_PROFILES = ["xstate-v5", "xstate-v6-alpha"];
+function normalizeMachineProfile(profile) {
+	return profile === "xstate-v5" ? XSTATE_V5_PROFILE : profile === "xstate-v6-alpha" ? XSTATE_V6_PROFILE : profile;
+}
+function isXStateV6Profile(profile) {
+	return (profile === "xstate-v5" || profile === "xstate-v6-alpha" ? normalizeMachineProfile(profile) : profile ?? XSTATE_V5_PROFILE).startsWith("@statelyai/xstate@6.");
+}
+const EXACT_SEMVER$1 = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function parseProfileSpecifier(specifier) {
+	const separator = specifier.lastIndexOf("@");
+	const name = specifier.slice(0, separator);
+	const version = specifier.slice(separator + 1);
+	if (separator <= 0 || !/^@[^/]+\/[^@/]+$/.test(name) || !version) throw new Error(`Invalid profile specifier: ${specifier}`);
+	return {
+		name,
+		version,
+		kind: EXACT_SEMVER$1.test(version) ? "exact" : "range"
+	};
+}
+function normalizeProfileRef(profile) {
+	return profile === "xstate-v5" || profile === "xstate-v6-alpha" ? normalizeMachineProfile(profile) : profile;
+}
+const AFTER_EVENT_PREFIX = "xstate.after.";
+/** Recovers an authored delay key from an internal after-event type. */
+function getDelayKeyFromEventType(eventType, sourceId) {
+	if (!eventType.startsWith(AFTER_EVENT_PREFIX)) return null;
+	const encoded = eventType.slice(13);
+	const sourceSuffix = sourceId ? `.${sourceId}` : null;
+	if (sourceSuffix && encoded.endsWith(sourceSuffix)) return encoded.slice(0, -sourceSuffix.length);
+	return encoded.split(".")[0] ?? encoded;
+}
 function isAutoGeneratedId(id) {
 	return !!id && id.startsWith("$auto-");
 }
@@ -3387,15 +3426,6 @@ function stripExportDefault(code) {
 	if (trimmed.startsWith("export default ")) return trimmed.slice(15).replace(/;$/, "");
 	return trimmed;
 }
-const XSTATE_V5_PROFILE = "@statelyai/xstate@5.30.0";
-const XSTATE_V6_PROFILE = "@statelyai/xstate@6.0.0-alpha.51";
-const LEGACY_MACHINE_PROFILES = ["xstate-v5", "xstate-v6-alpha"];
-function normalizeMachineProfile(profile) {
-	return profile === "xstate-v5" ? XSTATE_V5_PROFILE : profile === "xstate-v6-alpha" ? XSTATE_V6_PROFILE : profile;
-}
-function isXStateV6Profile(profile) {
-	return (profile === "xstate-v5" || profile === "xstate-v6-alpha" ? normalizeMachineProfile(profile) : profile ?? XSTATE_V5_PROFILE).startsWith("@statelyai/xstate@6.");
-}
 /**
 * Graph-native transition references. Transitions point at invoke/action/state
 * blocks by graph id (`@statelyai.*`); the literal `xstate.*` event is produced
@@ -3491,6 +3521,7 @@ function singleOrArrayRecord(record) {
 * declares that the machine has context, so dropping it loses information.
 */
 const KEEP_WHEN_EMPTY = new Set(["context"]);
+const KEEP_SINGLETON_ARRAY = new Set(["internalEvents", "tags"]);
 function simplifyAttributes(obj) {
 	for (const key of Object.keys(obj)) {
 		const value = obj[key];
@@ -3498,7 +3529,7 @@ function simplifyAttributes(obj) {
 		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];
+			else if (value.length === 1 && !KEEP_SINGLETON_ARRAY.has(key)) obj[key] = value[0];
 		} else if (typeof value === "object" && Object.keys(value).length === 0) delete obj[key];
 		else if (typeof value === "string" && value === "") delete obj[key];
 	}
@@ -3877,11 +3908,15 @@ function graphToMachineConfig(graph, options = {}) {
 			for (const edge of edges) {
 				const targetNode = graph.nodes.find((n) => n.id === edge.targetId);
 				const resolvedTarget = targetNode ? resolveTransitionTarget(graph, node, targetNode) : "";
+				const resolvedTargets = [resolvedTarget, ...(edge.data.additionalTargetIds ?? []).flatMap((targetId) => {
+					const additionalTarget = graph.nodes.find((n) => n.id === targetId);
+					return additionalTarget ? [resolveTransitionTarget(graph, node, additionalTarget)] : [];
+				})].filter(Boolean);
 				const type = edge.data.eventType ?? "";
 				const transitionMeta = showMeta ? buildMeta(edge.data.meta, edge.data.color) : void 0;
 				const transitionObject = {
 					...edge.data.matches ? { matches: edge.data.matches } : void 0,
-					target: edge.data.transitionType === "targetless" ? void 0 : `${resolvedTarget}`,
+					target: edge.data.transitionType === "targetless" ? void 0 : resolvedTargets.length > 1 ? resolvedTargets : `${resolvedTarget}`,
 					...edge.data.transitionType === "reenter" ? { reenter: true } : void 0,
 					guard: edge.data.guard ? serializeGuard(edge.data.guard, inlineGuardsAsTypeRef) : void 0,
 					...edge.data.context !== void 0 ? { context: edge.data.context } : void 0,
@@ -3929,16 +3964,16 @@ function graphToMachineConfig(graph, options = {}) {
 				else if (type === "" && node.data.type === "choice") choiceArr.push(transitionObject);
 				else if (type === "") alwaysArr.push(transitionObject);
 				else if (type.startsWith("xstate.after.")) {
-					const delayKey = type.slice(13).split(".")[0];
+					const delayKey = getDelayKeyFromEventType(type, edge.sourceId);
 					if (!after[delayKey]) after[delayKey] = [];
 					after[delayKey].push(transitionObject);
 				} else if (type === "*") pushOn("*");
 				else if (type.startsWith("xstate.done.state")) {
 					if (!onDone[type]) onDone[type] = [];
 					onDone[type].push(transitionObject);
-				} else if (type.startsWith("xstate.done.actor.") || type.startsWith("xstate.error.actor.") || type.startsWith("xstate.snapshot.actor.")) {
+				} else if (type.startsWith("xstate.done.actor.") || type.startsWith("xstate.error.actor.") || type.startsWith("xstate.snapshot.actor.") || type.startsWith("xstate.snapshot.")) {
 					const verb = type.startsWith("xstate.done.actor.") ? "onDone" : type.startsWith("xstate.error.actor.") ? "onError" : "onSnapshot";
-					const invoke = findInvokeByActorId(node, type.slice(type.lastIndexOf(".actor.") + 7));
+					const invoke = findInvokeByActorId(node, type.startsWith("xstate.snapshot.") ? type.slice(16).replace(/^actor\./, "") : type.slice(type.lastIndexOf(".actor.") + 7));
 					if (invoke) nestInvoke(invoke.id, verb);
 					else pushOn(type);
 				} else pushOn(type);
@@ -3979,6 +4014,7 @@ function graphToMachineConfig(graph, options = {}) {
 	if (graph.data.context !== void 0 && graph.data.context !== null) config.context = graph.data.context;
 	if (graph.data.version) config.version = graph.data.version;
 	if (graph.data.options?.maxIterations !== void 0) config.options = { maxIterations: graph.data.options.maxIterations };
+	if (graph.data.internalEvents?.length) config.internalEvents = graph.data.internalEvents;
 	return deepSimplify(config);
 }
 const INLINE_EXPRESSION_DIRECTIVE_FIELDS = [
@@ -3989,25 +4025,79 @@ const INLINE_EXPRESSION_DIRECTIVE_FIELDS = [
 	"initialInput",
 	"route"
 ];
-const EXACT_SEMVER$1 = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-function parseProfileSpecifier(specifier) {
-	const separator = specifier.lastIndexOf("@");
-	const name = specifier.slice(0, separator);
-	const version = specifier.slice(separator + 1);
-	if (separator <= 0 || !/^@[^/]+\/[^@/]+$/.test(name) || !version) throw new Error(`Invalid profile specifier: ${specifier}`);
-	return {
-		name,
-		version,
-		kind: EXACT_SEMVER$1.test(version) ? "exact" : "range"
-	};
-}
-function normalizeProfileRef(profile) {
-	return profile === "xstate-v5" || profile === "xstate-v6-alpha" ? normalizeMachineProfile(profile) : profile;
-}
+function analyzeXStateV5Compatibility(graph) {
+	const issues = [];
+	const graphPaths = [
+		["data.version", graph.data.version],
+		["data.options", graph.data.options],
+		["data.schemas.input", graph.data.schemas?.input],
+		["data.schemas.output", graph.data.schemas?.output]
+	].filter(([, value]) => value != null);
+	if (graphPaths.length) issues.push({
+		level: "warning",
+		message: "XState v6 machine fields are retained but read-only in XState v5.",
+		readOnlyPaths: graphPaths.map(([path]) => path)
+	});
+	for (const node of graph.nodes) {
+		const paths = [
+			["data.initialInput", node.data.initialInput],
+			["data.timeout", node.data.timeout],
+			["data.route", node.data.route],
+			["data.schemas", node.data.schemas]
+		].filter(([, value]) => value != null);
+		if (paths.length) issues.push({
+			level: "warning",
+			message: `XState v6 fields on ${node.data.key ?? node.id} are retained but read-only in XState v5.`,
+			nodeIds: [node.id],
+			readOnlyPaths: paths.map(([path]) => `nodes.${node.id}.${path}`)
+		});
+	}
+	for (const edge of graph.edges) {
+		const paths = [["data.matches", edge.data.matches], ["data.input", edge.data.input]].filter(([, value]) => value != null);
+		if (paths.length) issues.push({
+			level: "warning",
+			message: "XState v6 transition fields are retained but read-only in XState v5.",
+			edgeIds: [edge.id],
+			readOnlyPaths: paths.map(([path]) => `edges.${edge.id}.${path}`)
+		});
+	}
+	return issues;
+}
+const XSTATE_V5_PROJECTION = {
+	readOnlyPaths: [
+		"data.version",
+		"data.options",
+		"data.schemas.input",
+		"data.schemas.output",
+		"nodes.*.data.initialInput",
+		"nodes.*.data.timeout",
+		"nodes.*.data.route",
+		"nodes.*.data.schemas",
+		"edges.*.data.matches",
+		"edges.*.data.input"
+	],
+	analyzeCompatibility: analyzeXStateV5Compatibility
+};
+const XSTATE_V6_PROJECTION = {};
+/**
+* Derive LangGraph authoring kinds into its namespace. Canonical fields and
+* graph topology are never returned, so the adapter cannot rewrite them.
+*/
+const LANGGRAPH_PROJECTION = { adapt: (graph) => ({ data: {
+	nodes: Object.fromEntries(graph.nodes.map((node) => [node.id, { kind: node.data.type === "final" ? "end" : node.data.kind === "agent" || node.data.kind === "task" || node.data.kind === "entrypoint" ? node.data.kind : "node" }])),
+	edges: Object.fromEntries(graph.edges.map((edge) => {
+		const source = graph.nodes.find((node) => node.id === edge.sourceId);
+		return [edge.id, { kind: edge.data.kind === "call" ? "call" : edge.data.kind === "conditional" || edge.data.guard != null || source?.data.type === "choice" ? "conditional" : "edge" }];
+	}))
+} }) };
 /** Stately's semantic projection of the LangGraph 1.x APIs across runtimes. */
 const LANGGRAPH_PROFILE = "@statelyai/langgraph@1.0.0";
 const LANGGRAPH_PROFILE_MANIFEST = {
 	profile: LANGGRAPH_PROFILE,
+	namespace: "@statelyai.langgraph",
+	lineage: "@statelyai/langgraph",
+	projection: LANGGRAPH_PROJECTION,
+	selectable: false,
 	name: "LangGraph",
 	description: "LangGraph 1.x graph semantics for Python and JavaScript/TypeScript source.",
 	restrictFormatsToListed: true,
@@ -4188,6 +4278,9 @@ const XSTATE_AUTHORING = {
 };
 const XSTATE_PROFILE_MANIFESTS = [{
 	profile: XSTATE_V5_PROFILE,
+	namespace: "@statelyai.xstate",
+	lineage: "@statelyai/xstate",
+	projection: XSTATE_V5_PROJECTION,
 	name: "XState v5",
 	formats: [...XSTATE_FORMATS],
 	authoring: XSTATE_AUTHORING,
@@ -4198,7 +4291,10 @@ const XSTATE_PROFILE_MANIFESTS = [{
 	}
 }, {
 	profile: XSTATE_V6_PROFILE,
-	name: "XState v6",
+	namespace: "@statelyai.xstate",
+	lineage: "@statelyai/xstate",
+	projection: XSTATE_V6_PROJECTION,
+	name: "XState v6 alpha",
 	formats: [...XSTATE_FORMATS],
 	authoring: XSTATE_AUTHORING,
 	operations: {
@@ -4320,31 +4416,32 @@ function resolvedExpressionText(expression, bindings, resolving = /* @__PURE__ *
 	for (const replacement of replacements.sort((a, b) => b.start - a.start)) result = result.slice(0, replacement.start) + replacement.text + result.slice(replacement.end);
 	return result;
 }
-function typeNodeToJsonSchema(node) {
-	if (ts.isParenthesizedTypeNode(node)) return typeNodeToJsonSchema(node.type);
+function typeNodeToJsonSchema(node, bindings = /* @__PURE__ */ new Map(), resolving = /* @__PURE__ */ new Set()) {
+	if (ts.isParenthesizedTypeNode(node)) return typeNodeToJsonSchema(node.type, bindings, resolving);
 	if (ts.isLiteralTypeNode(node)) {
 		const literal = node.literal;
 		if (ts.isStringLiteral(literal) || ts.isNumericLiteral(literal)) return { const: ts.isNumericLiteral(literal) ? Number(literal.text) : literal.text };
 		if (literal.kind === ts.SyntaxKind.TrueKeyword) return { const: true };
 		if (literal.kind === ts.SyntaxKind.FalseKeyword) return { const: false };
+		if (literal.kind === ts.SyntaxKind.NullKeyword) return { type: "null" };
 		return null;
 	}
 	if (ts.isUnionTypeNode(node)) {
-		const members = node.types.map(typeNodeToJsonSchema);
+		const members = node.types.map((member) => typeNodeToJsonSchema(member, bindings, resolving));
 		if (members.some((member) => !member)) return null;
 		const constants = members.map((member) => member?.const);
 		if (constants.every((value) => value !== void 0)) return { enum: constants };
 		return { anyOf: members };
 	}
 	if (ts.isArrayTypeNode(node)) {
-		const items = typeNodeToJsonSchema(node.elementType);
+		const items = typeNodeToJsonSchema(node.elementType, bindings, resolving);
 		return items ? {
 			type: "array",
 			items
 		} : null;
 	}
 	if (ts.isTupleTypeNode(node)) {
-		const items = node.elements.map((element) => typeNodeToJsonSchema(element));
+		const items = node.elements.map((element) => typeNodeToJsonSchema(element, bindings, resolving));
 		if (items.some((item) => !item)) return null;
 		return {
 			type: "array",
@@ -4359,7 +4456,7 @@ function typeNodeToJsonSchema(node) {
 		for (const member of node.members) {
 			if (!ts.isPropertySignature(member) || !member.type || !member.name) return null;
 			const name = propName(member.name);
-			const schema = typeNodeToJsonSchema(member.type);
+			const schema = typeNodeToJsonSchema(member.type, bindings, resolving);
 			if (!name || !schema) return null;
 			properties[name] = schema;
 			if (!member.questionToken) required.push(name);
@@ -4372,21 +4469,77 @@ function typeNodeToJsonSchema(node) {
 		};
 	}
 	switch (node.kind) {
+		case ts.SyntaxKind.VoidKeyword: return {
+			type: "object",
+			properties: {},
+			required: []
+		};
 		case ts.SyntaxKind.StringKeyword: return { type: "string" };
 		case ts.SyntaxKind.NumberKeyword: return { type: "number" };
 		case ts.SyntaxKind.BooleanKeyword: return { type: "boolean" };
 		case ts.SyntaxKind.NullKeyword: return { type: "null" };
+		case ts.SyntaxKind.VoidKeyword: return {
+			type: "object",
+			properties: {},
+			required: [],
+			additionalProperties: false
+		};
 		case ts.SyntaxKind.UnknownKeyword:
 		case ts.SyntaxKind.AnyKeyword: return {};
-		default: return null;
+		default: break;
+	}
+	if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) {
+		const name = node.typeName.text;
+		if (name === "Array" && node.typeArguments?.length === 1) {
+			const items = typeNodeToJsonSchema(node.typeArguments[0], bindings, resolving);
+			return items ? {
+				type: "array",
+				items
+			} : null;
+		}
+		const binding = bindings.get(name);
+		if (!binding || resolving.has(name)) return null;
+		const nextResolving = new Set(resolving).add(name);
+		if (ts.isTypeAliasDeclaration(binding)) return typeNodeToJsonSchema(binding.type, bindings, nextResolving);
+		const properties = {};
+		const required = /* @__PURE__ */ new Set();
+		for (const heritageClause of binding.heritageClauses ?? []) {
+			if (heritageClause.token !== ts.SyntaxKind.ExtendsKeyword) return null;
+			for (const heritage of heritageClause.types) {
+				if (!ts.isIdentifier(heritage.expression) || (heritage.typeArguments?.length ?? 0) > 0) return null;
+				const baseName = heritage.expression.text;
+				const baseBinding = bindings.get(baseName);
+				if (!baseBinding || !ts.isInterfaceDeclaration(baseBinding)) return null;
+				const baseSchema = typeNodeToJsonSchema(ts.factory.createTypeReferenceNode(heritage.expression, heritage.typeArguments), bindings, nextResolving);
+				if (!baseSchema || baseSchema.type !== "object" || !baseSchema.properties) return null;
+				Object.assign(properties, baseSchema.properties);
+				for (const name of baseSchema.required ?? []) required.add(name);
+			}
+		}
+		for (const member of binding.members) {
+			if (!ts.isPropertySignature(member) || !member.type || !member.name) return null;
+			const propertyName = propName(member.name);
+			const schema = typeNodeToJsonSchema(member.type, bindings, nextResolving);
+			if (!propertyName || !schema) return null;
+			properties[propertyName] = schema;
+			if (member.questionToken) required.delete(propertyName);
+			else required.add(propertyName);
+		}
+		return {
+			type: "object",
+			properties,
+			...required.size ? { required: [...required] } : void 0,
+			additionalProperties: false
+		};
 	}
+	return null;
 }
-function typesCallSchema(node) {
+function typesCallSchema(node, bindings) {
 	const value = unwrapExpression(node);
 	if (!ts.isCallExpression(value) || value.expression.getText() !== "types" || value.typeArguments?.length !== 1) return null;
-	return typeNodeToJsonSchema(value.typeArguments[0]);
+	return typeNodeToJsonSchema(value.typeArguments[0], bindings);
 }
-function schemasObjectToValue(node) {
+function schemasObjectToValue(node, bindings) {
 	const value = unwrapExpression(node);
 	if (!ts.isObjectLiteralExpression(value)) return null;
 	const result = {};
@@ -4394,25 +4547,46 @@ function schemasObjectToValue(node) {
 		if (!ts.isPropertyAssignment(property)) continue;
 		const key = propName(property.name);
 		if (!key) continue;
-		if (key === "events" && ts.isObjectLiteralExpression(property.initializer)) {
+		if ([
+			"events",
+			"internalEvents",
+			"emitted",
+			"children"
+		].includes(key) && ts.isObjectLiteralExpression(property.initializer)) {
 			const events = {};
 			for (const eventProperty of property.initializer.properties) {
 				if (!ts.isPropertyAssignment(eventProperty)) continue;
 				const eventType = propName(eventProperty.name);
-				const schema = typesCallSchema(eventProperty.initializer);
+				const schema = typesCallSchema(eventProperty.initializer, bindings);
 				if (eventType && schema) events[eventType] = schema;
 			}
-			result.events = events;
+			result[key] = events;
 			continue;
 		}
-		const schema = typesCallSchema(property.initializer);
+		if (["actions", "guards"].includes(key) && ts.isObjectLiteralExpression(property.initializer)) {
+			const implementations = {};
+			for (const implementation of property.initializer.properties) {
+				if (!ts.isPropertyAssignment(implementation)) continue;
+				const name = propName(implementation.name);
+				if (!name || !ts.isObjectLiteralExpression(implementation.initializer)) continue;
+				const params = implementation.initializer.properties.find((candidate) => ts.isPropertyAssignment(candidate) && propName(candidate.name) === "params");
+				const schema = params ? typesCallSchema(params.initializer, bindings) : null;
+				implementations[name] = schema ? { params: schema } : {};
+			}
+			result[key] = implementations;
+			continue;
+		}
+		const schema = typesCallSchema(property.initializer, bindings);
 		if (!schema) continue;
 		result[key] = key === "context" ? schema.properties ?? {} : schema;
 	}
 	return result;
 }
 function propertyContext(parent, key) {
-	const inherited = parent.imports ? { imports: parent.imports } : {};
+	const inherited = {
+		...parent.imports ? { imports: parent.imports } : {},
+		...parent.typeBindings ? { typeBindings: parent.typeBindings } : {}
+	};
 	if (parent.statesMap) return {
 		...inherited,
 		v6: parent.v6
@@ -4422,12 +4596,17 @@ function propertyContext(parent, key) {
 		v6: parent.v6,
 		statesMap: true
 	};
+	if (key === "schemas") return {
+		...inherited,
+		v6: parent.v6,
+		schemasValue: true
+	};
 	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 {
+	if (parent.setupValue && (key === "actions" || key === "guards" || key === "actors" || key === "actorSources" || key === "delays")) return {
 		...inherited,
 		v6: parent.v6,
 		implementationMap: true
@@ -4685,6 +4864,10 @@ function mergeBranchPrefix(prefix, branch) {
 	return {
 		conds: [...prefix.conds, ...branch.conds],
 		actions: [...prefix.actions, ...branch.actions],
+		...prefix.contextUpdates || branch.contextUpdates ? { contextUpdates: {
+			...prefix.contextUpdates,
+			...branch.contextUpdates
+		} } : {},
 		result: branch.result,
 		unknown: prefix.unknown || branch.unknown
 	};
@@ -4765,6 +4948,31 @@ function expressionStatementAction(statement, enqName, bindings) {
 		}
 	};
 }
+/**
+* The v6 exporter uses a local accumulator when a transition has multiple
+* context updates or queued effects. Recover the partial context update from
+* that canonical form so import -> graph -> export remains targetable.
+*/
+function generatedContextUpdate(statement, bindings) {
+	const expression = unwrapExpression(statement.expression);
+	if (!ts.isBinaryExpression(expression) || expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !ts.isIdentifier(expression.left) || expression.left.text !== "nextContext") return;
+	const right = unwrapExpression(expression.right);
+	if (!ts.isObjectLiteralExpression(right)) return null;
+	const updates = {};
+	for (const property of right.properties) {
+		if (!ts.isSpreadAssignment(property)) return null;
+		const spread = unwrapExpression(property.expression);
+		if (ts.isIdentifier(spread) && spread.text === "nextContext") continue;
+		if (!ts.isObjectLiteralExpression(spread)) return null;
+		const value = objectLiteralToValue(spread, bindings, {
+			v6: true,
+			assignmentMap: true
+		}, 0);
+		if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+		Object.assign(updates, value);
+	}
+	return updates;
+}
 function statementBranches(statements, bindings, enqName, prefixes = [{
 	conds: [],
 	actions: []
@@ -4780,6 +4988,12 @@ function statementBranches(statements, bindings, enqName, prefixes = [{
 				nextOpen.push(prefix);
 				continue;
 			}
+			if (ts.isBlock(statement)) {
+				const nestedBranches = statementBranches(statement.statements, scopedBindings, enqName, [prefix]);
+				for (const branch of nestedBranches) if ("result" in branch) done.push(branch);
+				else nextOpen.push(branch);
+				continue;
+			}
 			if (ts.isReturnStatement(statement)) {
 				if (!statement.expression) {
 					done.push({
@@ -4792,6 +5006,21 @@ function statementBranches(statements, bindings, enqName, prefixes = [{
 				continue;
 			}
 			if (ts.isExpressionStatement(statement)) {
+				const contextUpdate = generatedContextUpdate(statement, scopedBindings);
+				if (contextUpdate !== void 0) {
+					if (contextUpdate === null) nextOpen.push({
+						...prefix,
+						unknown: true
+					});
+					else nextOpen.push({
+						...prefix,
+						contextUpdates: {
+							...prefix.contextUpdates,
+							...contextUpdate
+						}
+					});
+					continue;
+				}
 				const action = expressionStatementAction(statement, enqName, scopedBindings);
 				if (action) {
 					nextOpen.push({
@@ -4895,15 +5124,34 @@ function normalizeFunctionTransition(fn, bindings, depth) {
 	if (branches.some((branch) => branch.unknown)) return fallbackFunctionTransition(fn);
 	const contextIdentity = transitionContextIdentity(fn);
 	const transitions = branches.map((branch) => {
-		const transition = transitionFromValue(branch.result, branch.actions);
+		let result = branch.result;
+		if (branch.contextUpdates && result && typeof result === "object" && !Array.isArray(result)) {
+			const record = result;
+			const context = record.context;
+			const contextRecord = context && typeof context === "object" && !Array.isArray(context) ? context : null;
+			if (contextRecord?.["@type"] === "code" && contextRecord.expr === "nextContext") result = {
+				...record,
+				context: branch.contextUpdates
+			};
+		}
+		const transition = transitionFromValue(result, branch.actions);
 		if (!transition) return null;
+		const matches = matchesFromConditions(branch.conds);
 		if (typeof transition === "string") {
+			if (matches) return {
+				target: transition,
+				matches
+			};
 			const guard = guardFromConditions(branch.conds, guardParams(fn));
 			return guard ? {
 				target: transition,
 				guard
 			} : transition;
 		}
+		if (matches) return omitIdentityTransitionContext({
+			...transition,
+			matches
+		}, contextIdentity);
 		const guard = guardFromConditions(branch.conds, guardParams(fn));
 		return omitIdentityTransitionContext(guard ? {
 			...transition,
@@ -4914,6 +5162,26 @@ function normalizeFunctionTransition(fn, bindings, depth) {
 	if (transitions.length > 1) return transitions;
 	return fallbackFunctionTransition(fn);
 }
+function matchesFromConditions(conditions) {
+	const positives = conditions.filter((condition) => !condition.negated);
+	if (positives.length !== 1) return null;
+	const match = positives[0].text.match(/^Object\.is\(event\[['"]([^'"]+)['"]\],\s*(.+)\)$/);
+	if (!match) return null;
+	const [, key, rawValue] = match;
+	if (!key || !rawValue) return null;
+	for (const condition of conditions) {
+		if (!condition.negated) continue;
+		const negative = condition.text.match(/^Object\.is\(event\[['"]([^'"]+)['"]\],\s*(.+)\)$/);
+		if (!negative || negative[1] !== key) return null;
+	}
+	const value = rawValue.trim();
+	if (value.startsWith("'") && value.endsWith("'") || value.startsWith("\"") && value.endsWith("\"")) return { [key]: value.slice(1, -1) };
+	if (value === "true") return { [key]: true };
+	if (value === "false") return { [key]: false };
+	if (value === "null") return { [key]: null };
+	const number = Number(value);
+	return Number.isNaN(number) ? null : { [key]: number };
+}
 /**
 * XState v5 has no `choose()`, so `xstate.choose` is exported as the canonical
 * `enqueueActions(({ check, enqueue }) => { if (check(g)) { enqueue(a); } ... })`
@@ -4996,15 +5264,6 @@ function inlineAction(fn) {
 		}
 	};
 }
-function enqueueAction(fn) {
-	return {
-		type: "xstate.enqueue",
-		params: {
-			code: fn.getText(),
-			lang: "ts"
-		}
-	};
-}
 function inlineCodeExpression(expr, imports) {
 	return {
 		"@type": "code",
@@ -5037,8 +5296,8 @@ function codeImportsForExpression(expression, imports) {
 * `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.
+* inline code action. Direct `enq.raise(...)` / `enq(() => ...)` bodies are
+* authored code and remain one inline action.
 */
 function enqueuedNamedActions(fn, bindings) {
 	const body = fn.body;
@@ -5061,7 +5320,7 @@ function enqueuedNamedActions(fn, bindings) {
 function normalizeFunctionAction(fn, bindings) {
 	const actions = enqueuedNamedActions(fn, bindings);
 	if (actions) return actions.length === 1 ? actions[0] : actions;
-	return enqueueAction(fn);
+	return inlineAction(fn);
 }
 function objectLiteralToValue(node, bindings, context, depth, overrides = /* @__PURE__ */ new Map()) {
 	const result = {};
@@ -5079,7 +5338,7 @@ function objectLiteralToValue(node, bindings, context, depth, overrides = /* @__
 			continue;
 		}
 		if (context.v6 && key === "schemas" && ts.isPropertyAssignment(property)) {
-			const schemas = schemasObjectToValue(property.initializer);
+			const schemas = schemasObjectToValue(property.initializer, context.typeBindings ?? /* @__PURE__ */ new Map());
 			if (schemas) {
 				result[key] = schemas;
 				continue;
@@ -5132,6 +5391,14 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 		}
 		return inlineCodeExpression(node.getText(), codeImportsForExpression(node.getText(), context.imports));
 	}
+	if (context.schemasValue) {
+		if (ts.isIdentifier(node)) {
+			const binding = bindings.get(node.text);
+			if (binding && !ts.isFunctionDeclaration(binding)) return expressionToValue(binding, bindings, context, depth + 1);
+		}
+		const schemas = schemasObjectToValue(node, context.typeBindings ?? /* @__PURE__ */ new Map());
+		if (schemas) return schemas;
+	}
 	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;
@@ -5260,6 +5527,12 @@ function collectBindings(file) {
 	}
 	return bindings;
 }
+function collectSchemaTypeBindings(file) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of file.statements) if (ts.isTypeAliasDeclaration(statement) && statement.name) bindings.set(statement.name.text, statement);
+	else if (ts.isInterfaceDeclaration(statement) && statement.name) bindings.set(statement.name.text, statement);
+	return bindings;
+}
 function collectSourceImports(file) {
 	const imports = /* @__PURE__ */ new Map();
 	for (const statement of file.statements) {
@@ -5362,10 +5635,15 @@ function hasV6Syntax(source) {
 			const binding = bindings.get(node.text);
 			return binding ? containsFunctionTransitionMap(binding, seen) : false;
 		}
-		if (!ts.isObjectLiteralExpression(node)) return false;
+		if (ts.isArrayLiteralExpression(node)) return node.elements.some((element) => ts.isExpression(element) && containsFunctionTransitionMap(element, seen));
+		if (!ts.isObjectLiteralExpression(node)) return containsFunction(node);
 		return node.properties.some((property) => {
 			if (ts.isMethodDeclaration(property)) return true;
-			if (ts.isPropertyAssignment(property)) return containsFunction(property.initializer);
+			if (ts.isPropertyAssignment(property)) {
+				const key = propName(property.name);
+				if (key === "guard" || key === "cond" || key === "actions") return false;
+				return containsFunctionTransitionMap(property.initializer, seen);
+			}
 			if (ts.isShorthandPropertyAssignment(property)) return containsFunction(property.name);
 			if (ts.isSpreadAssignment(property)) return containsFunctionTransitionMap(property.expression, seen);
 			return false;
@@ -5431,11 +5709,6 @@ function hasV6Syntax(source) {
 function detectXStateSourceProfile(source) {
 	return hasV6Syntax(source) ? "xstate-v6-alpha" : "xstate-v5";
 }
-function xstateSourceToConfig(source, options = {}) {
-	const [config] = extractXStateMachineConfigs(source, options);
-	if (!config) throw new Error("No createMachine(...), createFSM(...), or setup factory call found.");
-	return config;
-}
 /**
 * Extract every XState machine config from source without executing code.
 * XState 5/6 syntax is inferred structurally unless a profile is supplied.
@@ -5444,6 +5717,7 @@ function extractXStateMachineConfigEntries(source, options = {}) {
 	const file = sourceFile(source);
 	const bindings = collectBindings(file);
 	const imports = collectSourceImports(file);
+	const typeBindings = collectSchemaTypeBindings(file);
 	const found = [];
 	let machineIndex = 0;
 	const profile = options.profile === "auto" || !options.profile ? detectXStateSourceProfile(source) : options.profile;
@@ -5525,14 +5799,16 @@ function extractXStateMachineConfigEntries(source, options = {}) {
 		const value = expressionToValue(arg, bindings, {
 			v6: profile === "xstate-v6-alpha",
 			machineValue: true,
-			imports
+			imports,
+			typeBindings
 		});
 		if (value && typeof value === "object" && !Array.isArray(value)) {
 			const { states: setupStates, ...setupWithoutStates } = setupConfigExpressionsForCreateMachine(node, bindings).reduce((merged, setupArg) => {
 				const setupValue = expressionToValue(setupArg, bindings, {
 					v6: profile === "xstate-v6-alpha",
 					setupValue: true,
-					imports
+					imports,
+					typeBindings
 				});
 				if (!isRecordValue(setupValue)) return merged;
 				return mergeSetupRecords(merged, setupValue);
@@ -5551,9 +5827,6 @@ function extractXStateMachineConfigEntries(source, options = {}) {
 	visit(file);
 	return found;
 }
-function extractXStateMachineConfigs(source, options = {}) {
-	return extractXStateMachineConfigEntries(source, options).map(({ config }) => config);
-}
 function jsonSchemaToTSType(schema) {
 	if (!schema) return "unknown";
 	if (schema.enum) return schema.enum.map((v) => typeof v === "string" ? `'${v}'` : String(v)).join(" | ");
@@ -5674,11 +5947,12 @@ function eventSchemaToZod(schema) {
 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]) => {
+	const shape = Object.fromEntries(Object.entries(properties).map(([key, definition]) => {
 		return [key, raw(`${definitionToZod(definition)}${isRequiredProperty(key, definition, required) ? "" : ".optional()"}`)];
-	})))})`;
+	}));
+	let result = `z.object(${serializeJS(shape)})`;
 	if (schema.additionalProperties === false) result += ".strict()";
-	else if (schema.additionalProperties === true || schema.additionalProperties === void 0) result += ".passthrough()";
+	else if (schema.additionalProperties === true || schema.additionalProperties === void 0) result = `z.looseObject(${serializeJS(shape)})`;
 	else if (schema.additionalProperties) result += `.catchall(${jsonSchemaToZod(schema.additionalProperties)})`;
 	return result;
 }
@@ -5761,7 +6035,7 @@ function graphToXStateTS(graph, options = {}) {
 	const schemas = graph.data.schemas;
 	const impls = filterInlineImplementations$1(graph.data.implementations);
 	const supportsTypeSyntax = targetLanguage === "typescript";
-	const hasSchemas = !!(schemas && (schemas.context || schemas.events || schemas.input || schemas.output));
+	const hasSchemas = !!(schemas && (schemas.context || schemas.events || schemas.internalEvents || schemas.emitted || schemas.actions || schemas.guards || schemas.children || schemas.input || schemas.output || schemas.tags || schemas.meta));
 	const hasStateSchemas = graph.nodes.some((node) => node.data.schemas);
 	const hasActions = !!impls?.actions.length;
 	const hasGuards = !!impls?.guards.length;
@@ -5784,7 +6058,7 @@ 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, {
+	const machineConfig = xstateVersion === 6 ? toXStateV6MachineConfig(graphToMachineConfig(graph, {
 		...configOptions,
 		keepChooseStructured: true
 	})) : toV5MachineConfig(graphToMachineConfig(graph, configOptions));
@@ -5916,7 +6190,7 @@ function toV5MachineConfig(machineConfig) {
 		return wasArray ? mapped : mapped[0];
 	});
 }
-function toV6MachineConfig(machineConfig) {
+function toXStateV6MachineConfig(machineConfig) {
 	return mapV6MachineConfig(machineConfig);
 }
 function mapV6MachineConfig(value, context = {}) {
@@ -5929,6 +6203,10 @@ function mapV6MachineConfig(value, context = {}) {
 			result[key] = mapV6StatesMap(item);
 			continue;
 		}
+		if (key === "choice") {
+			result[key] = buildV6TransitionFunction(Array.isArray(item) ? item : [item]) ?? mapV6MachineConfig(item, { transitionValue: true });
+			continue;
+		}
 		if (key === "entry" || key === "exit" || key === "actions") {
 			result[key] = toV6ActionField(Array.isArray(item) ? item : item === void 0 ? [] : [item]);
 			continue;
@@ -5964,18 +6242,20 @@ function toV6TransitionValue(value) {
 	const transition = value;
 	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);
+	if (transition.description || transition.input !== void 0 && !containsInlineExpression(transition.input)) return mapV6MachineConfig(transition);
 	const target = transition.target;
 	const context = transition.context;
 	const actionsValue = transition.actions;
 	const actions = Array.isArray(actionsValue) ? actionsValue : actionsValue === void 0 ? [] : [actionsValue];
-	if (actions.length === 0 && typeof target === "string" && context === void 0 && !transition.reenter && !transition.meta) return target;
-	if (actions.length === 0 && target === void 0 && context === void 0) return mapV6MachineConfig(transition);
+	if (actions.length === 0 && !containsInlineExpression(transition) && !containsTemplateExpression(transition)) return mapV6MachineConfig(transition);
+	if (actions.length === 0 && typeof target === "string" && context === void 0 && transition.input === void 0 && !transition.reenter && !transition.meta) return { target };
+	if (actions.length === 0 && target === void 0 && context === void 0 && transition.input === void 0) return mapV6MachineConfig(transition);
 	return buildV6ActionFunction(actions, {
-		target: typeof target === "string" ? target : void 0,
+		target: typeof target === "string" || Array.isArray(target) && target.every((item) => typeof item === "string") ? target : void 0,
 		reenter: transition.reenter === true,
 		meta: transition.meta,
-		context
+		context,
+		input: transition.input
 	}) ?? mapV6MachineConfig(transition);
 }
 function guardCondition(value) {
@@ -5998,10 +6278,14 @@ function guardCondition(value) {
 	if (arrow < 0) return null;
 	const params = expression.slice(0, arrow).trim();
 	const body = expression.slice(arrow + 2).trim();
-	if (body.startsWith("{")) return null;
+	const callCondition = `(${expression})({ context, event, input, output, actions, guards, children, self, system })`;
+	if (body.startsWith("{")) return {
+		condition: callCondition,
+		callCondition
+	};
 	return {
 		condition: body,
-		callCondition: `(${expression})({ context, event, input, output, actions, guards, children, self, system })`,
+		callCondition,
 		firstParam: params.startsWith("(") && params.endsWith(")") ? params.slice(1, -1).trim() : params
 	};
 }
@@ -6029,7 +6313,8 @@ const V6_ARG_BINDINGS = [
 ];
 const V6_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 function inferV6ArgBindings(code) {
-	return V6_ARG_BINDINGS.filter((name) => new RegExp(`\\b${name}\\b`).test(code));
+	const withoutPropertyKeys = code.replace(/\b(context|event|input|output|actions|guards|children|self|system)\s*:/g, "");
+	return V6_ARG_BINDINGS.filter((name) => new RegExp(`\\b${name}\\b`).test(withoutPropertyKeys));
 }
 /** Splits a destructuring pattern body on its top-level commas. */
 function splitV6PatternEntries(body) {
@@ -6106,11 +6391,15 @@ function mergeV6FirstParam(authoredFirstParam, inferred) {
 	};
 }
 function buildV6TransitionFunction(transitions) {
+	const transitionObjects = transitions.every((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)) ? transitions : void 0;
+	if (!transitionObjects?.length) return;
+	const descriptions = transitionObjects.map((transition) => typeof transition.description === "string" ? transition.description : void 0);
+	const hasBranchDescriptions = transitionObjects.some((transition) => Object.prototype.hasOwnProperty.call(transition.meta ?? {}, XSTATE_V6_BRANCH_DESCRIPTION_META)) || descriptions.some((description) => description !== descriptions[0]);
 	const branches = [];
 	let authoredFirstParam;
-	for (const item of transitions) {
-		if (!item || typeof item !== "object" || Array.isArray(item)) return;
-		const transition = item;
+	const commonDescription = descriptions[0];
+	for (const transition of transitionObjects) {
+		const description = typeof transition.description === "string" ? transition.description : void 0;
 		const match = transition.matches === void 0 ? void 0 : matchesCondition(transition.matches);
 		if (match === null) return;
 		const guard = guardCondition(transition.guard);
@@ -6124,9 +6413,12 @@ function buildV6TransitionFunction(transitions) {
 		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 effectiveReturnValue = buildV6TransitionReturnValue({
-			target: typeof transition.target === "string" ? transition.target : void 0,
+			target: typeof transition.target === "string" || Array.isArray(transition.target) && transition.target.every((target) => typeof target === "string") ? transition.target : void 0,
 			reenter: transition.reenter === true,
-			meta: transition.meta,
+			meta: hasBranchDescriptions ? {
+				...transition.meta ?? {},
+				[XSTATE_V6_BRANCH_DESCRIPTION_META]: description ?? null
+			} : transition.meta,
 			input: transition.input
 		}, rendered.contextValue) ?? "{}";
 		const body = [...rendered.statements.map(formatV6Statement), `return ${effectiveReturnValue};`];
@@ -6143,22 +6435,25 @@ function buildV6TransitionFunction(transitions) {
 	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
+			condition: branch.callCondition ?? branch.condition
 		}));
 		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 renderedBranches) if (branch.condition === "true") lines.push(...branch.body.map((line) => `  ${line}`));
+	const lines = merged.prelude.map((statement) => indentV6Code(statement, 2));
+	for (const branch of renderedBranches) if (branch.condition === "true") lines.push(...branch.body.map((line) => indentV6Code(line, 2)));
 	else {
-		lines.push(`  if (${branch.condition}) {`);
-		lines.push(...branch.body.map((line) => `    ${line}`));
+		lines.push(indentV6Code(`if (${branch.condition}) {`, 2));
+		lines.push(...branch.body.map((line) => indentV6Code(line, 4)));
 		lines.push("  }");
 	}
-	return raw(`(${merged.firstParam}, enq) => {\n${lines.join("\n")}\n}`);
+	const transitionFunction = raw(`(${merged.firstParam}, enq) => {\n${lines.join("\n")}\n}`);
+	return commonDescription === void 0 || hasBranchDescriptions ? transitionFunction : {
+		description: commonDescription,
+		to: transitionFunction
+	};
 }
 function toV6ActionField(actions) {
 	if (actions.length === 1) {
@@ -6177,7 +6472,11 @@ function buildV6ActionFunction(actions, transition) {
 	if (transition) returnValue = buildV6TransitionReturnValue(transition, rendered.contextValue);
 	if (statements.length === 0 && !returnValue) return void 0;
 	const bindings = inferV6ArgBindings([...statements, returnValue ?? ""].join("\n"));
-	return raw(`(${bindings.length ? `{ ${bindings.join(", ")} }` : "_"}, enq) => {\n${[...statements.map((statement) => `  ${formatV6Statement(statement)}`), ...returnValue ? [`  return ${returnValue};`] : []].join("\n")}\n}`);
+	return raw(`(${bindings.length ? `{ ${bindings.join(", ")} }` : "_"}, enq) => {\n${[...statements.map((statement) => indentV6Code(formatV6Statement(statement), 2)), ...returnValue ? [indentV6Code(`return ${returnValue};`, 2)] : []].join("\n")}\n}`);
+}
+function indentV6Code(code, spaces) {
+	const indent = " ".repeat(spaces);
+	return code.split("\n").map((line) => line ? `${indent}${line}` : line).join("\n");
 }
 function formatV6Statement(statement) {
 	const trimmed = statement.trim();
@@ -6188,7 +6487,7 @@ function renderV6Effects(effects, finalContext) {
 	const statements = ["let nextContext = context"];
 	const inCurrentContext = (body) => {
 		if (body.length === 0) return;
-		statements.push("{", "  const context = nextContext", ...body.map((line) => `  ${line}`), "}");
+		statements.push("{", "  const context = nextContext", ...body.map((line) => indentV6Code(line, 2)), "}");
 	};
 	for (const effect of effects) {
 		inCurrentContext(effect.statements ?? []);
@@ -6209,8 +6508,16 @@ function unwrapTemplateExpressions(value) {
 	if (!value || typeof value !== "object") return value;
 	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, unwrapTemplateExpressions(item)]));
 }
+function containsTemplateExpression(value) {
+	if (typeof value === "string") return /^\{\{[\s\S]*\}\}$/.test(value.trim());
+	if (Array.isArray(value)) return value.some(containsTemplateExpression);
+	return Boolean(value) && typeof value === "object" && Object.values(value).some(containsTemplateExpression);
+}
 function buildV6TransitionReturnValue(transition, contextValue) {
-	if (!transition.reenter && !transition.meta && !contextValue && transition.input === void 0) return transition.target ? `{ target: ${serializeJS(transition.target)} }` : void 0;
+	if (!transition.reenter && !transition.meta && !contextValue && transition.input === void 0) {
+		const target = Array.isArray(transition.target) ? `[${transition.target.map((item) => serializeJS(item)).join(", ")}]` : serializeJS(transition.target);
+		return transition.target ? `{ target: ${target} }` : void 0;
+	}
 	return serializeJS({
 		target: transition.target,
 		reenter: transition.reenter ? true : void 0,
@@ -6248,6 +6555,13 @@ function inlineExpr(value) {
 	const directive = value;
 	return directive["@type"] === "code" && typeof directive.expr === "string" ? directive.expr : void 0;
 }
+function containsInlineExpression(value) {
+	if (!value || typeof value !== "object") return false;
+	if (Array.isArray(value)) return value.some(containsInlineExpression);
+	const record = value;
+	if (record["@type"] === "code" && typeof record.expr === "string") return true;
+	return Object.values(record).some(containsInlineExpression);
+}
 function actionToV6Effect(action) {
 	const expr = inlineExpr(action);
 	if (expr) {
@@ -6443,6 +6757,12 @@ function getCodeExpressionImports$1(graph) {
 const XSTATE_ACTOR_LOGIC_HELPERS = new Set([
 	"createMachine",
 	"createAsyncLogic",
+	"createCallbackLogic",
+	"createEventObservableLogic",
+	"createListenerLogic",
+	"createLogic",
+	"createObservableLogic",
+	"createSubscriptionLogic",
 	"fromPromise",
 	"fromCallback",
 	"fromObservable",
@@ -6527,8 +6847,17 @@ function buildV6SchemasBlock(schemas, options) {
 	const contextType = contextSchemaToTSType(schemas.context);
 	if (contextType) result.context = raw(`types<${contextType}>()`);
 	if (schemas.events && Object.keys(schemas.events).length > 0) result.events = Object.fromEntries(Object.entries(schemas.events).map(([eventType, schema]) => [eventType, raw(`types<${eventPayloadSchemaToTSType(schema)}>()`)]));
+	if (schemas.emitted && Object.keys(schemas.emitted).length > 0) result.emitted = Object.fromEntries(Object.entries(schemas.emitted).map(([eventType, schema]) => [eventType, raw(`types<${eventPayloadSchemaToTSType(schema)}>()`)]));
+	if (schemas.internalEvents && Object.keys(schemas.internalEvents).length > 0) result.internalEvents = Object.fromEntries(Object.entries(schemas.internalEvents).map(([eventType, schema]) => [eventType, raw(`types<${eventPayloadSchemaToTSType(schema)}>()`)]));
+	if (schemas.children && Object.keys(schemas.children).length > 0) result.children = Object.fromEntries(Object.entries(schemas.children).map(([name, schema]) => [name, raw(`types<${jsonSchemaToTSType(schema)}>()`)]));
+	for (const key of ["actions", "guards"]) {
+		const map = schemas[key];
+		if (map && Object.keys(map).length > 0) result[key] = Object.fromEntries(Object.entries(map).map(([name, value]) => [name, { ...value.params ? { params: raw(`types<${jsonSchemaToTSType(value.params)}>()`) } : {} }]));
+	}
 	if (schemas.input) result.input = raw(`types<${jsonSchemaToTSType(schemas.input)}>()`);
 	if (schemas.output) result.output = raw(`types<${jsonSchemaToTSType(schemas.output)}>()`);
+	if (schemas.tags && Object.keys(schemas.tags).length > 0) result.tags = raw(`types<${jsonSchemaToTSType(schemas.tags)}>()`);
+	if (schemas.meta && Object.keys(schemas.meta).length > 0) result.meta = raw(`types<${jsonSchemaToTSType(schemas.meta)}>()`);
 	return Object.keys(result).length > 0 ? result : void 0;
 }
 function buildV6ZodSchemasBlock(schemas) {
@@ -6537,14 +6866,25 @@ function buildV6ZodSchemasBlock(schemas) {
 	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.emitted && Object.keys(schemas.emitted).length > 0) result.emitted = Object.fromEntries(Object.entries(schemas.emitted).map(([eventType, schema]) => [eventType, raw(eventSchemaToZod(schema))]));
+	for (const key of ["internalEvents", "children"]) {
+		const map = schemas[key];
+		if (map && Object.keys(map).length > 0) result[key] = Object.fromEntries(Object.entries(map).map(([name, schema]) => [name, raw(jsonSchemaToZod(schema))]));
+	}
+	for (const key of ["actions", "guards"]) {
+		const map = schemas[key];
+		if (map && Object.keys(map).length > 0) result[key] = Object.fromEntries(Object.entries(map).map(([name, value]) => [name, { ...value.params ? { params: raw(jsonSchemaToZod(value.params)) } : {} }]));
+	}
 	if (schemas.input) result.input = raw(jsonSchemaToZod(schemas.input));
 	if (schemas.output) result.output = raw(jsonSchemaToZod(schemas.output));
+	if (schemas.tags && Object.keys(schemas.tags).length > 0) result.tags = raw(jsonSchemaToZod(schemas.tags));
+	if (schemas.meta && Object.keys(schemas.meta).length > 0) result.meta = raw(jsonSchemaToZod(schemas.meta));
 	return Object.keys(result).length > 0 ? result : void 0;
 }
 function eventPayloadSchemaToTSType(schema) {
 	const props = schema.properties ?? {};
 	const payloadProps = Object.fromEntries(Object.entries(props).filter(([key]) => key !== "type"));
-	if (Object.keys(payloadProps).length === 0) return "{}";
+	if (Object.keys(payloadProps).length === 0) return "void";
 	return jsonSchemaToTSType({
 		...schema,
 		properties: payloadProps,
@@ -6562,14 +6902,16 @@ function hasSchemaProperties(schema) {
 function buildActionsBlock(actions, options) {
 	const block = {};
 	for (const implementation of actions) if (implementation.code?.body) {
+		if (options.xstateVersion === 6) assertV6NamedActionBody(implementation.name, implementation.code.body);
 		const inlineExpression = getInlineExpression$1(implementation.code.body);
 		if (inlineExpression) {
 			block[implementation.name] = raw(inlineExpression);
 			continue;
 		}
-		const params = hasSchemaProperties(implementation.paramsSchema) ? options.includeTypeSyntax ? `, params: ${jsonSchemaToTSType(implementation.paramsSchema)}` : ", params" : "";
-		block[implementation.name] = raw(`function ({ context, event }${params ? params : ""}) {\n  ${dedent(implementation.code.body)}\n}`);
-	} else block[implementation.name] = raw(`function ({ context, event }) {\n  // TODO: implement ${implementation.name}\n}`);
+		const params = hasSchemaProperties(implementation.paramsSchema) ? options.xstateVersion === 6 ? options.includeTypeSyntax ? `params: ${jsonSchemaToTSType(implementation.paramsSchema)}` : "params" : options.includeTypeSyntax ? `, params: ${jsonSchemaToTSType(implementation.paramsSchema)}` : ", params" : "";
+		const firstParam = options.xstateVersion === 6 ? params : `{ context, event }${params}`;
+		block[implementation.name] = raw(`function (${firstParam}) {\n  ${dedent(implementation.code.body)}\n}`);
+	} else block[implementation.name] = raw(options.xstateVersion === 6 ? `function () {\n  // TODO: implement ${implementation.name}\n}` : `function ({ context, event }) {\n  // TODO: implement ${implementation.name}\n}`);
 	return block;
 }
 function buildGuardsBlock(guards, options) {
@@ -6641,6 +6983,23 @@ function getInlineExpression$1(code) {
 	if (stripped !== code.trim()) return stripped;
 	return isCompleteFunctionExpression(stripped) || isCompleteXStateHelperExpression(stripped) ? stripped : void 0;
 }
+/**
+* A complete function expression is preserved verbatim when it came from an
+* imported implementation. Reject the XState v5 named-action signature here
+* instead of emitting a v6 action whose `context`/`event` references are free
+* at runtime. XState v6 named actions receive only their params argument.
+*/
+function assertV6NamedActionBody(name, code) {
+	const expression = parseSingleExpression(stripExportDefault(code))?.expression;
+	if (!expression || !ts.isArrowFunction(expression) && !ts.isFunctionExpression(expression)) return;
+	const firstParameter = expression.parameters[0]?.name;
+	if (!firstParameter || !ts.isObjectBindingPattern(firstParameter)) return;
+	if (firstParameter.elements.some((element) => {
+		if (element.dotDotDotToken) return false;
+		const property = element.propertyName ?? element.name;
+		return ts.isIdentifier(property) && (property.text === "context" || property.text === "event");
+	})) throw new Error(`Cannot export named action "${name}" as XState v6: its implementation uses the XState v5 context/event signature. Rewrite it to receive params only.`);
+}
 function parseSingleExpression(code) {
 	const candidate = code.trim().replace(/;$/, "");
 	const source = ts.createSourceFile("implementation.ts", `(${candidate})`, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
@@ -6756,6 +7115,9 @@ function transformState(state, ctx, sourceKey) {
 			case "output":
 				result.data = transformCodeValues(value);
 				break;
+			case "tags":
+				result.tags = Array.isArray(value) && value.length === 1 ? value[0] : value;
+				break;
 			case "entry":
 			case "exit":
 				result[key] = transformActions(value);
@@ -7676,102 +8038,4 @@ const simulateMachineStepInputSchema = machineInputSchema.extend({
 });
 
 //#endregion
-//#region src/statelyPragma.ts
-function findStatelyPragmaAttachments(sourceText, fileName = "machine.ts") {
-	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(fileName));
-	const attachments = [];
-	const visit = (node) => {
-		if (ts.isCallExpression(node) && isCreateMachineExpression(node.expression)) {
-			const attachNode = findAttachNode(node);
-			if (attachNode) attachments.push({
-				machineStart: getMachineExpressionStart(node.expression, sourceFile),
-				attachStart: attachNode.getStart(sourceFile),
-				pragma: findAttachedStatelyPragma(sourceText, attachNode)
-			});
-		}
-		ts.forEachChild(node, visit);
-	};
-	visit(sourceFile);
-	return attachments;
-}
-function getStatelyPragma(sourceText, fileName = "machine.ts", machineIndex = 0) {
-	return findStatelyPragmaAttachments(sourceText, fileName)[machineIndex]?.pragma;
-}
-function upsertStatelyPragma(sourceText, id, options = {}) {
-	const attachment = findStatelyPragmaAttachments(sourceText, options.fileName ?? "machine.ts")[options.machineIndex ?? 0];
-	if (!attachment) return sourceText;
-	const lineEnding = options.lineEnding ?? detectLineEnding(sourceText);
-	const canonicalComment = `// @statelyai id=${id}`;
-	if (attachment.pragma) return sourceText.slice(0, attachment.pragma.start) + canonicalComment + sourceText.slice(attachment.pragma.end);
-	const insertText = `${getIndentationAtOffset(sourceText, attachment.attachStart)}${canonicalComment}${lineEnding}`;
-	return sourceText.slice(0, attachment.attachStart) + insertText + sourceText.slice(attachment.attachStart);
-}
-function findAttachedStatelyPragma(sourceText, node) {
-	const comments = ts.getLeadingCommentRanges(sourceText, node.getFullStart()) ?? [];
-	for (let index = comments.length - 1; index >= 0; index -= 1) {
-		const comment = comments[index];
-		const parsed = parseStatelyPragma(sourceText, comment.pos, comment.end);
-		if (parsed) return parsed;
-	}
-}
-function parseStatelyPragma(sourceText, start, end) {
-	const match = normalizeCommentContent(sourceText.slice(start, end)).match(/^@statelyai(?:\s+(.*))?$/s);
-	if (!match) return;
-	const fields = parseFields(match[1] ?? "");
-	return {
-		tag: "@statelyai",
-		id: fields.id,
-		fields,
-		start,
-		end
-	};
-}
-function normalizeCommentContent(rawComment) {
-	if (rawComment.startsWith("//")) return rawComment.slice(2).trim();
-	if (rawComment.startsWith("/*")) return rawComment.slice(2, rawComment.endsWith("*/") ? -2 : void 0).split(/\r?\n/).map((line) => line.replace(/^\s*\*\s?/, "")).join(" ").trim();
-	return rawComment.trim();
-}
-function parseFields(input) {
-	const fields = {};
-	for (const token of input.split(/\s+/)) {
-		if (!token) continue;
-		const equalsIndex = token.indexOf("=");
-		if (equalsIndex <= 0) continue;
-		const key = token.slice(0, equalsIndex);
-		const value = token.slice(equalsIndex + 1);
-		if (!key || !value) continue;
-		fields[key] = value;
-	}
-	return fields;
-}
-function findAttachNode(node) {
-	let current = node;
-	while (current?.parent) {
-		if (ts.isVariableStatement(current.parent) || ts.isExpressionStatement(current.parent) || ts.isExportAssignment(current.parent)) return current.parent;
-		current = current.parent;
-	}
-	return current;
-}
-function isCreateMachineExpression(expression) {
-	return ts.isIdentifier(expression) && expression.text === "createMachine" || ts.isPropertyAccessExpression(expression) && expression.name.text === "createMachine";
-}
-function getMachineExpressionStart(expression, sourceFile) {
-	if (ts.isPropertyAccessExpression(expression)) return expression.name.getStart(sourceFile);
-	return expression.getStart(sourceFile);
-}
-function getIndentationAtOffset(sourceText, offset) {
-	const lineStart = sourceText.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
-	return sourceText.slice(lineStart, offset).match(/^[ \t]*/)?.[0] ?? "";
-}
-function detectLineEnding(sourceText) {
-	return sourceText.includes("\r\n") ? "\r\n" : "\n";
-}
-function getScriptKind(fileName) {
-	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
-	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
-	if (fileName.endsWith(".js")) return ts.ScriptKind.JS;
-	return ts.ScriptKind.TS;
-}
-
-//#endregion
-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 };
+export { toXStateV6MachineConfig as S, graphToXStateV4TS as _, alignCompareGraphIds as a, raw as b, diffGraphsSemantically as c, getDelayKeyFromEventType as d, getXStateFSMCompatibilityIssues as f, graphToXStateTS as g, graphToXStateFSM as h, XSTATE_V6_FN_TRANSITION_META as i, eventsSchemaToTSType as l, graphToMachineConfig as m, RawCode as n, contextSchemaToTSType as o, graphChangeToPatchesResult as p, XSTATE_V6_BRANCH_DESCRIPTION_META as r, detectXStateSourceProfile as s, INLINE_EXPRESSION_DIRECTIVE_FIELDS as t, extractXStateMachineConfigEntries as u, jsonSchemaToTSType as v, serializeJS as x, normalizeMachineProfile as y };