@statelyai/sdk 0.29.1 → 0.31.1

package/dist/sync.mjs

@@ -1,6 +1,7 @@
 import "./openapi-BTDjYWXd.mjs";
 import { r as createStatelyClient } from "./studio-rSI54Ese.mjs";
-import { b as serializeJS, c as detectXStateSourceProfile, f as graphChangeToPatchesResult, h as graphToXStateTS, i as INLINE_EXPRESSION_DIRECTIVE_FIELDS, l as diffGraphsSemantically, n as getStatelyPragma, o as alignCompareGraphIds, p as graphToMachineConfig, r as upsertStatelyPragma, t as findStatelyPragmaAttachments, v as normalizeMachineProfile, x as xstateSourceToConfig } from "./statelyPragma-p1vu8PmH.mjs";
+import { S as toXStateV6MachineConfig, a as alignCompareGraphIds, c as diffGraphsSemantically, d as getDelayKeyFromEventType, g as graphToXStateTS, i as XSTATE_V6_FN_TRANSITION_META, m as graphToMachineConfig, p as graphChangeToPatchesResult, r as XSTATE_V6_BRANCH_DESCRIPTION_META, s as detectXStateSourceProfile, t as INLINE_EXPRESSION_DIRECTIVE_FIELDS, u as extractXStateMachineConfigEntries, x as serializeJS, y as normalizeMachineProfile } from "./dist-wbhkeGh6.mjs";
+import { n as getStatelyPragma, r as upsertStatelyPragma, t as findStatelyPragmaAttachments } from "./statelyPragma-D46lczJR.mjs";
 import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
@@ -820,11 +821,15 @@ function parseSourceToMachine(text, document, options = {}) {
 		...statesObjectReplacements,
 		...importReplacements
 	].filter(removeOverlappingRanges).sort(compareSourceRangesDescending));
