@statelyai/sdk 0.31.0 → 0.31.1

package/dist/sync.mjs

@@ -1,6 +1,6 @@
 import "./openapi-BTDjYWXd.mjs";
 import { r as createStatelyClient } from "./studio-rSI54Ese.mjs";
-import { a as detectXStateSourceProfile, c as extractXStateMachineConfigEntries, d as graphToMachineConfig, g as normalizeMachineProfile, o as diffGraphsSemantically, p as graphToXStateTS, r as alignCompareGraphIds, t as INLINE_EXPRESSION_DIRECTIVE_FIELDS, u as graphChangeToPatchesResult, v as serializeJS } from "./dist-BQEaIgBI.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";
@@ -1248,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();
@@ -1302,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;
@@ -1329,7 +1441,7 @@ async function createTransitionReplacementForDocuments(document, sourceFile, mac
 	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);
@@ -1340,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));
@@ -1359,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;
@@ -1370,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;
@@ -1390,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: [],
@@ -1481,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);
@@ -1963,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*\}$/, "");
@@ -2391,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) {
@@ -2410,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);
@@ -3048,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);
 }
@@ -3121,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);
@@ -3146,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);

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/sdk",
-  "version": "0.31.0",
+  "version": "0.31.1",
   "license": "MIT",
   "bin": {
     "stately-sdk": "./dist/bin.mjs"
@@ -93,8 +93,8 @@
     "jsdom": "^27.4.0",
     "tsdown": "0.21.0-beta.2",
     "vitest": "^3.2.4",
-    "@statelyai/api-contract": "0.4.5",
-    "@statelyai/graph-tools": "0.8.1"
+    "@statelyai/api-contract": "0.4.7",
+    "@statelyai/graph-tools": "0.8.3"
   },
   "engines": {
     "node": ">=22.4"