-	if (sourceLocations.profile === "xstate-v6-alpha") {
+	if (sourceLocations.profile === "xstate-v6-alpha" || options.machineIndex !== void 0) {
 		const importedTransitionSources = collectImportedXStateTransitionSources(text, document, options);
+		const parseText = importedTransitionSources.length ? `${hydratedText}\n${importedTransitionSources.join("\n")}` : hydratedText;
+		const selectedMachineIndex = options.machineIndex ?? 0;
+		const config = extractXStateMachineConfigEntries(parseText, { profile: sourceLocations.profile }).find((entry) => entry.machineIndex === selectedMachineIndex)?.config;
+		if (!config) throw new Error(`No machine at index ${selectedMachineIndex} was found in ${document.fileName}.`);
 		return `import { createMachine } from "xstate";
 
-export const machine = createMachine(${serializeJS(xstateSourceToConfig(importedTransitionSources.length ? `${hydratedText}\n${importedTransitionSources.join("\n")}` : hydratedText, { profile: "xstate-v6-alpha" }), 0)});
+export const machine = createMachine(${serializeJS(config, 0)});
 `;
 	}
 	return hydratedText;
@@ -1092,12 +1097,13 @@ function offsetAtRangePosition$1(sourceText, line, character) {
 function applyMachineToSource(machineConfig, document, options = {}) {
 	if (!isMachineConfig(machineConfig)) return [];
 	const sourceFile = createSourceFile(document, document.getText());
-	const machineConfigNode = findMachineConfigObjectLiteral(sourceFile, options.machineIndex);
+	const machineConfigNode = getMappedRootObjectLiteral(document, sourceFile, options.sourceLocations) ?? findMachineConfigObjectLiteral(sourceFile, options.machineIndex);
 	if (!machineConfigNode) return [];
+	if (options.sourceUpdateStrategy === "rewrite") return addCodeImportReplacements(document, sourceFile, machineConfig, [createRewriteReplacement(document, sourceFile, machineConfigNode, machineConfig)]).sort(compareReplacementRangesDescending);
 	const parsedPatches = parseGraphPatches(options.patches);
 	const prevGraph = parseGraph(options.prevGraph);
 	const nextGraph = parseGraph(options.nextGraph);
-	const rootNode = getMappedRootObjectLiteral(document, sourceFile, options.sourceLocations) ?? machineConfigNode;
+	const rootNode = machineConfigNode;
 	if (!parsedPatches || !prevGraph || !nextGraph || parsedPatches.length === 0) {
 		if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
 		return [createReplacement(document, sourceFile, rootNode, machineConfig)];
@@ -1171,6 +1177,7 @@ async function applyMachineToSourceDocuments(machineConfig, document, options =
 	const sourceFile = createSourceFile(document, document.getText());
 	const machineConfigNode = getMappedRootObjectLiteral(document, sourceFile, options.sourceLocations) ?? findMachineConfigObjectLiteral(sourceFile, options.machineIndex);
 	if (!machineConfigNode) return [];
+	if (options.sourceUpdateStrategy === "rewrite") return addCodeImportReplacements(document, sourceFile, machineConfig, [createRewriteReplacement(document, sourceFile, machineConfigNode, machineConfig)]).sort(compareReplacementRangesDescending);
 	const parsedPatches = parseGraphPatches(options.patches);
 	const prevGraph = parseGraph(options.prevGraph);
 	const nextGraph = parseGraph(options.nextGraph);
@@ -1241,6 +1248,10 @@ function fallbackRootReplacement(document, sourceFile, machineConfigNode, machin
 	return addCodeImportReplacements(document, sourceFile, machineConfig, [createReplacement(document, sourceFile, machineConfigNode, machineConfig)]).sort(compareReplacementRangesDescending);
 }
 async function tryCreateTransitionPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
+	if (isXStateV6Source(sourceLocations)) {
+		const v6Split = await tryCreateV6TransitionPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patches, prevGraph, nextGraph, sourceLocations, openTextDocument);
+		if (v6Split) return v6Split;
+	}
 	const replacements = [];
 	const remainingPatches = [];
 	const handledTransitionKeys = /* @__PURE__ */ new Set();
@@ -1295,6 +1306,114 @@ async function tryCreateTransitionPatchSplitForDocuments(document, sourceFile, m
 		remainingPatches
 	} : null;
 }
+async function tryCreateV6TransitionPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
+	applyV6FunctionDescriptionEdits(machineConfig, machineConfigNode, patches, prevGraph, nextGraph);
+	const propertiesByPath = /* @__PURE__ */ new Map();
+	const remainingPatches = [];
+	const deletedStatePaths = patches.flatMap((patch) => {
+		if (patch.op !== "deleteState") return [];
+		const path = resolveStatePath(prevGraph, patch.stateId);
+		return path ? [path] : [];
+	});
+	for (const patch of patches) {
+		const edgeId = getTransitionPatchEdgeId(patch, prevGraph, nextGraph);
+		if ((edgeId ? prevGraph.edges.find((edge) => edge.id === edgeId) ?? nextGraph.edges.find((edge) => edge.id === edgeId) : void 0)?.data?.meta?.[XSTATE_V6_FN_TRANSITION_META] === true && patch.op !== "deleteTransition") return {
+			replacements: [],
+			remainingPatches: []
+		};
+		const targets = getV6TransitionPropertyTargets(patch, prevGraph, nextGraph);
+		if (targets.length === 0) {
+			remainingPatches.push(patch);
+			continue;
+		}
+		for (const target of targets) {
+			if (deletedStatePaths.some((deletedPath) => isPathEqualOrDescendant(target.path, deletedPath))) continue;
+			const key = target.path.join(".");
+			const group = propertiesByPath.get(key) ?? {
+				path: target.path,
+				properties: /* @__PURE__ */ new Map()
+			};
+			const slots = group.properties.get(target.propertyName) ?? /* @__PURE__ */ new Set();
+			if (target.slotKey !== null) slots.add(target.slotKey);
+			group.properties.set(target.propertyName, slots);
+			propertiesByPath.set(key, group);
+		}
+	}
+	if (propertiesByPath.size === 0) return null;
+	const replacements = [];
+	for (const { path, properties } of propertiesByPath.values()) {
+		if (!canSerializeXStateV6TransitionProperties(machineConfig, path, properties)) return {
+			replacements: [],
+			remainingPatches: []
+		};
+		const propertyReplacements = await createStatePropertiesReplacementForDocuments(document, sourceFile, machineConfigNode, machineConfig, path, [...properties.keys()], sourceLocations, openTextDocument, properties);
+		if (!propertyReplacements) return null;
+		replacements.push(...propertyReplacements);
+	}
+	return {
+		replacements: replacements.sort(compareReplacementRangesDescending),
+		remainingPatches
+	};
+}
+function applyV6FunctionDescriptionEdits(machineConfig, machineConfigNode, patches, prevGraph, nextGraph) {
+	for (const patch of patches) {
+		if (patch.op !== "updateTransition" || patch.transitionDescription === void 0 || Object.prototype.hasOwnProperty.call(patch.meta ?? {}, XSTATE_V6_BRANCH_DESCRIPTION_META)) continue;
+		const target = getTransitionPatchTarget(patch, prevGraph, nextGraph);
+		if (!target) continue;
+		const stateObject = getStateObjectLiteralByPath(machineConfigNode, target.sourcePath);
+		if (!stateObject || !isV6FunctionTransitionSource(stateObject, target.previousEventType)) continue;
+		const stateConfig = getStateConfigByPath(machineConfig, target.sourcePath);
+		const transitions = (isMachineConfig(stateConfig?.on) ? stateConfig.on : null)?.[target.eventType];
+		if (!Array.isArray(transitions)) continue;
+		for (const transition of transitions) {
+			if (!isMachineConfig(transition)) continue;
+			if (patch.transitionDescription === null) delete transition.description;
+			else transition.description = patch.transitionDescription;
+		}
+	}
+}
+function isV6FunctionTransitionSource(stateObject, eventType) {
+	const onObject = getObjectLiteralProperty(stateObject, "on");
+	if (!onObject) return false;
+	const eventProperty = findObjectLiteralProperty(onObject, eventType);
+	if (!eventProperty || !ts$1.isPropertyAssignment(eventProperty)) return false;
+	const initializer = unwrapExpression$1(eventProperty.initializer);
+	if (ts$1.isArrowFunction(initializer) || ts$1.isFunctionExpression(initializer)) return true;
+	if (!ts$1.isObjectLiteralExpression(initializer)) return false;
+	return initializer.properties.some((property) => ts$1.isPropertyAssignment(property) && property.name.getText().replace(/^['"]|['"]$/g, "") === "to");
+}
+function canSerializeXStateV6TransitionProperties(machineConfig, path, properties) {
+	const stateConfig = getStateConfigByPath(machineConfig, path);
+	if (!stateConfig) return false;
+	for (const [propertyName, slots] of properties) {
+		const value = stateConfig[propertyName];
+		if (value === void 0) continue;
+		const converted = getXStateV6PropertyValue(propertyName, value);
+		if (propertyName === "on" || propertyName === "after") {
+			if (!isMachineConfig(converted)) return false;
+			if ([...slots].some((slot) => Array.isArray(converted[slot]))) return false;
+			continue;
+		}
+		if (propertyName === "invoke") {
+			const invokes = Array.isArray(converted) ? converted : [converted];
+			for (const slotRef of slots) {
+				const match = /^@statelyai\.invoke\.(done|error|snapshot|timeout)\.(.+)$/.exec(slotRef);
+				if (!match) return false;
+				const invoke = invokes[findXStateV6InvokeIndex(invokes, match[2])];
+				const slot = {
+					done: "onDone",
+					error: "onError",
+					snapshot: "onSnapshot",
+					timeout: "onTimeout"
+				}[match[1]];
+				if (!isMachineConfig(invoke) || Array.isArray(invoke[slot])) return false;
+			}
+			continue;
+		}
+		if (Array.isArray(converted)) return false;
+	}
+	return true;
+}
 async function createDeleteTransitionReplacementsForDocuments(document, sourceFile, machineConfigNode, transitionTarget, sourceLocations, openTextDocument) {
 	const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, transitionTarget.sourcePath, openTextDocument);
 	const targetDocument = mappedTarget?.document ?? document;
@@ -1319,10 +1438,10 @@ async function createTransitionReplacementForDocuments(document, sourceFile, mac
 	if (transitionSource && transitionTarget.previousEventType === transitionTarget.eventType) return [createPropertyValueReplacement(targetDocument, targetSourceFile, transitionSource.eventProperty, nextTransitionValue)];
 	if (transitionSource) return [createPropertyAssignmentReplacement(targetDocument, targetSourceFile, transitionSource.eventProperty, transitionTarget.eventType, nextTransitionValue)];
 	const onObject = getObjectLiteralProperty(stateObject, "on");
-	if (onObject) return [createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, onObject, transitionTarget.eventType, nextTransitionValue)];
-	return [createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, stateObject, "on", { [transitionTarget.eventType]: nextTransitionValue })];
+	if (onObject) return createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, onObject, transitionTarget.eventType, nextTransitionValue);
+	return createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, stateObject, "on", { [transitionTarget.eventType]: nextTransitionValue });
 }
-async function createStatePropertiesReplacementForDocuments(document, sourceFile, machineConfigNode, machineConfig, path, propertyNames, sourceLocations, openTextDocument) {
+async function createStatePropertiesReplacementForDocuments(document, sourceFile, machineConfigNode, machineConfig, path, propertyNames, sourceLocations, openTextDocument, affectedV6Slots) {
 	const nextStateConfig = getStateConfigByPath(machineConfig, path);
 	if (!isMachineConfig(nextStateConfig)) return null;
 	const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, path, openTextDocument);
@@ -1333,8 +1452,36 @@ async function createStatePropertiesReplacementForDocuments(document, sourceFile
 	const replacements = [];
 	const insertionEntries = [];
 	for (const propertyName of propertyNames) {
-		const nextValue = nextStateConfig[propertyName];
+		const rawNextValue = nextStateConfig[propertyName];
 		const property = findObjectLiteralProperty(stateObject, propertyName);
+		const affectedSlots = affectedV6Slots?.get(propertyName);
+		const nextValue = rawNextValue === void 0 || !isXStateV6Source(sourceLocations) ? rawNextValue : getXStateV6PropertyValue(propertyName, rawNextValue);
+		if (affectedSlots && (propertyName === "on" || propertyName === "after") && property && ts$1.isPropertyAssignment(property) && isMachineConfig(nextValue)) {
+			const existingMap = unwrapObjectLiteralExpression(property.initializer);
+			if (existingMap) {
+				const insertedSlots = [];
+				for (const slot of affectedSlots) {
+					const existingSlot = findObjectLiteralProperty(existingMap, slot);
+					const nextSlotValue = nextValue[slot];
+					if (nextSlotValue === void 0) {
+						if (existingSlot) replacements.push(createObjectLiteralPropertyDeletion(targetDocument, targetSourceFile, existingMap, existingSlot));
+					} else if (existingSlot) replacements.push(createPropertyValueReplacement(targetDocument, targetSourceFile, existingSlot, nextSlotValue));
+					else insertedSlots.push({
+						key: slot,
+						config: nextSlotValue
+					});
+				}
+				if (insertedSlots.length > 0) replacements.push(createObjectLiteralPropertiesInsertion(targetDocument, targetSourceFile, existingMap, insertedSlots));
+				continue;
+			}
+		}
+		if (affectedSlots && propertyName === "invoke" && property && ts$1.isPropertyAssignment(property)) {
+			const invokeReplacements = createXStateV6InvokeSlotReplacements(targetDocument, targetSourceFile, property.initializer, nextValue, affectedSlots);
+			if (invokeReplacements) {
+				replacements.push(...invokeReplacements);
+				continue;
+			}
+		}
 		if (nextValue === void 0) {
 			if (!property) continue;
 			replacements.push(createObjectLiteralPropertyDeletion(targetDocument, targetSourceFile, stateObject, property));
@@ -1352,10 +1499,63 @@ async function createStatePropertiesReplacementForDocuments(document, sourceFile
 	if (insertionEntries.length > 0) replacements.push(createObjectLiteralPropertiesInsertion(targetDocument, targetSourceFile, stateObject, insertionEntries));
 	return replacements.length > 0 ? replacements.sort(compareReplacementRangesDescending) : [];
 }
+function createXStateV6InvokeSlotReplacements(document, sourceFile, initializer, nextValue, affectedSlots) {
+	const expression = unwrapExpression$1(initializer);
+	const existingInvokes = ts$1.isArrayLiteralExpression(expression) ? expression.elements.filter(ts$1.isExpression) : [expression];
+	const nextInvokes = Array.isArray(nextValue) ? nextValue : [nextValue];
+	const replacements = [];
+	const insertions = /* @__PURE__ */ new Map();
+	for (const slotRef of affectedSlots) {
+		const match = /^@statelyai\.invoke\.(done|error|snapshot|timeout)\.(.+)$/.exec(slotRef);
+		if (!match) return null;
+		const propertyName = {
+			done: "onDone",
+			error: "onError",
+			snapshot: "onSnapshot",
+			timeout: "onTimeout"
+		}[match[1]];
+		const invokeId = match[2];
+		const invokeIndex = findXStateV6InvokeIndex(nextInvokes, invokeId);
+		const existingInvoke = existingInvokes[invokeIndex];
+		const nextInvoke = nextInvokes[invokeIndex];
+		if (invokeIndex < 0 || !existingInvoke || !nextInvoke || !isMachineConfig(nextInvoke)) return null;
+		const existingObject = unwrapObjectLiteralExpression(existingInvoke);
+		if (!existingObject) return null;
+		const existingProperty = findObjectLiteralProperty(existingObject, propertyName);
+		const nextSlotValue = nextInvoke[propertyName];
+		if (nextSlotValue === void 0) {
+			if (existingProperty) replacements.push(createObjectLiteralPropertyDeletion(document, sourceFile, existingObject, existingProperty));
+		} else if (existingProperty) replacements.push(createPropertyValueReplacement(document, sourceFile, existingProperty, nextSlotValue));
+		else {
+			const entries = insertions.get(existingObject) ?? [];
+			entries.push({
+				key: propertyName,
+				config: nextSlotValue
+			});
+			insertions.set(existingObject, entries);
+		}
+	}
+	for (const [existingObject, entries] of insertions) replacements.push(createObjectLiteralPropertiesInsertion(document, sourceFile, existingObject, entries));
+	return replacements;
+}
+function findXStateV6InvokeIndex(invokes, invokeId) {
+	return invokes.findIndex((candidate, index) => {
+		if (!isMachineConfig(candidate)) return false;
+		if (candidate.id === invokeId) return true;
+		if (candidate.id !== void 0) return false;
+		if (invokeId === `$auto-inline-${index}`) return true;
+		return typeof candidate.src === "string" && invokeId === `$auto-invoke-${candidate.src}`;
+	});
+}
+function getXStateV6PropertyValue(propertyName, value) {
+	const converted = toXStateV6MachineConfig({ [propertyName]: value });
+	return isMachineConfig(converted) ? converted[propertyName] : value;
+}
 function getTransitionPatchTarget(patch, prevGraph, nextGraph) {
 	const patchRecord = patch;
 	if (patch.op === "createTransition") {
-		const edge = patch.id ? nextGraph.edges.find((item) => item.id === patch.id) : nextGraph.edges.find((item) => item.sourceId === patch.sourceId);
+		const edge = getCreatedTransitionEdge(patch, prevGraph, nextGraph);
+		if (!edge) return null;
 		const sourcePath = resolveStatePath(nextGraph, patch.sourceId);
 		const eventType = edge?.data?.eventType ?? edge?.label ?? patchRecord.eventType;
 		if (!sourcePath || !eventType) return null;
@@ -1363,8 +1563,8 @@ function getTransitionPatchTarget(patch, prevGraph, nextGraph) {
 			sourcePath,
 			eventType,
 			previousEventType: eventType,
-			transitionId: edge?.id ?? patch.id,
-			index: getTransitionIndexFromId(edge?.id ?? patch.id ?? "")
+			transitionId: edge.id,
+			index: getTransitionIndexFromId(edge.id)
 		};
 	}
 	const edgeId = patch.op === "updateTransition" || patch.op === "deleteTransition" ? patch.transitionId : patch.op === "setGuard" || patch.op === "deleteGuard" ? patch.edgeId : patch.op === "createAction" || patch.op === "updateAction" || patch.op === "deleteAction" ? "edgeId" in patch.location ? patch.location.edgeId : null : null;
@@ -1383,6 +1583,68 @@ function getTransitionPatchTarget(patch, prevGraph, nextGraph) {
 		index: getTransitionIndexFromId(edgeId)
 	};
 }
+function isXStateV6Source(sourceLocations) {
+	return sourceLocations?.profile === "xstate-v6-alpha" || sourceLocations?.profileRef?.startsWith("@statelyai/xstate@6") === true;
+}
+function getV6TransitionPropertyTargets(patch, prevGraph, nextGraph) {
+	const edgeId = getTransitionPatchEdgeId(patch, prevGraph, nextGraph);
+	if (!edgeId) return [];
+	const candidates = [{
+		edge: prevGraph.edges.find((edge) => edge.id === edgeId),
+		graph: prevGraph
+	}, {
+		edge: nextGraph.edges.find((edge) => edge.id === edgeId),
+		graph: nextGraph
+	}];
+	const targets = /* @__PURE__ */ new Map();
+	for (const { edge, graph } of candidates) {
+		if (!edge || edge.data?.route) continue;
+		const path = resolveStatePath(graph, edge.sourceId);
+		if (!path) continue;
+		const eventType = edge.data?.eventType ?? edge.label ?? "";
+		const sourceNode = graph.nodes.find((node) => node.id === edge.sourceId);
+		let propertyName;
+		let slotKey = null;
+		if (eventType === "") propertyName = sourceNode?.data.type === "choice" ? "choice" : "always";
+		else if (eventType.startsWith("xstate.after.")) {
+			propertyName = "after";
+			slotKey = getDelayKeyFromEventType(eventType, edge.sourceId);
+		} else if (eventType.startsWith("@statelyai.invoke.")) {
+			propertyName = "invoke";
+			slotKey = eventType;
+		} else if (eventType.startsWith("@statelyai.state.done.")) propertyName = "onDone";
+		else if (eventType.startsWith("@statelyai.state.error.")) propertyName = "onError";
+		else if (eventType.startsWith("@statelyai.state.timeout.")) propertyName = "onTimeout";
+		else {
+			propertyName = "on";
+			slotKey = eventType;
+		}
+		targets.set(`${path.join(".")}:${propertyName}:${slotKey ?? ""}`, {
+			path,
+			propertyName,
+			slotKey
+		});
+	}
+	return [...targets.values()];
+}
+function getCreatedTransitionEdge(patch, prevGraph, nextGraph) {
+	const previousIds = new Set(prevGraph.edges.map((edge) => edge.id));
+	let candidates = nextGraph.edges.filter((edge) => !previousIds.has(edge.id) && edge.sourceId === patch.sourceId);
+	const createdWithRequestedId = patch.id ? candidates.find((edge) => edge.id === patch.id) : void 0;
+	if (createdWithRequestedId) return createdWithRequestedId;
+	if (patch.eventType !== void 0) candidates = candidates.filter((edge) => (edge.data?.eventType ?? edge.label) === patch.eventType);
+	if (patch.targetId !== void 0) candidates = candidates.filter((edge) => edge.targetId === patch.targetId);
+	if (patch.transitionType !== void 0) candidates = candidates.filter((edge) => edge.data?.transitionType === patch.transitionType);
+	if (patch.matches !== void 0) candidates = candidates.filter((edge) => JSON.stringify(edge.data?.matches) === JSON.stringify(patch.matches));
+	return candidates.length === 1 ? candidates[0] : null;
+}
+function getTransitionPatchEdgeId(patch, prevGraph, nextGraph) {
+	if (patch.op === "createTransition") return getCreatedTransitionEdge(patch, prevGraph, nextGraph)?.id ?? null;
+	if (patch.op === "updateTransition" || patch.op === "deleteTransition") return patch.transitionId;
+	if (patch.op === "setGuard" || patch.op === "deleteGuard") return patch.edgeId;
+	if ((patch.op === "createAction" || patch.op === "updateAction" || patch.op === "deleteAction") && "edgeId" in patch.location) return patch.location.edgeId;
+	return null;
+}
 function getStatePropertyPatchTargets(patch, prevGraph, nextGraph) {
 	if (patch.op === "updateSchemas") return [{
 		path: [],
@@ -1474,7 +1736,24 @@ function createArrayElementDeletion(document, sourceFile, arrayLiteral, element)
 }
 function createExpressionReplacement(document, sourceFile, expression, nextValue) {
 	const formatting = getFormattingContextForExpression(document, sourceFile, expression);
-	return createOffsetReplacement(document, expression.getStart(sourceFile), expression.getEnd(), printExpression(valueToExpression(nextValue, unwrapExpression$1(expression)), sourceFile, formatting));
+	const printed = containsRawCodeLike(nextValue) ? reindentPrintedExpression(serializeJS(nextValue), formatting) : printExpression(valueToExpression(nextValue, unwrapExpression$1(expression)), sourceFile, formatting);
+	return createOffsetReplacement(document, expression.getStart(sourceFile), expression.getEnd(), preserveExpressionComments(expression, sourceFile, printed, formatting));
+}
+function preserveExpressionComments(expression, sourceFile, printed, formatting) {
+	const original = sourceFile.text.slice(expression.getStart(sourceFile), expression.getEnd());
+	const scanner = ts$1.createScanner(ts$1.ScriptTarget.Latest, false, ts$1.LanguageVariant.JSX, original);
+	const comments = [];
+	for (let token = scanner.scan(); token !== ts$1.SyntaxKind.EndOfFileToken; token = scanner.scan()) if (token === ts$1.SyntaxKind.SingleLineCommentTrivia || token === ts$1.SyntaxKind.MultiLineCommentTrivia) comments.push(scanner.getTokenText());
+	const missing = comments.filter((comment) => !printed.includes(comment));
+	if (missing.length === 0) return printed;
+	const lineSeparator = formatting.newLineKind === ts$1.NewLineKind.CarriageReturnLineFeed ? "\r\n" : "\n";
+	const bodyStart = printed.indexOf("=> {");
+	if (bodyStart >= 0) {
+		const insertion = bodyStart + 4;
+		const indent = `${formatting.baseIndent}${formatting.indentUnit}`;
+		return `${printed.slice(0, insertion)}${lineSeparator}${missing.map((comment) => `${indent}${comment}`).join(lineSeparator)}${printed.slice(insertion)}`;
+	}
+	return `${missing.join(lineSeparator)}${lineSeparator}${formatting.baseIndent}${printed}`;
 }
 function createPropertyValueReplacement(document, sourceFile, property, nextValue) {
 	if (!ts$1.isPropertyAssignment(property)) return createPropertyAssignmentReplacement(document, sourceFile, property, getStatePropertyKeyText(property) ?? "value", nextValue);
@@ -1485,8 +1764,30 @@ function createPropertyAssignmentReplacement(document, sourceFile, property, key
 	return createOffsetReplacement(document, property.getStart(sourceFile), property.getEnd(), text);
 }
 function createObjectLiteralPropertyInsertion(document, sourceFile, objectLiteral, key, nextValue) {
-	const text = objectPropertyTextForInsertion(objectLiteral, printObjectLiteralProperty(key, nextValue, sourceFile, getFormattingContext(document, sourceFile, objectLiteral)));
-	return createOffsetReplacement(document, objectLiteral.properties.end, objectLiteral.properties.end, text);
+	const propertyText = objectPropertyTextForInsertion(objectLiteral, printObjectLiteralProperty(key, nextValue, sourceFile, getFormattingContext(document, sourceFile, objectLiteral)));
+	return createObjectPropertyInsertionReplacements(document, objectLiteral, getObjectLiteralPropertyInsertionOffset(sourceFile, objectLiteral), propertyText);
+}
+function getObjectLiteralPropertyInsertionOffset(sourceFile, objectLiteral) {
+	const propertiesEnd = objectLiteral.properties.end;
+	const objectEnd = objectLiteral.getEnd() - 1;
+	const trailingTrivia = sourceFile.text.slice(propertiesEnd, objectEnd);
+	const commentMatch = /^[ \t]*(\/\/|\/\*)/.exec(trailingTrivia);
+	if (!commentMatch) return propertiesEnd;
+	const commentStart = propertiesEnd + commentMatch.index + commentMatch[0].length - 2;
+	if (commentMatch[1] === "//") {
+		const lineFeed = sourceFile.text.indexOf("\n", commentStart);
+		const lineEnd = lineFeed === -1 ? objectEnd : Math.min(lineFeed, objectEnd);
+		return lineEnd > commentStart && sourceFile.text.charCodeAt(lineEnd - 1) === 13 ? lineEnd - 1 : lineEnd;
+	}
+	const commentEnd = sourceFile.text.indexOf("*/", commentStart + 2);
+	return commentEnd === -1 ? propertiesEnd : Math.min(commentEnd + 2, objectEnd);
+}
+function createObjectPropertyInsertionReplacements(document, objectLiteral, insertionOffset, propertyText) {
+	const propertiesEnd = objectLiteral.properties.end;
+	const needsComma = objectLiteral.properties.length > 0 && !objectLiteral.properties.hasTrailingComma;
+	const replacements = [createOffsetReplacement(document, insertionOffset, insertionOffset, `${needsComma && insertionOffset === propertiesEnd ? "," : ""}${propertyText}`)];
+	if (needsComma && insertionOffset !== propertiesEnd) replacements.push(createOffsetReplacement(document, propertiesEnd, propertiesEnd, ","));
+	return replacements;
 }
 function getArrayElementDeletionRange(sourceFile, arrayLiteral, element) {
 	const elements = [...arrayLiteral.elements];
@@ -1583,14 +1884,16 @@ function createImplementationCreateReplacements(document, sourceFile, implementa
 	if (!implementation.id || !implementationCode) return null;
 	const categoryObject = getObjectLiteralProperty(implementationRoot, categoryName);
 	if (!categoryObject) {
-		const text = objectPropertyTextForInsertion(implementationRoot, `${propertyNameTextForSource(categoryName)}: {\n${getIndentForNewObjectProperty(sourceFile, implementationRoot)}${propertyNameTextForSource(implementation.id)}: ${implementationCode},\n${getIndentForObjectClose(sourceFile, implementationRoot)}}`);
-		return [createOffsetReplacement(document, implementationRoot.properties.end, implementationRoot.properties.end, text)];
+		const propertyText = objectPropertyTextForInsertion(implementationRoot, `${propertyNameTextForSource(categoryName)}: {\n${getIndentForNewObjectProperty(sourceFile, implementationRoot)}${propertyNameTextForSource(implementation.id)}: ${implementationCode},\n${getIndentForObjectClose(sourceFile, implementationRoot)}}`);
+		return createObjectPropertyInsertionReplacements(document, implementationRoot, getObjectLiteralPropertyInsertionOffset(sourceFile, implementationRoot), propertyText);
 	}
-	const text = objectPropertyTextForInsertion(categoryObject, `${propertyNameTextForSource(implementation.id)}: ${implementationCode}`);
-	return [createOffsetReplacement(document, categoryObject.properties.end, categoryObject.properties.end, text)];
+	const propertyText = objectPropertyTextForInsertion(categoryObject, `${propertyNameTextForSource(implementation.id)}: ${implementationCode}`);
+	return createObjectPropertyInsertionReplacements(document, categoryObject, getObjectLiteralPropertyInsertionOffset(sourceFile, categoryObject), propertyText);
 }
 function objectPropertyTextForInsertion(objectLiteral, propertyText) {
-	return `${objectLiteral.properties.length > 0 ? "," : ""}${getLineBreak(objectLiteral.getSourceFile())}${getIndentForNewObjectProperty(objectLiteral.getSourceFile(), objectLiteral)}${propertyText}`;
+	const lineBreak = getLineBreak(objectLiteral.getSourceFile());
+	const indent = getIndentForNewObjectProperty(objectLiteral.getSourceFile(), objectLiteral);
+	return `${lineBreak}${indent}${propertyText.startsWith(indent) ? propertyText.slice(indent.length) : propertyText}`;
 }
 function getLineBreak(sourceFile) {
 	return sourceFile.text.includes("\r\n") ? "\r\n" : "\n";
@@ -1886,7 +2189,7 @@ function getObjectLiteralPropertyDeletionRange(sourceFile, objectLiteral, proper
 	const propertyEnd = property.getEnd();
 	if (properties.length === 1) return {
 		start: propertyStart,
-		end: propertyEnd
+		end: objectLiteral.properties.hasTrailingComma ? objectLiteral.properties.end : propertyEnd
 	};
 	if (propertyIndex === properties.length - 1) {
 		const previousProperty = properties[propertyIndex - 1];
@@ -1932,7 +2235,8 @@ function getStatePropertyKeyText(property) {
 	return null;
 }
 function printObjectLiteralProperty(key, value, sourceFile, formatting) {
-	const objectText = printExpression(valueToExpression({ [key]: value }), sourceFile, formatting);
+	const objectValue = { [key]: value };
+	const objectText = containsRawCodeLike(value) ? reindentPrintedExpression(serializeJS(objectValue), formatting) : printExpression(valueToExpression(objectValue), sourceFile, formatting);
 	const lineSeparator = formatting.newLineKind === ts$1.NewLineKind.CarriageReturnLineFeed ? "\r\n" : "\n";
 	const lines = objectText.split(/\r?\n/);
 	if (lines.length <= 2) return objectText.replace(/^\{\s*/, "").replace(/\s*\}$/, "");
@@ -2254,6 +2558,21 @@ function createReplacement(document, sourceFile, node, value) {
 		newText: printExpression(valueToExpression(value, node), sourceFile, formatting)
 	};
 }
+function createRewriteReplacement(document, sourceFile, node, value) {
+	const start = document.positionAt(node.getStart(sourceFile));
+	const end = document.positionAt(node.getEnd());
+	const formatting = getFormattingContext(document, sourceFile, node);
+	return {
+		uri: getDocumentUri(document),
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		newText: printExpression(valueToExpression(value), sourceFile, formatting)
+	};
+}
 function addCodeImportReplacements(document, sourceFile, machineConfig, replacements) {
 	const importReplacements = createCodeImportReplacements(document, sourceFile, collectCodeImports(machineConfig));
 	return [...replacements, ...importReplacements];
@@ -2345,9 +2664,10 @@ function tryCreateSemanticReplacements(document, sourceFile, machineConfigNode,
 	return replacements.sort(compareReplacementRangesDescending);
 }
 async function tryCreateSemanticPatchSplitForDocuments(document, sourceFile, machineConfigNode, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
-	const split = getSemanticStateRenamePatchSplit(patches, prevGraph, nextGraph);
-	if (!split) return null;
-	const replacements = [];
+	const descriptionSplit = isXStateV6Source(sourceLocations) ? await tryCreateV6WrapperDescriptionPatchSplitForDocuments(document, sourceFile, machineConfigNode, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) : null;
+	const split = getSemanticStateRenamePatchSplit(descriptionSplit?.remainingPatches ?? patches, prevGraph, nextGraph);
+	if (!split) return descriptionSplit;
+	const replacements = [...descriptionSplit?.replacements ?? []];
 	const targetLiterals = await collectMappedTargetStringLiterals(document, sourceFile, machineConfigNode, sourceLocations, openTextDocument);
 	let activeSourceLocations = sourceLocations;
 	for (const rename of split.renames) {
@@ -2364,6 +2684,55 @@ async function tryCreateSemanticPatchSplitForDocuments(document, sourceFile, mac
 		sourceLocations: activeSourceLocations
 	};
 }
+async function tryCreateV6WrapperDescriptionPatchSplitForDocuments(document, sourceFile, machineConfigNode, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
+	const replacements = [];
+	const remainingPatches = [];
+	const descriptionsByTarget = /* @__PURE__ */ new Map();
+	for (const patch of patches) {
+		if (patch.op !== "updateTransition" || patch.transitionDescription === void 0 || Object.entries(patch).some(([key, value]) => value !== void 0 && ![
+			"op",
+			"transitionId",
+			"transitionDescription"
+		].includes(key))) {
+			remainingPatches.push(patch);
+			continue;
+		}
+		const target = getTransitionPatchTarget(patch, prevGraph, nextGraph);
+		if (!target || target.previousEventType !== target.eventType) {
+			remainingPatches.push(patch);
+			continue;
+		}
+		const targetKey = `${target.sourcePath.join(".")}:${target.eventType}`;
+		if (descriptionsByTarget.has(targetKey)) {
+			if (descriptionsByTarget.get(targetKey) !== patch.transitionDescription) return null;
+			continue;
+		}
+		descriptionsByTarget.set(targetKey, patch.transitionDescription);
+		const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, target.sourcePath, openTextDocument);
+		const targetDocument = mappedTarget?.document ?? document;
+		const targetSourceFile = mappedTarget?.sourceFile ?? sourceFile;
+		const stateObject = mappedTarget?.node ?? getStateObjectLiteralByPath(machineConfigNode, target.sourcePath);
+		const onObject = stateObject ? getObjectLiteralProperty(stateObject, "on") : null;
+		const eventProperty = onObject ? findObjectLiteralProperty(onObject, target.eventType) : null;
+		const initializer = eventProperty && ts$1.isPropertyAssignment(eventProperty) ? unwrapExpression$1(eventProperty.initializer) : null;
+		const wrapper = initializer && ts$1.isObjectLiteralExpression(initializer) ? initializer : null;
+		const toProperty = wrapper ? getPropertyAssignment(wrapper, "to") : null;
+		if (!wrapper || !toProperty) {
+			remainingPatches.push(patch);
+			continue;
+		}
+		const descriptionProperty = getPropertyAssignment(wrapper, "description");
+		if (patch.transitionDescription === null) {
+			if (descriptionProperty) replacements.push(createObjectLiteralPropertyDeletion(targetDocument, targetSourceFile, wrapper, descriptionProperty));
+		} else if (descriptionProperty) replacements.push(createPropertyValueReplacement(targetDocument, targetSourceFile, descriptionProperty, patch.transitionDescription));
+		else replacements.push(...createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, wrapper, "description", patch.transitionDescription));
+	}
+	return replacements.length > 0 ? {
+		replacements,
+		remainingPatches,
+		sourceLocations
+	} : null;
+}
 function getSemanticStateRenameFromPatch(patch, prevGraph, nextGraph) {
 	if (patch.op !== "updateState" || patch.key === void 0) return null;
 	const prevPath = resolveStatePath(prevGraph, patch.stateId);
@@ -3002,11 +3371,12 @@ function reindentPrintedExpression(printed, formatting) {
 	const lineSeparator = formatting.newLineKind === ts$1.NewLineKind.CarriageReturnLineFeed ? "\r\n" : "\n";
 	const lines = printed.split(/\r?\n/);
 	if (lines.length <= 1) return printed;
+	const printedIndentUnit = Math.min(...lines.slice(1).map((line) => line.match(/^ */)?.[0].length ?? 0).filter((indent) => indent > 0), 4);
 	return lines.map((line, index) => {
 		if (index === 0) return line;
 		if (line.trim() === "") return "";
 		const leadingSpaces = line.match(/^ */)?.[0].length ?? 0;
-		const indentLevel = Math.floor(leadingSpaces / 4);
+		const indentLevel = Math.floor(leadingSpaces / printedIndentUnit);
 		return `${formatting.baseIndent}${formatting.indentUnit.repeat(indentLevel)}${line.slice(leadingSpaces)}`;
 	}).join(lineSeparator);
 }
@@ -3075,7 +3445,12 @@ function valueToExpression(value, existingExpression) {
 	}
 	if (isMachineConfig(value)) {
 		const existingObject = existingExpression && ts$1.isObjectLiteralExpression(existingExpression) ? existingExpression : void 0;
-		const properties = Object.entries(value).filter(([, propertyValue]) => propertyValue !== void 0).map(([key, propertyValue]) => {
+		const entries = Object.entries(value).filter(([, propertyValue]) => propertyValue !== void 0);
+		if (existingObject) {
+			const existingOrder = new Map(existingObject.properties.map((property, index) => [getStatePropertyKeyText(property), index]));
+			entries.sort(([left], [right]) => (existingOrder.get(left) ?? Number.MAX_SAFE_INTEGER) - (existingOrder.get(right) ?? Number.MAX_SAFE_INTEGER));
+		}
+		const properties = entries.map(([key, propertyValue]) => {
 			const existingProperty = existingObject ? getPropertyAssignment(existingObject, key) : null;
 			const nextInitializer = getPreservedPropertyInitializer(key, propertyValue, existingProperty?.initializer) ?? valueToExpression(propertyValue, existingProperty?.initializer);
 			if (existingProperty) return ts$1.factory.updatePropertyAssignment(existingProperty, existingProperty.name, nextInitializer);
@@ -3100,6 +3475,11 @@ function isRawCodeLike(value) {
 	const raw = value;
 	return raw.constructor?.name === "RawCode" && typeof raw.code === "string";
 }
+function containsRawCodeLike(value) {
+	if (isRawCodeLike(value)) return true;
+	if (Array.isArray(value)) return value.some(containsRawCodeLike);
+	return Boolean(value) && typeof value === "object" && Object.values(value).some(containsRawCodeLike);
+}
 function inlineExpressionDirectiveToExpression(value) {
 	if (!isInlineExpressionDirective(value)) return null;
 	return ts$1.factory.createIdentifier(value.expr);
@@ -3165,11 +3545,12 @@ const xstateAdapter = {
 		return collectXStateSourceLocations(text, document, options);
 	},
 	async applyMachineToDocument(machineConfig, document, options) {
-		const rootSourceLocation = collectXStateSourceLocations(document.getText(), document, { machineIndex: options?.machineIndex })?.root ?? options?.sourceLocations?.root;
+		const detectedSourceLocations = collectXStateSourceLocations(document.getText(), document, { machineIndex: options?.machineIndex });
+		const rootSourceLocation = options?.sourceLocations?.root ?? detectedSourceLocations?.root;
 		const sanitizedMachineConfig = options?.preserveStatelyMetadata === false ? stripStatelyMetadata(machineConfig) : machineConfig;
 		if (!options?.patches?.length) return [];
 		const replacements = await applyMachineToSourceDocuments(sanitizedMachineConfig, document, options);
-		if (replacements.some(containsXStateExpressionPlaceholder) || replacements.some((replacement) => isImplicitRootReplacement(replacement, rootSourceLocation))) return [];
+		if (replacements.some(containsXStateExpressionPlaceholder) || options?.sourceUpdateStrategy !== "rewrite" && replacements.some((replacement) => isImplicitRootReplacement(replacement, rootSourceLocation))) return [];
 		return replacements;
 	}
 };
@@ -3503,7 +3884,7 @@ async function extractMachinesFromLocalSource(sourcePath, contents, machineIndex
 		return { machines: extractMachineConfigsFromAst(sourcePath, parseSourceToMachine(contents, createTextDocument(sourcePath, contents), {
 			machineIndex,
 			resolver: createFileSourceDocumentResolver()
-		}), machineIndex) };
+		}), machineIndex === void 0 ? void 0 : 0) };
 	} catch (error) {
 		return {
 			machines: [],

package/dist/{version-DC3yW9Dk.mjs → version-B6OHpDiz.mjs}

@@ -365,7 +365,7 @@ function createWebSocketTransport(options) {
 
 //#endregion
 //#region src/version.ts
-const SDK_VERSION = "0.29.1";
+const SDK_VERSION = "0.31.1";
 function inspectionRuntime() {
 	if (typeof window !== "undefined") return "browser";
 	if (typeof process !== "undefined" && process.versions?.node) return "node";