@statelyai/sdk 0.26.3 → 0.27.1

package/dist/sync.mjs

@@ -1,10 +1,10 @@
 import "./openapi-BTDjYWXd.mjs";
-import { r as createStatelyClient } from "./studio-iNSHtNmP.mjs";
-import { f as normalizeMachineProfile, h as xstateSourceToConfig, i as INLINE_EXPRESSION_DIRECTIVE_FIELDS, m as serializeJS, n as getStatelyPragma, r as upsertStatelyPragma, s as detectXStateSourceProfile, t as findStatelyPragmaAttachments, u as graphToXStateTS } from "./statelyPragma-B-axv279.mjs";
+import { r as createStatelyClient } from "./studio-CNkxMZyz.mjs";
+import { _ as normalizeMachineProfile, b as xstateSourceToConfig, 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, y as serializeJS } from "./statelyPragma-ByF0-L-N.mjs";
 import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
-import { getDiff, isEmptyDiff } from "@statelyai/graph";
+import { isEmptyDiff } from "@statelyai/graph";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { execFile } from "node:child_process";
@@ -50,6 +50,17 @@ function createTextDocument(fileName, text, uri = path$1.isAbsolute(fileName) ?
 		}
 	};
 }
+function applyReplacementsToText(text, replacements) {
+	let updated = text;
+	const sorted = [...replacements].sort(compareReplacementRangesDescending$1);
+	for (const replacement of sorted) {
+		const lineStarts = getLineStarts(updated);
+		const start = offsetAt(lineStarts, replacement.range.startLine, replacement.range.startChar);
+		const end = offsetAt(lineStarts, replacement.range.endLine, replacement.range.endChar);
+		updated = `${updated.slice(0, start)}${replacement.newText}${updated.slice(end)}`;
+	}
+	return updated;
+}
 function sourceUriToFileName(uriOrPath) {
 	if (uriOrPath.startsWith("file://")) return fileURLToPath(uriOrPath);
 	if (/^[a-z][a-z\d+.-]*:/i.test(uriOrPath)) throw new Error(`Unsupported non-file URI: ${uriOrPath}`);
@@ -133,17 +144,26 @@ function getLineStarts(text) {
 	for (let index = 0; index < text.length; index += 1) if (text.charCodeAt(index) === 10) lineStarts.push(index + 1);
 	return lineStarts;
 }
+function offsetAt(lineStarts, line, character) {
+	const lineStart = lineStarts[line];
+	if (lineStart === void 0) return lineStarts[lineStarts.length - 1] + character;
+	return lineStart + character;
+}
+function compareReplacementRangesDescending$1(left, right) {
+	if (left.range.startLine !== right.range.startLine) return right.range.startLine - left.range.startLine;
+	return right.range.startChar - left.range.startChar;
+}
 
 //#endregion
 //#region ../editor-sync/src/internal/sourceLocations.ts
 const sourceFileUris = /* @__PURE__ */ new WeakMap();
 function collectXStateSourceLocations(sourceText, document, options = {}) {
-	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
+	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$3(document.fileName));
 	const uri = document.uri?.toString() ?? document.fileName;
 	sourceFileUris.set(sourceFile, uri);
 	const bindings = collectBindings(sourceFile, uri, document.fileName, options);
 	const staticValues = collectStaticValueBindings(sourceFile);
-	const root = findMachineConfigObjectLiteral(sourceFile, bindings);
+	const root = findMachineConfigObjectLiteral$1(sourceFile, bindings, options.machineIndex);
 	if (!root) return;
 	const states = [];
 	const statesObjectLocations = [];
@@ -250,11 +270,11 @@ function parseRangePart(value) {
 }
 function collectImportedXStateTransitionSources(sourceText, document, options = {}) {
 	if (!options.resolver) return [];
-	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
+	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$3(document.fileName));
 	const uri = document.uri?.toString() ?? document.fileName;
 	sourceFileUris.set(sourceFile, uri);
 	const bindings = collectBindings(sourceFile, uri, document.fileName, options);
-	const root = findMachineConfigObjectLiteral(sourceFile, bindings);
+	const root = findMachineConfigObjectLiteral$1(sourceFile, bindings, options.machineIndex);
 	if (!root) return [];
 	return [...collectResolvedTransitionFunctions(root, bindings)].flatMap(([localName, resolved]) => {
 		const { binding } = resolved;
@@ -326,7 +346,7 @@ function collectTopLevelBindings(sourceFile, uri) {
 		if (!ts$1.isVariableStatement(statement)) continue;
 		for (const declaration of statement.declarationList.declarations) {
 			if (!ts$1.isIdentifier(declaration.name) || !declaration.initializer) continue;
-			const initializer = unwrapExpression$1(declaration.initializer);
+			const initializer = unwrapExpression$2(declaration.initializer);
 			if (ts$1.isArrowFunction(initializer) || ts$1.isFunctionExpression(initializer)) {
 				bindings.set(declaration.name.text, {
 					kind: "transitionFunction",
@@ -337,7 +357,7 @@ function collectTopLevelBindings(sourceFile, uri) {
 				});
 				continue;
 			}
-			const objectLiteral = unwrapObjectLiteralExpression(declaration.initializer);
+			const objectLiteral = unwrapObjectLiteralExpression$1(declaration.initializer);
 			if (objectLiteral) {
 				bindings.set(declaration.name.text, {
 					kind: "objectReference",
@@ -372,7 +392,7 @@ function addImportedBindings(bindings, sourceFile, uri, fileName, options, cache
 			uri
 		}, statement.moduleSpecifier.text);
 		if (!importedDocument) continue;
-		const importedSourceFile = ts$1.createSourceFile(importedDocument.fileName, importedDocument.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(importedDocument.fileName));
+		const importedSourceFile = ts$1.createSourceFile(importedDocument.fileName, importedDocument.text, ts$1.ScriptTarget.Latest, true, getScriptKind$3(importedDocument.fileName));
 		sourceFileUris.set(importedSourceFile, importedDocument.uri);
 		const importedBindings = collectBindings(importedSourceFile, importedDocument.uri, importedDocument.fileName, options, cache);
 		for (const element of namedBindings.elements) {
@@ -385,7 +405,7 @@ function addImportedBindings(bindings, sourceFile, uri, fileName, options, cache
 function collectResolvedTransitionFunctions(root, bindings) {
 	const found = /* @__PURE__ */ new Map();
 	const visitExpression = (expression, sourcePath) => {
-		const current = unwrapExpression$1(expression);
+		const current = unwrapExpression$2(expression);
 		if (ts$1.isIdentifier(current)) {
 			const binding = bindings.get(current.text);
 			if (binding?.kind === "transitionFunction") {
@@ -422,30 +442,34 @@ function collectResolvedTransitionFunctions(root, bindings) {
 			"onSnapshot",
 			"onTimeout"
 		]) {
-			const property = state.properties.find((candidate) => ts$1.isPropertyAssignment(candidate) && getPropertyNameText$1(candidate.name) === propertyName);
+			const property = state.properties.find((candidate) => ts$1.isPropertyAssignment(candidate) && getPropertyNameText$2(candidate.name) === propertyName);
 			if (property) visitExpression(property.initializer, sourcePath);
 		}
-		const states = state.properties.find((candidate) => ts$1.isPropertyAssignment(candidate) && getPropertyNameText$1(candidate.name) === "states");
-		const statesObject = states && unwrapObjectLiteralExpression(states.initializer);
+		const states = state.properties.find((candidate) => ts$1.isPropertyAssignment(candidate) && getPropertyNameText$2(candidate.name) === "states");
+		const statesObject = states && unwrapObjectLiteralExpression$1(states.initializer);
 		if (!statesObject) return;
 		for (const property of statesObject.properties) {
 			if (!ts$1.isPropertyAssignment(property)) continue;
-			const child = unwrapObjectLiteralExpression(property.initializer);
-			const key = getPropertyNameText$1(property.name);
+			const child = unwrapObjectLiteralExpression$1(property.initializer);
+			const key = getPropertyNameText$2(property.name);
 			if (child && key) visitState(child, [...sourcePath, key]);
 		}
 	};
 	visitState(root, []);
 	return found;
 }
-function findMachineConfigObjectLiteral(sourceFile, bindings) {
+function findMachineConfigObjectLiteral$1(sourceFile, bindings, machineIndex = 0) {
 	let found = null;
+	let currentMachineIndex = 0;
 	const visit = (node) => {
 		if (found) return;
-		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1(node.expression)) {
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression$2(node.expression)) {
+			const isSelectedMachine = currentMachineIndex === machineIndex;
+			currentMachineIndex += 1;
+			if (!isSelectedMachine) return;
 			const [firstArgument] = node.arguments;
 			if (!firstArgument || !ts$1.isExpression(firstArgument)) return;
-			found = unwrapObjectLiteralExpression(firstArgument) ?? resolveIdentifierObject(firstArgument, bindings);
+			found = unwrapObjectLiteralExpression$1(firstArgument) ?? resolveIdentifierObject(firstArgument, bindings);
 			return;
 		}
 		ts$1.forEachChild(node, visit);
@@ -502,7 +526,7 @@ function resolveStateProperty(property, bindings, staticValues, root) {
 	if (!ts$1.isPropertyAssignment(property)) return null;
 	const resolvedKey = resolvePropertyKey(property.name, staticValues, root);
 	if (!resolvedKey) return null;
-	const inlineObject = unwrapObjectLiteralExpression(property.initializer);
+	const inlineObject = unwrapObjectLiteralExpression$1(property.initializer);
 	if (inlineObject) return {
 		key: resolvedKey.key,
 		kind: "inline",
@@ -537,19 +561,19 @@ function getSourceFileUri(sourceFile) {
 	return sourceFileUris.get(sourceFile) ?? sourceFile.fileName;
 }
 function unwrapCreateConfigArgument(expression) {
-	const unwrapped = unwrapExpression$1(expression);
+	const unwrapped = unwrapExpression$2(expression);
 	if (!ts$1.isCallExpression(unwrapped)) return null;
 	const callee = unwrapped.expression;
 	if (!ts$1.isPropertyAccessExpression(callee) || !isSetupCreateConfigName(callee.name.text)) return null;
 	const [firstArgument] = unwrapped.arguments;
 	if (!firstArgument || !ts$1.isExpression(firstArgument)) return null;
-	return unwrapObjectLiteralExpression(firstArgument);
+	return unwrapObjectLiteralExpression$1(firstArgument);
 }
 function isSetupCreateConfigName(name) {
 	return /^create[A-Z_$][\w$]*Config$/.test(name);
 }
 function resolveIdentifierObject(expression, bindings) {
-	const unwrapped = unwrapExpression$1(expression);
+	const unwrapped = unwrapExpression$2(expression);
 	if (!ts$1.isIdentifier(unwrapped)) return null;
 	const binding = bindings.get(unwrapped.text);
 	return binding?.kind === "objectReference" ? binding.node : null;
@@ -557,8 +581,8 @@ function resolveIdentifierObject(expression, bindings) {
 function resolveObjectLiteralProperty(objectLiteral, propertyName, bindings) {
 	for (const property of objectLiteral.properties) {
 		if (!ts$1.isPropertyAssignment(property)) continue;
-		if (getPropertyNameText$1(property.name) !== propertyName) continue;
-		const inlineObject = unwrapObjectLiteralExpression(property.initializer);
+		if (getPropertyNameText$2(property.name) !== propertyName) continue;
+		const inlineObject = unwrapObjectLiteralExpression$1(property.initializer);
 		if (inlineObject) return {
 			object: inlineObject,
 			kind: "inline",
@@ -585,7 +609,7 @@ function resolveObjectLiteralProperty(objectLiteral, propertyName, bindings) {
 	}
 	return null;
 }
-function getPropertyNameText$1(name) {
+function getPropertyNameText$2(name) {
 	if (ts$1.isIdentifier(name) || ts$1.isStringLiteral(name) || ts$1.isNumericLiteral(name)) return name.text;
 	if (ts$1.isComputedPropertyName(name)) {
 		const expression = name.expression;
@@ -594,7 +618,7 @@ function getPropertyNameText$1(name) {
 	return null;
 }
 function resolvePropertyKey(name, staticValues, root) {
-	const literalKey = getPropertyNameText$1(name);
+	const literalKey = getPropertyNameText$2(name);
 	if (literalKey !== null) {
 		if (ts$1.isComputedPropertyName(name)) return {
 			key: literalKey,
@@ -618,7 +642,7 @@ function resolvePropertyKey(name, staticValues, root) {
 	};
 }
 function getStaticValueBindingForExpression(expression, staticValues) {
-	const unwrapped = unwrapExpression$1(expression);
+	const unwrapped = unwrapExpression$2(expression);
 	if (ts$1.isIdentifier(unwrapped)) return staticValues.get(unwrapped.text) ?? null;
 	if (ts$1.isPropertyAccessExpression(unwrapped) && ts$1.isIdentifier(unwrapped.expression)) return staticValues.get(`${unwrapped.expression.text}.${unwrapped.name.text}`) ?? null;
 	return null;
@@ -692,10 +716,10 @@ function isStateKeyComputedPropertyName(name) {
 	if (!ts$1.isObjectLiteralExpression(objectLiteral)) return false;
 	const parentProperty = objectLiteral.parent;
 	if (!ts$1.isPropertyAssignment(parentProperty)) return false;
-	return getPropertyNameText$1(parentProperty.name) === "states";
+	return getPropertyNameText$2(parentProperty.name) === "states";
 }
 function getStaticStringValue(expression) {
-	const unwrapped = unwrapExpression$1(expression);
+	const unwrapped = unwrapExpression$2(expression);
 	if (ts$1.isStringLiteral(unwrapped) || ts$1.isNoSubstitutionTemplateLiteral(unwrapped) || ts$1.isNumericLiteral(unwrapped)) return unwrapped.text;
 	return null;
 }
@@ -703,15 +727,15 @@ function getEnumMemberName(name) {
 	if (ts$1.isIdentifier(name) || ts$1.isStringLiteral(name) || ts$1.isNumericLiteral(name)) return name.text;
 	return null;
 }
-function isCreateMachineExpression$1(expression) {
+function isCreateMachineExpression$2(expression) {
 	const isMachineFactoryName = (name) => name === "createMachine" || name === "createMachineFromConfig";
 	return ts$1.isIdentifier(expression) && isMachineFactoryName(expression.text) || ts$1.isPropertyAccessExpression(expression) && isMachineFactoryName(expression.name.text);
 }
-function unwrapObjectLiteralExpression(expression) {
-	const unwrapped = unwrapExpression$1(expression);
+function unwrapObjectLiteralExpression$1(expression) {
+	const unwrapped = unwrapExpression$2(expression);
 	return ts$1.isObjectLiteralExpression(unwrapped) ? unwrapped : null;
 }
-function unwrapExpression$1(expression) {
+function unwrapExpression$2(expression) {
 	let current = expression;
 	for (;;) {
 		if (ts$1.isParenthesizedExpression(current)) {
@@ -739,7 +763,7 @@ function toSourceRange$1(sourceFile, node) {
 		endChar: end.character
 	};
 }
-function getScriptKind$2(fileName) {
+function getScriptKind$3(fileName) {
 	if (fileName.endsWith(".tsx")) return ts$1.ScriptKind.TSX;
 	if (fileName.endsWith(".jsx")) return ts$1.ScriptKind.JSX;
 	if (fileName.endsWith(".js")) return ts$1.ScriptKind.JS;
@@ -820,12 +844,12 @@ function readHydratedStatesObject(uri, range, states, resolver) {
 	return applySourceRangeReplacementsToSlice(document.text, range, replacements);
 }
 function applySourceRangeReplacementsToSlice(text, range, replacements) {
-	const sliceStart = offsetAtRangePosition(text, range.startLine, range.startChar);
-	const sliceEnd = offsetAtRangePosition(text, range.endLine, range.endChar);
+	const sliceStart = offsetAtRangePosition$2(text, range.startLine, range.startChar);
+	const sliceEnd = offsetAtRangePosition$2(text, range.endLine, range.endChar);
 	let updated = text.slice(sliceStart, sliceEnd);
 	for (const replacement of replacements.sort(compareSourceRangesDescending)) {
-		const start = offsetAtRangePosition(text, replacement.range.startLine, replacement.range.startChar);
-		const end = offsetAtRangePosition(text, replacement.range.endLine, replacement.range.endChar);
+		const start = offsetAtRangePosition$2(text, replacement.range.startLine, replacement.range.startChar);
+		const end = offsetAtRangePosition$2(text, replacement.range.endLine, replacement.range.endChar);
 		if (start < sliceStart || end > sliceEnd) continue;
 		const localStart = start - sliceStart;
 		const localEnd = end - sliceStart;
@@ -835,7 +859,7 @@ function applySourceRangeReplacementsToSlice(text, range, replacements) {
 }
 function collectHydratedImportReplacements(text, document, hydratedSymbols) {
 	if (hydratedSymbols.size === 0) return [];
-	const sourceFile = ts$1.createSourceFile(document.fileName, text, ts$1.ScriptTarget.Latest, true, getScriptKind$1(document.fileName));
+	const sourceFile = ts$1.createSourceFile(document.fileName, text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
 	const replacements = [];
 	for (const statement of sourceFile.statements) {
 		if (!ts$1.isImportDeclaration(statement) || !ts$1.isStringLiteral(statement.moduleSpecifier)) continue;
@@ -866,7 +890,7 @@ function toSourceRange(sourceFile, node, options = {}) {
 		endChar: end.character
 	};
 }
-function getScriptKind$1(fileName) {
+function getScriptKind$2(fileName) {
 	if (fileName.endsWith(".tsx")) return ts$1.ScriptKind.TSX;
 	if (fileName.endsWith(".jsx")) return ts$1.ScriptKind.JSX;
 	if (fileName.endsWith(".js")) return ts$1.ScriptKind.JS;
@@ -875,10 +899,10 @@ function getScriptKind$1(fileName) {
 function removeOverlappingRanges(replacement, index, replacements) {
 	return !replacements.some((candidate, candidateIndex) => {
 		if (candidateIndex === index) return false;
-		return compareSourceRangesDescending(candidate, replacement) < 0 && rangesOverlap(candidate.range, replacement.range);
+		return compareSourceRangesDescending(candidate, replacement) < 0 && rangesOverlap$1(candidate.range, replacement.range);
 	});
 }
-function rangesOverlap(left, right) {
+function rangesOverlap$1(left, right) {
 	const leftStart = rangePositionKey(left.startLine, left.startChar);
 	const leftEnd = rangePositionKey(left.endLine, left.endChar);
 	const rightStart = rangePositionKey(right.startLine, right.startChar);
@@ -891,22 +915,22 @@ function areSourceRangesEqual(left, right) {
 	return left.startLine === right.startLine && left.startChar === right.startChar && left.endLine === right.endLine && left.endChar === right.endChar;
 }
 function canHydrateShorthandState(text, range) {
-	const end = offsetAtRangePosition(text, range.endLine, range.endChar);
+	const end = offsetAtRangePosition$2(text, range.endLine, range.endChar);
 	return text.slice(end).match(/\S/)?.[0] !== ":";
 }
 function readSourceRange(uri, range, resolver) {
 	if (!resolver) return null;
 	const document = resolver.read(uri);
 	if (!document) return null;
-	const start = offsetAtRangePosition(document.text, range.startLine, range.startChar);
-	const end = offsetAtRangePosition(document.text, range.endLine, range.endChar);
+	const start = offsetAtRangePosition$2(document.text, range.startLine, range.startChar);
+	const end = offsetAtRangePosition$2(document.text, range.endLine, range.endChar);
 	return document.text.slice(start, end);
 }
 function applySourceRangeReplacements(text, replacements) {
 	let updated = text;
 	for (const replacement of replacements) {
-		const start = offsetAtRangePosition(updated, replacement.range.startLine, replacement.range.startChar);
-		const end = offsetAtRangePosition(updated, replacement.range.endLine, replacement.range.endChar);
+		const start = offsetAtRangePosition$2(updated, replacement.range.startLine, replacement.range.startChar);
+		const end = offsetAtRangePosition$2(updated, replacement.range.endLine, replacement.range.endChar);
 		updated = `${updated.slice(0, start)}${replacement.newText}${updated.slice(end)}`;
 	}
 	return updated;
@@ -915,7 +939,7 @@ function compareSourceRangesDescending(left, right) {
 	if (left.range.startLine !== right.range.startLine) return right.range.startLine - left.range.startLine;
 	return right.range.startChar - left.range.startChar;
 }
-function offsetAtRangePosition(text, line, character) {
+function offsetAtRangePosition$2(text, line, character) {
 	if (line <= 0) return character;
 	let currentLine = 0;
 	for (let index = 0; index < text.length; index += 1) {
@@ -927,227 +951,2786 @@ function offsetAtRangePosition(text, line, character) {
 }
 
 //#endregion
-//#region src/sync.ts
-const execFileAsync = promisify(execFile);
-const MAX_CAPTURED_LOCAL_MACHINES = 100;
-const INLINE_EXPRESSION_FIELD_SET = new Set(INLINE_EXPRESSION_DIRECTIVE_FIELDS);
-async function extractMachinesFromLocalSource(sourcePath, contents) {
+//#region ../editor-sync/src/internal/editTargets.ts
+function createSourceFile(document, sourceText) {
+	return ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$1(document.fileName));
+}
+function getMappedRootObjectLiteral(document, sourceFile, sourceLocations) {
+	if (!sourceLocations?.root || !isSourceLocationForDocument(sourceLocations.root.uri, document)) return null;
+	return findObjectLiteralByRange(sourceFile, sourceLocations.root.range);
+}
+function getMappedStateObjectLiteral(document, sourceFile, sourceLocations, path) {
+	if (!sourceLocations) return null;
+	const location = sourceLocations.states.find((item) => arePathsEqual$1(item.path, path));
+	if (!location || !isSourceLocationForDocument(location.uri, document)) return null;
+	return findObjectLiteralByRange(sourceFile, location.range);
+}
+async function getMappedStateReplacementTarget(rootDocument, rootSourceFile, sourceLocations, path, openTextDocument) {
+	if (!sourceLocations) return null;
+	const location = sourceLocations.states.find((item) => arePathsEqual$1(item.path, path));
+	if (!location) return null;
+	return getObjectTargetFromLocation(rootDocument, rootSourceFile, location.uri, location.range, openTextDocument);
+}
+function getStateMembershipParentTarget(document, sourceFile, machineConfigNode, sourceLocations, parentPath, getStateObjectLiteralByPath) {
+	if (parentPath.length === 0) return getMappedStatesObjectTarget(document, sourceFile, sourceLocations) ?? {
+		document,
+		sourceFile,
+		node: machineConfigNode,
+		nodeKind: "machineConfig"
+	};
+	const node = getMappedStateObjectLiteral(document, sourceFile, sourceLocations, parentPath) ?? getStateObjectLiteralByPath(machineConfigNode, parentPath);
+	return node ? {
+		document,
+		sourceFile,
+		node,
+		nodeKind: "machineConfig"
+	} : null;
+}
+async function getStateMembershipParentTargetForDocuments(document, sourceFile, machineConfigNode, sourceLocations, parentPath, openTextDocument, getStateObjectLiteralByPath) {
+	if (parentPath.length === 0) return await getMappedStatesObjectTargetForDocuments(document, sourceFile, sourceLocations, openTextDocument) ?? {
+		document,
+		sourceFile,
+		node: machineConfigNode,
+		nodeKind: "machineConfig"
+	};
+	const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, parentPath, openTextDocument);
+	if (mappedTarget) return {
+		...mappedTarget,
+		nodeKind: "machineConfig"
+	};
+	const node = getStateObjectLiteralByPath(machineConfigNode, parentPath);
+	return node ? {
+		document,
+		sourceFile,
+		node,
+		nodeKind: "machineConfig"
+	} : null;
+}
+async function openDocumentBySourceUri(uri, openTextDocument) {
+	if (!openTextDocument) return null;
 	try {
-		return { machines: extractMachineConfigsFromAst(sourcePath, parseSourceToMachine(contents, createTextDocument(sourcePath, contents), { resolver: createFileSourceDocumentResolver() })) };
-	} catch (error) {
-		return {
-			machines: [],
-			error: error instanceof Error ? error.message : String(error)
-		};
+		return await openTextDocument(uri);
+	} catch {
+		return null;
 	}
 }
-function isInvalidLocalMachineDefinitionError(message) {
-	return /No initial state specified for compound state node/.test(message) || /Try adding \{\s*initial:\s*['"`]/.test(message);
-}
-function formatLocalMachineExtractionIssue(message) {
-	if (isInvalidLocalMachineDefinitionError(message)) return `Invalid local machine definition: ${message}`;
-	return `Could not extract a local machine from this file: ${message}`;
+function isSourceLocationForDocument(uri, document) {
+	return uri === (typeof document.uri === "string" ? document.uri : document.uri?.toString()) || uri === document.fileName;
 }
-function extractMachineConfigsFromAst(fileName, sourceText) {
-	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(fileName));
-	const bindings = collectLocalBindings(sourceFile);
-	const machines = [];
+function findObjectLiteralByRange(sourceFile, range) {
+	const start = offsetAtRangePosition$1(sourceFile.text, range.startLine, range.startChar);
+	const end = offsetAtRangePosition$1(sourceFile.text, range.endLine, range.endChar);
+	let found = null;
 	const visit = (node) => {
-		if (machines.length >= MAX_CAPTURED_LOCAL_MACHINES) return;
-		if (!ts.isCallExpression(node) || !isCreateMachineExpression(node.expression)) {
-			ts.forEachChild(node, visit);
+		if (found) return;
+		if (ts$1.isObjectLiteralExpression(node) && node.getStart(sourceFile) === start && node.getEnd() >= end) {
+			found = node;
 			return;
 		}
-		const [firstArgument] = node.arguments;
-		if (!firstArgument || !ts.isExpression(firstArgument)) return;
-		const config = evaluateExpression(firstArgument, sourceFile, bindings, /* @__PURE__ */ new Set());
-		if (!config || typeof config !== "object" || Array.isArray(config)) return;
-		machines.push({
-			config,
-			_type: ts.isPropertyAccessExpression(unwrapExpression(node.expression)) ? "setup.createMachine" : "createMachine"
-		});
+		ts$1.forEachChild(node, visit);
 	};
-	ts.forEachChild(sourceFile, visit);
-	return machines;
+	visit(sourceFile);
+	return found;
 }
-function collectLocalBindings(sourceFile) {
-	const bindings = /* @__PURE__ */ new Map();
-	for (const statement of sourceFile.statements) {
-		if (ts.isVariableStatement(statement)) {
-			for (const declaration of statement.declarationList.declarations) {
-				if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
-				bindings.set(declaration.name.text, {
-					kind: "value",
-					expression: declaration.initializer
-				});
-			}
-			continue;
-		}
-		if (!ts.isEnumDeclaration(statement)) continue;
-		let nextNumericValue = 0;
-		for (const member of statement.members) {
-			const memberName = getPropertyNameText(member.name);
-			if (!memberName) continue;
-			const symbol = `${statement.name.text}.${memberName}`;
-			if (!member.initializer) {
-				bindings.set(symbol, {
-					kind: "enumMember",
-					value: nextNumericValue
-				});
-				nextNumericValue += 1;
-				continue;
-			}
-			const value = evaluateExpression(member.initializer, sourceFile, bindings, /* @__PURE__ */ new Set());
-			if (typeof value === "string" || typeof value === "number") {
-				bindings.set(symbol, {
-					kind: "enumMember",
-					value
-				});
-				if (typeof value === "number") nextNumericValue = value + 1;
-			}
+function getMappedStatesObjectTarget(rootDocument, rootSourceFile, sourceLocations) {
+	const location = sourceLocations?.statesObject;
+	if (!location || !isSourceLocationForDocument(location.uri, rootDocument)) return null;
+	const node = findObjectLiteralByRange(rootSourceFile, location.range);
+	return node ? {
+		document: rootDocument,
+		sourceFile: rootSourceFile,
+		node,
+		nodeKind: "statesObject"
+	} : null;
+}
+async function getMappedStatesObjectTargetForDocuments(rootDocument, rootSourceFile, sourceLocations, openTextDocument) {
+	const location = sourceLocations?.statesObject;
+	if (!location) return null;
+	const target = await getObjectTargetFromLocation(rootDocument, rootSourceFile, location.uri, location.range, openTextDocument);
+	return target ? {
+		...target,
+		nodeKind: "statesObject"
+	} : null;
+}
+async function getObjectTargetFromLocation(rootDocument, rootSourceFile, uri, range, openTextDocument) {
+	const targetDocument = isSourceLocationForDocument(uri, rootDocument) ? rootDocument : await openDocumentBySourceUri(uri, openTextDocument);
+	if (!targetDocument) return null;
+	const targetSourceFile = isSourceLocationForDocument(uri, rootDocument) ? rootSourceFile : createSourceFile(targetDocument, targetDocument.getText());
+	const node = findObjectLiteralByRange(targetSourceFile, range);
+	if (!node) return null;
+	return {
+		document: targetDocument,
+		sourceFile: targetSourceFile,
+		node
+	};
+}
+function getScriptKind$1(fileName) {
+	if (fileName.endsWith(".tsx")) return ts$1.ScriptKind.TSX;
+	if (fileName.endsWith(".jsx")) return ts$1.ScriptKind.JSX;
+	if (fileName.endsWith(".js")) return ts$1.ScriptKind.JS;
+	return ts$1.ScriptKind.TS;
+}
+function arePathsEqual$1(left, right) {
+	return left.length === right.length && left.every((segment, index) => segment === right[index]);
+}
+function offsetAtRangePosition$1(sourceText, line, character) {
+	let currentLine = 0;
+	let lineStart = 0;
+	for (let index = 0; index < sourceText.length; index += 1) {
+		if (currentLine === line) return Math.min(lineStart + character, sourceText.length);
+		if (sourceText.charCodeAt(index) === 10) {
+			currentLine += 1;
+			lineStart = index + 1;
 		}
 	}
-	return bindings;
+	return Math.min(lineStart + character, sourceText.length);
 }
-function evaluateExpression(expression, sourceFile, bindings, seenBindings) {
-	const unwrapped = unwrapExpression(expression);
-	if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped)) return unwrapped.text;
-	if (ts.isNumericLiteral(unwrapped)) return Number(unwrapped.text);
-	if (unwrapped.kind === ts.SyntaxKind.TrueKeyword) return true;
-	if (unwrapped.kind === ts.SyntaxKind.FalseKeyword) return false;
-	if (unwrapped.kind === ts.SyntaxKind.NullKeyword) return null;
-	if (ts.isIdentifier(unwrapped)) {
-		if (unwrapped.text === "undefined") return;
-		const binding = bindings.get(unwrapped.text);
-		if (!binding || binding.kind !== "value" || seenBindings.has(unwrapped.text)) return unwrapped.getText(sourceFile);
-		const nextSeen = new Set(seenBindings);
-		nextSeen.add(unwrapped.text);
-		return evaluateExpression(binding.expression, sourceFile, bindings, nextSeen);
-	}
-	if (ts.isPropertyAccessExpression(unwrapped) && ts.isIdentifier(unwrapped.expression)) {
-		const binding = bindings.get(`${unwrapped.expression.text}.${unwrapped.name.text}`);
-		if (binding?.kind === "enumMember") return binding.value;
-		return unwrapped.getText(sourceFile);
+
+//#endregion
+//#region ../editor-sync/src/internal/graphToCode.ts
+function applyMachineToSource(machineConfig, document, options = {}) {
+	if (!isMachineConfig(machineConfig)) return [];
+	const sourceFile = createSourceFile(document, document.getText());
+	const machineConfigNode = findMachineConfigObjectLiteral(sourceFile, options.machineIndex);
+	if (!machineConfigNode) return [];
+	const parsedPatches = parseGraphPatches(options.patches);
+	const prevGraph = parseGraph(options.prevGraph);
+	const nextGraph = parseGraph(options.nextGraph);
+	const rootNode = getMappedRootObjectLiteral(document, sourceFile, options.sourceLocations) ?? machineConfigNode;
+	if (!parsedPatches || !prevGraph || !nextGraph || parsedPatches.length === 0) {
+		if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+		return [createReplacement(document, sourceFile, rootNode, machineConfig)];
 	}
-	if (ts.isArrayLiteralExpression(unwrapped)) return unwrapped.elements.map((element) => ts.isSpreadElement(element) ? evaluateExpression(element.expression, sourceFile, bindings, seenBindings) : evaluateExpression(element, sourceFile, bindings, seenBindings));
-	if (ts.isObjectLiteralExpression(unwrapped)) {
-		const result = {};
-		for (const property of unwrapped.properties) {
-			if (ts.isSpreadAssignment(property)) {
-				const spreadValue = evaluateExpression(property.expression, sourceFile, bindings, seenBindings);
-				if (spreadValue && typeof spreadValue === "object" && !Array.isArray(spreadValue)) Object.assign(result, spreadValue);
-				continue;
-			}
-			if (ts.isShorthandPropertyAssignment(property)) {
-				result[property.name.text] = evaluateExpression(property.name, sourceFile, bindings, seenBindings);
-				continue;
-			}
-			if (!ts.isPropertyAssignment(property)) continue;
-			const key = resolvePropertyNameValue(property.name, sourceFile, bindings, seenBindings);
-			if (key == null) continue;
-			const fieldName = String(key);
-			if (shouldPreserveInlineExpression(fieldName, property.initializer, sourceFile, bindings, seenBindings)) {
-				result[fieldName] = createInlineExpressionDirective(property.initializer.getText(sourceFile));
-				continue;
+	if (hasNestedStateRenameBatch(parsedPatches, prevGraph, nextGraph)) return [];
+	const semanticReplacements = tryCreateSemanticReplacements(document, sourceFile, machineConfigNode, parsedPatches, prevGraph, nextGraph);
+	if (semanticReplacements) return semanticReplacements.sort(compareReplacementRangesDescending);
+	let patchesForSplit = parsedPatches;
+	const implementationSplit = tryCreateImplementationPatchSplit(document, sourceFile, patchesForSplit, nextGraph, options.machineIndex);
+	if (implementationSplit) {
+		const implementationRemainingPatches = dropCoveredSchemaPatches(implementationSplit.remainingPatches, implementationSplit.replacements.length > 0);
+		if (implementationRemainingPatches.length === 0) return implementationSplit.replacements.sort(compareReplacementRangesDescending);
+		const remainingPlan = deriveReplacementPlan(implementationRemainingPatches, prevGraph, nextGraph);
+		if (remainingPlan.type === "root") {
+			if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+			return [createReplacement(document, sourceFile, rootNode, machineConfig)];
+		}
+		const replacements = [...implementationSplit.replacements];
+		for (const path of remainingPlan.paths) {
+			const currentNode = getMappedStateObjectLiteral(document, sourceFile, options.sourceLocations, path) ?? getStateObjectLiteralByPath(machineConfigNode, path);
+			const nextValue = getStateConfigByPath(machineConfig, path);
+			if (!currentNode || !isMachineConfig(nextValue)) {
+				if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+				return [createReplacement(document, sourceFile, rootNode, machineConfig)];
 			}
-			result[fieldName] = evaluateExpression(property.initializer, sourceFile, bindings, seenBindings);
+			replacements.push(createReplacement(document, sourceFile, currentNode, nextValue));
 		}
-		return result;
+		return replacements.sort(compareReplacementRangesDescending);
 	}
-	if (ts.isPrefixUnaryExpression(unwrapped)) {
-		const operand = evaluateExpression(unwrapped.operand, sourceFile, bindings, seenBindings);
-		if (typeof operand !== "number") return unwrapped.getText(sourceFile);
-		switch (unwrapped.operator) {
-			case ts.SyntaxKind.MinusToken: return -operand;
-			case ts.SyntaxKind.PlusToken: return operand;
-			default: return unwrapped.getText(sourceFile);
+	patchesForSplit = dropCoveredSchemaPatches(patchesForSplit, false);
+	const stateMembershipSplit = tryCreateStateMembershipPatchSplit(document, sourceFile, rootNode, machineConfig, patchesForSplit, prevGraph, nextGraph, options.sourceLocations);
+	if (stateMembershipSplit) {
+		const stateMembershipRemainingPatches = dropCoveredSchemaPatches(stateMembershipSplit.remainingPatches, stateMembershipSplit.replacements.length > 0);
+		if (stateMembershipRemainingPatches.length === 0) return stateMembershipSplit.replacements;
+		const remainingPlan = deriveReplacementPlan(stateMembershipRemainingPatches, prevGraph, nextGraph);
+		if (remainingPlan.type === "root") {
+			if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+			return [createReplacement(document, sourceFile, rootNode, machineConfig)];
 		}
-	}
-	if (ts.isTemplateExpression(unwrapped)) {
-		let value = unwrapped.head.text;
-		for (const span of unwrapped.templateSpans) {
-			const expressionValue = evaluateExpression(span.expression, sourceFile, bindings, seenBindings);
-			value += String(expressionValue ?? "");
-			value += span.literal.text;
+		const replacements = [...stateMembershipSplit.replacements];
+		for (const path of remainingPlan.paths) {
+			const currentNode = getMappedStateObjectLiteral(document, sourceFile, options.sourceLocations, path) ?? getStateObjectLiteralByPath(machineConfigNode, path);
+			const nextValue = getStateConfigByPath(machineConfig, path);
+			if (!currentNode || !isMachineConfig(nextValue)) {
+				if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+				return [createReplacement(document, sourceFile, rootNode, machineConfig)];
+			}
+			replacements.push(createReplacement(document, sourceFile, currentNode, nextValue));
 		}
-		return value;
+		return replacements.sort(compareReplacementRangesDescending);
 	}
-	return unwrapped.getText(sourceFile);
-}
-function shouldPreserveInlineExpression(fieldName, expression, sourceFile, bindings, seenBindings) {
-	if (!INLINE_EXPRESSION_FIELD_SET.has(fieldName)) return false;
-	const unwrapped = unwrapExpression(expression);
-	if (ts.isIdentifier(unwrapped)) {
-		const binding = bindings.get(unwrapped.text);
-		if (!binding || binding.kind !== "value" || seenBindings.has(unwrapped.text)) return true;
-		const nextSeen = new Set(seenBindings);
-		nextSeen.add(unwrapped.text);
-		return shouldPreserveInlineExpression(fieldName, binding.expression, sourceFile, bindings, nextSeen);
+	const plan = deriveReplacementPlan(patchesForSplit, prevGraph, nextGraph);
+	if (plan.type === "root") {
+		if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+		return [createReplacement(document, sourceFile, rootNode, machineConfig)];
 	}
-	if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped) || ts.isNumericLiteral(unwrapped) || unwrapped.kind === ts.SyntaxKind.TrueKeyword || unwrapped.kind === ts.SyntaxKind.FalseKeyword || unwrapped.kind === ts.SyntaxKind.NullKeyword || ts.isObjectLiteralExpression(unwrapped) || ts.isArrayLiteralExpression(unwrapped)) return false;
-	return unwrapped.getText(sourceFile).trim().length > 0;
+	const replacements = [];
+	for (const path of plan.paths) {
+		const currentNode = getMappedStateObjectLiteral(document, sourceFile, options.sourceLocations, path) ?? getStateObjectLiteralByPath(machineConfigNode, path);
+		const nextValue = getStateConfigByPath(machineConfig, path);
+		if (!currentNode || !isMachineConfig(nextValue)) {
+			if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+			return [createReplacement(document, sourceFile, rootNode, machineConfig)];
+		}
+		replacements.push(createReplacement(document, sourceFile, currentNode, nextValue));
+	}
+	return replacements.sort(compareReplacementRangesDescending);
 }
-function createInlineExpressionDirective(expr) {
-	return {
-		"@type": "code",
-		lang: "ts",
-		expr
+async function applyMachineToSourceDocuments(machineConfig, document, options = {}) {
+	if (!isMachineConfig(machineConfig)) return [];
+	const sourceFile = createSourceFile(document, document.getText());
+	const machineConfigNode = getMappedRootObjectLiteral(document, sourceFile, options.sourceLocations) ?? findMachineConfigObjectLiteral(sourceFile, options.machineIndex);
+	if (!machineConfigNode) return [];
+	const parsedPatches = parseGraphPatches(options.patches);
+	const prevGraph = parseGraph(options.prevGraph);
+	const nextGraph = parseGraph(options.nextGraph);
+	const finalize = (replacements) => {
+		return normalizeOverlappingReplacements(addCodeImportReplacements(document, sourceFile, machineConfig, replacements)).sort(compareReplacementRangesDescending);
 	};
+	if (!parsedPatches || !prevGraph || !nextGraph || parsedPatches.length === 0) {
+		if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+		return finalize([createReplacement(document, sourceFile, machineConfigNode, machineConfig)]);
+	}
+	if (hasNestedStateRenameBatch(parsedPatches, prevGraph, nextGraph)) return [];
+	const semanticSplit = await tryCreateSemanticPatchSplitForDocuments(document, sourceFile, machineConfigNode, parsedPatches, prevGraph, nextGraph, options.sourceLocations, options.openTextDocument);
+	if (semanticSplit && semanticSplit.remainingPatches.length === 0) return finalize(semanticSplit.replacements);
+	const activePatches = dropCoveredSchemaPatches(semanticSplit?.remainingPatches ?? parsedPatches, (semanticSplit?.replacements.length ?? 0) > 0);
+	const activeSourceLocations = semanticSplit?.sourceLocations ?? options.sourceLocations;
+	let semanticReplacements = semanticSplit?.replacements ?? [];
+	if (activePatches.length === 0) return finalize(semanticReplacements);
+	const transitionSplit = await tryCreateTransitionPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, activePatches, prevGraph, nextGraph, activeSourceLocations, options.openTextDocument);
+	if (transitionSplit && transitionSplit.remainingPatches.length === 0) return finalize([...semanticReplacements, ...transitionSplit.replacements]);
+	if (transitionSplit) semanticReplacements = [...semanticReplacements, ...transitionSplit.replacements];
+	const implementationSplit = tryCreateImplementationPatchSplit(document, sourceFile, transitionSplit?.remainingPatches ?? activePatches, nextGraph, options.machineIndex);
+	if (implementationSplit && implementationSplit.remainingPatches.length === 0) return finalize([...semanticReplacements, ...implementationSplit.replacements]);
+	if (implementationSplit) semanticReplacements = [...semanticReplacements, ...implementationSplit.replacements];
+	const patchesAfterImplementationSplit = dropCoveredSchemaPatches(implementationSplit?.remainingPatches ?? activePatches, semanticReplacements.length > 0);
+	if (patchesAfterImplementationSplit.length === 0) return finalize(semanticReplacements);
+	const stateMembershipSplit = await tryCreateStateMembershipPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patchesAfterImplementationSplit, prevGraph, nextGraph, activeSourceLocations, options.openTextDocument);
+	if (stateMembershipSplit) {
+		const stateMembershipRemainingPatches = dropCoveredSchemaPatches(stateMembershipSplit.remainingPatches, semanticReplacements.length + stateMembershipSplit.replacements.length > 0);
+		if (stateMembershipRemainingPatches.length === 0) return finalize([...semanticReplacements, ...stateMembershipSplit.replacements]);
+		const remainingPlan = deriveReplacementPlan(stateMembershipRemainingPatches, prevGraph, nextGraph);
+		if (remainingPlan.type === "root") {
+			if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+			return finalize([createReplacement(document, sourceFile, machineConfigNode, machineConfig)]);
+		}
+		const replacements = [...semanticReplacements, ...stateMembershipSplit.replacements];
+		for (const path of remainingPlan.paths) {
+			const nextValue = getStateConfigByPath(machineConfig, path);
+			if (!isMachineConfig(nextValue)) return fallbackRootReplacement(document, sourceFile, machineConfigNode, machineConfig, activeSourceLocations);
+			const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, activeSourceLocations, path, options.openTextDocument);
+			const currentNode = mappedTarget?.node ?? getStateObjectLiteralByPath(machineConfigNode, path);
+			const targetDocument = mappedTarget?.document ?? document;
+			const targetSourceFile = mappedTarget?.sourceFile ?? sourceFile;
+			if (!currentNode) return fallbackRootReplacement(document, sourceFile, machineConfigNode, machineConfig, activeSourceLocations);
+			replacements.push(createReplacement(targetDocument, targetSourceFile, currentNode, nextValue));
+		}
+		return finalize(replacements);
+	}
+	const plan = deriveReplacementPlan(patchesAfterImplementationSplit, prevGraph, nextGraph);
+	if (plan.type === "root") {
+		if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+		return finalize([createReplacement(document, sourceFile, machineConfigNode, machineConfig)]);
+	}
+	const replacements = [...semanticReplacements];
+	for (const path of plan.paths) {
+		const nextValue = getStateConfigByPath(machineConfig, path);
+		if (!isMachineConfig(nextValue)) return fallbackRootReplacement(document, sourceFile, machineConfigNode, machineConfig, activeSourceLocations);
+		const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, activeSourceLocations, path, options.openTextDocument);
+		const currentNode = mappedTarget?.node ?? getStateObjectLiteralByPath(machineConfigNode, path);
+		const targetDocument = mappedTarget?.document ?? document;
+		const targetSourceFile = mappedTarget?.sourceFile ?? sourceFile;
+		if (!currentNode) return fallbackRootReplacement(document, sourceFile, machineConfigNode, machineConfig, activeSourceLocations);
+		replacements.push(createReplacement(targetDocument, targetSourceFile, currentNode, nextValue));
+	}
+	return finalize(replacements);
 }
-function resolvePropertyNameValue(name, sourceFile, bindings, seenBindings) {
-	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
-	if (!ts.isComputedPropertyName(name)) return null;
-	const value = evaluateExpression(name.expression, sourceFile, bindings, seenBindings);
-	if (typeof value === "string" || typeof value === "number") return value;
-	return name.getText(sourceFile);
-}
-function isCreateMachineExpression(expression) {
-	const unwrapped = unwrapExpression(expression);
-	return ts.isIdentifier(unwrapped) && unwrapped.text === "createMachine" || ts.isPropertyAccessExpression(unwrapped) && unwrapped.name.text === "createMachine";
+function fallbackRootReplacement(document, sourceFile, machineConfigNode, machineConfig, sourceLocations) {
+	if (wouldDeModularizeRootReplacement(sourceLocations)) return [];
+	return addCodeImportReplacements(document, sourceFile, machineConfig, [createReplacement(document, sourceFile, machineConfigNode, machineConfig)]).sort(compareReplacementRangesDescending);
 }
-function unwrapExpression(expression) {
-	let current = expression;
-	for (;;) {
-		if (ts.isParenthesizedExpression(current)) {
-			current = current.expression;
+async function tryCreateTransitionPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
+	const replacements = [];
+	const remainingPatches = [];
+	const handledTransitionKeys = /* @__PURE__ */ new Set();
+	const handledStatePropertyKeys = /* @__PURE__ */ new Set();
+	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 transitionTarget = getTransitionPatchTarget(patch, prevGraph, nextGraph);
+		if (transitionTarget) {
+			if (deletedStatePaths.some((deletedPath) => isPathEqualOrDescendant(transitionTarget.sourcePath, deletedPath))) continue;
+			const transitionKey = `${transitionTarget.sourcePath.join(".")}:${transitionTarget.previousEventType}:${transitionTarget.index ?? "single"}`;
+			if (handledTransitionKeys.has(transitionKey)) continue;
+			const patchReplacements = patch.op === "deleteTransition" ? await createDeleteTransitionReplacementsForDocuments(document, sourceFile, machineConfigNode, transitionTarget, sourceLocations, openTextDocument) : await createTransitionReplacementForDocuments(document, sourceFile, machineConfigNode, machineConfig, transitionTarget, sourceLocations, openTextDocument);
+			if (!patchReplacements) {
+				remainingPatches.push(patch);
+				continue;
+			}
+			handledTransitionKeys.add(transitionKey);
+			replacements.push(...patchReplacements);
 			continue;
 		}
-		if (ts.isAsExpression(current) || ts.isSatisfiesExpression(current)) {
-			current = current.expression;
+		const [statePropertyTarget] = getStatePropertyPatchTargets(patch, prevGraph, nextGraph);
+		if (!statePropertyTarget) {
+			remainingPatches.push(patch);
 			continue;
 		}
-		if (ts.isTypeAssertionExpression(current) || ts.isNonNullExpression(current)) {
-			current = current.expression;
+		const statePathKey = statePropertyTarget.path.join(".");
+		const statePropertyKey = `${statePathKey}:${statePropertyTarget.propertyName}`;
+		if (handledStatePropertyKeys.has(statePropertyKey)) continue;
+		const propertyNames = /* @__PURE__ */ new Set();
+		for (const candidate of patches) {
+			const candidateTargets = getStatePropertyPatchTargets(candidate, prevGraph, nextGraph);
+			for (const candidateTarget of candidateTargets) {
+				if (candidateTarget.path.join(".") !== statePathKey) continue;
+				const candidateKey = `${statePathKey}:${candidateTarget.propertyName}`;
+				if (!handledStatePropertyKeys.has(candidateKey)) propertyNames.add(candidateTarget.propertyName);
+			}
+		}
+		const patchReplacements = await createStatePropertiesReplacementForDocuments(document, sourceFile, machineConfigNode, machineConfig, statePropertyTarget.path, [...propertyNames], sourceLocations, openTextDocument);
+		if (!patchReplacements) {
+			remainingPatches.push(patch);
 			continue;
 		}
-		return current;
+		replacements.push(...patchReplacements);
+		for (const propertyName of propertyNames) handledStatePropertyKeys.add(`${statePathKey}:${propertyName}`);
 	}
+	return replacements.length > 0 ? {
+		replacements: replacements.sort(compareReplacementRangesDescending),
+		remainingPatches
+	} : null;
 }
-function getPropertyNameText(name) {
-	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
-	return null;
+async function createDeleteTransitionReplacementsForDocuments(document, sourceFile, machineConfigNode, transitionTarget, sourceLocations, openTextDocument) {
+	const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, transitionTarget.sourcePath, openTextDocument);
+	const targetDocument = mappedTarget?.document ?? document;
+	const targetSourceFile = mappedTarget?.sourceFile ?? sourceFile;
+	const stateObject = mappedTarget?.node ?? getStateObjectLiteralByPath(machineConfigNode, transitionTarget.sourcePath);
+	if (!stateObject) return null;
+	const transitionSource = getTransitionSourceExpression(stateObject, transitionTarget.previousEventType, transitionTarget.index);
+	if (!transitionSource) return null;
+	if (transitionSource.array && transitionSource.element) return [createArrayElementDeletion(targetDocument, targetSourceFile, transitionSource.array, transitionSource.element)];
+	return [createObjectLiteralPropertyDeletion(targetDocument, targetSourceFile, transitionSource.onObject, transitionSource.eventProperty)];
 }
-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;
+async function createTransitionReplacementForDocuments(document, sourceFile, machineConfigNode, machineConfig, transitionTarget, sourceLocations, openTextDocument) {
+	const nextTransitionValue = getTransitionConfigValue(machineConfig, transitionTarget.sourcePath, transitionTarget.eventType, transitionTarget.index);
+	if (nextTransitionValue === void 0) return null;
+	const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, transitionTarget.sourcePath, openTextDocument);
+	const targetDocument = mappedTarget?.document ?? document;
+	const targetSourceFile = mappedTarget?.sourceFile ?? sourceFile;
+	const stateObject = mappedTarget?.node ?? getStateObjectLiteralByPath(machineConfigNode, transitionTarget.sourcePath);
+	if (!stateObject) return null;
+	const transitionSource = getTransitionSourceExpression(stateObject, transitionTarget.previousEventType, transitionTarget.index);
+	if (transitionSource?.array && transitionSource.element) return [createExpressionReplacement(targetDocument, targetSourceFile, transitionSource.element, nextTransitionValue)];
+	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 })];
 }
-function isUrl(value) {
-	try {
-		const url = new URL(value);
-		return url.protocol === "http:" || url.protocol === "https:";
-	} catch {
-		return false;
+async function createStatePropertiesReplacementForDocuments(document, sourceFile, machineConfigNode, machineConfig, path, propertyNames, sourceLocations, openTextDocument) {
+	const nextStateConfig = getStateConfigByPath(machineConfig, path);
+	if (!isMachineConfig(nextStateConfig)) return null;
+	const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, path, openTextDocument);
+	const targetDocument = mappedTarget?.document ?? document;
+	const targetSourceFile = mappedTarget?.sourceFile ?? sourceFile;
+	const stateObject = mappedTarget?.node ?? getStateObjectLiteralByPath(machineConfigNode, path);
+	if (!stateObject) return null;
+	const replacements = [];
+	const insertionEntries = [];
+	for (const propertyName of propertyNames) {
+		const nextValue = nextStateConfig[propertyName];
+		const property = findObjectLiteralProperty(stateObject, propertyName);
+		if (nextValue === void 0) {
+			if (!property) continue;
+			replacements.push(createObjectLiteralPropertyDeletion(targetDocument, targetSourceFile, stateObject, property));
+			continue;
+		}
+		if (property) {
+			replacements.push(createPropertyValueReplacement(targetDocument, targetSourceFile, property, nextValue));
+			continue;
+		}
+		insertionEntries.push({
+			key: propertyName,
+			config: nextValue
+		});
 	}
+	if (insertionEntries.length > 0) replacements.push(createObjectLiteralPropertiesInsertion(targetDocument, targetSourceFile, stateObject, insertionEntries));
+	return replacements.length > 0 ? replacements.sort(compareReplacementRangesDescending) : [];
 }
-async function fileExists(filePath) {
-	try {
-		await fs.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
+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 sourcePath = resolveStatePath(nextGraph, patch.sourceId);
+		const eventType = edge?.data?.eventType ?? edge?.label ?? patchRecord.eventType;
+		if (!sourcePath || !eventType) return null;
+		return {
+			sourcePath,
+			eventType,
+			previousEventType: eventType,
+			transitionId: edge?.id ?? patch.id,
+			index: getTransitionIndexFromId(edge?.id ?? patch.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;
+	if (!edgeId) return null;
+	const nextEdge = nextGraph.edges.find((item) => item.id === edgeId);
+	const prevEdge = prevGraph.edges.find((item) => item.id === edgeId);
+	const sourcePath = resolveEdgeSourcePath(nextGraph, edgeId) ?? resolveEdgeSourcePath(prevGraph, edgeId);
+	const eventType = nextEdge?.data?.eventType ?? nextEdge?.label ?? patchRecord.eventType ?? prevEdge?.data?.eventType ?? prevEdge?.label;
+	const previousEventType = prevEdge?.data?.eventType ?? prevEdge?.label ?? eventType;
+	if (!sourcePath || !eventType || !previousEventType) return null;
+	return {
+		sourcePath,
+		eventType,
+		previousEventType,
+		transitionId: edgeId,
+		index: getTransitionIndexFromId(edgeId)
+	};
+}
+function getStatePropertyPatchTargets(patch, prevGraph, nextGraph) {
+	if (patch.op === "updateSchemas") return [{
+		path: [],
+		propertyName: "schemas"
+	}];
+	if (patch.op === "updateState") {
+		const propertyNames = getStatePropertyNamesFromUpdatePatch(patch);
+		if (propertyNames.length === 0) return [];
+		const path = resolveStatePath(nextGraph, patch.stateId) ?? resolveStatePath(prevGraph, patch.stateId);
+		return path ? propertyNames.map((propertyName) => ({
+			path,
+			propertyName
+		})) : [];
+	}
+	if (patch.op === "createAction" || patch.op === "updateAction" || patch.op === "deleteAction") {
+		if (!("nodeId" in patch.location)) return [];
+		const path = resolveStatePath(nextGraph, patch.location.nodeId) ?? resolveStatePath(prevGraph, patch.location.nodeId);
+		return path ? [{
+			path,
+			propertyName: patch.location.group
+		}] : [];
+	}
+	if (patch.op === "createInvoke" || patch.op === "updateInvoke" || patch.op === "deleteInvoke") {
+		const path = resolveStatePath(nextGraph, patch.nodeId) ?? resolveStatePath(prevGraph, patch.nodeId);
+		return path ? [{
+			path,
+			propertyName: "invoke"
+		}] : [];
+	}
+	if (patch.op === "createTag" || patch.op === "deleteTag") {
+		const path = resolveStatePath(nextGraph, patch.nodeId) ?? resolveStatePath(prevGraph, patch.nodeId);
+		return path ? [{
+			path,
+			propertyName: "tags"
+		}] : [];
+	}
+	return [];
+}
+function getStatePropertyNamesFromUpdatePatch(patch) {
+	if (patch.op !== "updateState") return [];
+	const patchRecord = patch;
+	const propertyNames = [];
+	if (patchRecord.stateDescription !== void 0) propertyNames.push("description");
+	if (patchRecord.meta !== void 0) propertyNames.push("meta");
+	if (patchRecord.type !== void 0) propertyNames.push("type");
+	if (patchRecord.history !== void 0) propertyNames.push("history");
+	if (patchRecord.initialId !== void 0 || patchRecord.initialInput !== void 0) propertyNames.push("initial");
+	if (patchRecord.timeout !== void 0) propertyNames.push("timeout");
+	if (patchRecord.route !== void 0) propertyNames.push("route");
+	return propertyNames;
+}
+function getTransitionConfigValue(machineConfig, sourcePath, eventType, index) {
+	const sourceConfig = getStateConfigByPath(machineConfig, sourcePath);
+	const eventConfig = (isMachineConfig(sourceConfig?.on) ? sourceConfig.on : null)?.[eventType];
+	if (Array.isArray(eventConfig) && index !== null) return eventConfig[index];
+	return eventConfig;
+}
+function getTransitionSourceExpression(stateObject, eventType, index) {
+	const onObject = getObjectLiteralProperty(stateObject, "on");
+	if (!onObject) return null;
+	const eventProperty = findObjectLiteralProperty(onObject, eventType);
+	if (!eventProperty) return null;
+	if (!ts$1.isPropertyAssignment(eventProperty)) return {
+		onObject,
+		eventProperty
+	};
+	const initializer = unwrapExpression$1(eventProperty.initializer);
+	if (ts$1.isArrayLiteralExpression(initializer) && index !== null) {
+		const element = initializer.elements[index];
+		if (element && ts$1.isExpression(element)) return {
+			onObject,
+			eventProperty,
+			array: initializer,
+			element
+		};
+	}
+	return {
+		onObject,
+		eventProperty
+	};
+}
+function getTransitionIndexFromId(id) {
+	const match = id.match(/\[(\d+)\](?:$|#)/);
+	return match ? Number(match[1]) : null;
+}
+function createArrayElementDeletion(document, sourceFile, arrayLiteral, element) {
+	const range = getArrayElementDeletionRange(sourceFile, arrayLiteral, element);
+	return createOffsetReplacement(document, range.start, range.end, "");
+}
+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));
+}
+function createPropertyValueReplacement(document, sourceFile, property, nextValue) {
+	if (!ts$1.isPropertyAssignment(property)) return createPropertyAssignmentReplacement(document, sourceFile, property, getStatePropertyKeyText(property) ?? "value", nextValue);
+	return createExpressionReplacement(document, sourceFile, property.initializer, nextValue);
+}
+function createPropertyAssignmentReplacement(document, sourceFile, property, key, nextValue) {
+	const text = printObjectLiteralProperty(key, nextValue, sourceFile, getFormattingContextForExpression(document, sourceFile, property));
+	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);
+}
+function getArrayElementDeletionRange(sourceFile, arrayLiteral, element) {
+	const elements = [...arrayLiteral.elements];
+	const elementIndex = elements.indexOf(element);
+	const elementStart = element.getFullStart();
+	const elementEnd = element.getEnd();
+	if (elements.length === 1) return {
+		start: elementStart,
+		end: elementEnd
+	};
+	if (elementIndex === elements.length - 1) {
+		const previousElement = elements[elementIndex - 1];
+		const commaOffset = sourceFile.text.lastIndexOf(",", elementStart - 1);
+		return {
+			start: commaOffset >= previousElement.getEnd() && commaOffset < elementStart ? commaOffset : elementStart,
+			end: elementEnd
+		};
+	}
+	const nextElement = elements[elementIndex + 1];
+	const commaOffset = sourceFile.text.indexOf(",", elementEnd);
+	return {
+		start: elementStart,
+		end: commaOffset >= elementEnd && commaOffset < nextElement.getFullStart() ? commaOffset + 1 : elementEnd
+	};
+}
+function tryCreateImplementationPatchSplit(document, sourceFile, patches, nextGraph, machineIndex = 0) {
+	const replacements = [];
+	const remainingPatches = [];
+	for (const patch of patches) {
+		if (!isImplementationPatch(patch)) {
+			remainingPatches.push(patch);
+			continue;
+		}
+		const patchReplacements = createImplementationPatchReplacements(document, sourceFile, patch, nextGraph, machineIndex);
+		if (!patchReplacements) {
+			remainingPatches.push(patch);
+			continue;
+		}
+		replacements.push(...patchReplacements);
+	}
+	return replacements.length > 0 ? {
+		replacements: replacements.sort(compareReplacementRangesDescending),
+		remainingPatches
+	} : null;
+}
+function isImplementationPatch(patch) {
+	return patch.op === "createImplementation" || patch.op === "updateImplementation" || patch.op === "deleteImplementation";
+}
+function createImplementationPatchReplacements(document, sourceFile, patch, nextGraph, machineIndex) {
+	const createMachineCall = findCreateMachineCall(sourceFile, machineIndex);
+	if (!createMachineCall) return null;
+	const implementationRoot = findImplementationObjectLiteralForMachine(sourceFile, createMachineCall);
+	const categoryName = implementationSourceTypeToCategoryName(patch.sourceType);
+	const categoryObject = implementationRoot ? getObjectLiteralProperty(implementationRoot, categoryName) : null;
+	if (patch.op === "createImplementation") {
+		const implementation = getGraphImplementation(nextGraph, patch.sourceType, patch.implementation.id) ?? patch.implementation;
+		if (!implementationRoot) return createMachineCall.arguments.length < 2 && !isObjectOfProvideCall(createMachineCall) ? createProvideCreateReplacements(document, sourceFile, createMachineCall, categoryName, implementation) : null;
+		return createImplementationCreateReplacements(document, sourceFile, implementationRoot, categoryName, implementation);
+	}
+	if (!implementationRoot || !categoryObject) return null;
+	const implementationProperty = findObjectLiteralProperty(categoryObject, patch.implementationId);
+	if (!implementationProperty) return null;
+	if (patch.op === "deleteImplementation") {
+		const deletionRange = getObjectLiteralPropertyDeletionRange(sourceFile, categoryObject, implementationProperty);
+		return [createOffsetReplacement(document, deletionRange.start, deletionRange.end, "")];
+	}
+	const nextImplementation = getGraphImplementation(nextGraph, patch.sourceType, patch.implementationId);
+	const nextName = patch.data.name ?? nextImplementation?.name;
+	const nextCode = patch.data.code ?? nextImplementation?.code?.body;
+	const replacements = [];
+	if (nextName && nextName !== patch.implementationId) {
+		const nameNode = getObjectLiteralElementName(implementationProperty);
+		if (!nameNode) return null;
+		replacements.push(createOffsetReplacement(document, nameNode.getStart(sourceFile), nameNode.getEnd(), propertyNameTextForSource(nextName)));
+	}
+	if (nextCode !== void 0) {
+		if (!ts$1.isPropertyAssignment(implementationProperty)) return null;
+		replacements.push(createOffsetReplacement(document, implementationProperty.initializer.getStart(sourceFile), implementationProperty.initializer.getEnd(), nextCode));
+	}
+	return replacements.length > 0 ? replacements : null;
+}
+function createProvideCreateReplacements(document, sourceFile, createMachineCall, categoryName, implementation) {
+	const implementationCode = implementation.code?.body;
+	if (!implementation.id || !implementationCode) return null;
+	const lineBreak = getLineBreak(sourceFile);
+	const baseIndent = getLineIndent(sourceFile.text, createMachineCall.getStart(sourceFile));
+	const propertyIndent = `${baseIndent}  `;
+	const nestedIndent = `${baseIndent}    `;
+	const text = `.provide({${lineBreak}${propertyIndent}${propertyNameTextForSource(categoryName)}: {${lineBreak}${nestedIndent}${propertyNameTextForSource(implementation.id)}: ${implementationCode},${lineBreak}${propertyIndent}},${lineBreak}${baseIndent}})`;
+	return [createOffsetReplacement(document, createMachineCall.getEnd(), createMachineCall.getEnd(), text)];
+}
+function createImplementationCreateReplacements(document, sourceFile, implementationRoot, categoryName, implementation) {
+	const implementationCode = implementation.code?.body;
+	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 text = objectPropertyTextForInsertion(categoryObject, `${propertyNameTextForSource(implementation.id)}: ${implementationCode}`);
+	return [createOffsetReplacement(document, categoryObject.properties.end, categoryObject.properties.end, text)];
+}
+function objectPropertyTextForInsertion(objectLiteral, propertyText) {
+	return `${objectLiteral.properties.length > 0 ? "," : ""}${getLineBreak(objectLiteral.getSourceFile())}${getIndentForNewObjectProperty(objectLiteral.getSourceFile(), objectLiteral)}${propertyText}`;
+}
+function getLineBreak(sourceFile) {
+	return sourceFile.text.includes("\r\n") ? "\r\n" : "\n";
+}
+function getLineIndent(sourceText, offset) {
+	const lineStart = getLineStartOffset(sourceText, offset);
+	return sourceText.slice(lineStart, offset).match(/^[ \t]*/)?.[0] ?? "";
+}
+function getIndentForNewObjectProperty(sourceFile, objectLiteral) {
+	const closeIndent = getIndentForObjectClose(sourceFile, objectLiteral);
+	const existingProperty = objectLiteral.properties[0];
+	if (existingProperty) {
+		const propertyLineStart = getLineStartOffset(sourceFile.text, existingProperty.getStart(sourceFile));
+		return sourceFile.text.slice(propertyLineStart, existingProperty.getStart(sourceFile)).match(/^[ \t]*/)?.[0] ?? `${closeIndent}  `;
+	}
+	return `${closeIndent}  `;
+}
+function getIndentForObjectClose(sourceFile, objectLiteral) {
+	const objectStart = objectLiteral.getStart(sourceFile);
+	const lineStart = getLineStartOffset(sourceFile.text, objectStart);
+	return sourceFile.text.slice(lineStart, objectStart).match(/^[ \t]*/)?.[0] ?? "";
+}
+function createOffsetReplacement(document, startOffset, endOffset, newText) {
+	const start = document.positionAt(startOffset);
+	const end = document.positionAt(endOffset);
+	return {
+		uri: getDocumentUri(document),
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		newText
+	};
+}
+function propertyNameTextForSource(name) {
+	return isIdentifierText(name) ? name : JSON.stringify(name);
+}
+function getGraphImplementation(graph, sourceType, implementationId) {
+	if (!implementationId) return;
+	return graph.data?.implementations?.[implementationSourceTypeToCategoryName(sourceType)]?.find((implementation) => implementation.id === implementationId);
+}
+function implementationSourceTypeToCategoryName(sourceType) {
+	switch (sourceType) {
+		case "action": return "actions";
+		case "guard": return "guards";
+		case "actor": return "actors";
+		case "delay": return "delays";
+	}
+}
+function tryCreateStateMembershipPatchSplit(document, sourceFile, machineConfigNode, machineConfig, patches, prevGraph, nextGraph, sourceLocations, allowDisjointDescendantReplacements = false) {
+	const split = splitStateMembershipPatches(patches, prevGraph, nextGraph, sourceLocations, allowDisjointDescendantReplacements);
+	if (!split) return null;
+	const replacements = createStateMembershipReplacements(document, sourceFile, machineConfigNode, machineConfig, split.changes, sourceLocations);
+	if (!replacements) return null;
+	return {
+		replacements,
+		remainingPatches: split.remainingPatches
+	};
+}
+async function tryCreateStateMembershipPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
+	const split = splitStateMembershipPatches(patches, prevGraph, nextGraph, sourceLocations, true);
+	if (!split) return null;
+	const replacements = await createStateMembershipReplacementsForDocuments(document, sourceFile, machineConfigNode, machineConfig, split.changes, sourceLocations, openTextDocument);
+	if (!replacements) return null;
+	return {
+		replacements,
+		remainingPatches: split.remainingPatches
+	};
+}
+function splitStateMembershipPatches(patches, prevGraph, nextGraph, sourceLocations, allowDisjointDescendantReplacements) {
+	const createdById = /* @__PURE__ */ new Map();
+	const changesByParent = /* @__PURE__ */ new Map();
+	const remainingPatches = [];
+	const getChange = (parentPath) => {
+		const key = parentPath.join(".");
+		const existing = changesByParent.get(key);
+		if (existing) return existing;
+		const change = {
+			parentPath,
+			createdPaths: [],
+			deletedPaths: [],
+			patches: []
+		};
+		changesByParent.set(key, change);
+		return change;
+	};
+	for (const patch of patches) switch (patch.op) {
+		case "createState": {
+			if (!patch.id) {
+				remainingPatches.push(patch);
+				break;
+			}
+			const parentPath = resolveStatePath(nextGraph, patch.parentId);
+			const nextPath = resolveStatePath(nextGraph, patch.id);
+			if (!parentPath || !nextPath || nextPath.length === 0) {
+				remainingPatches.push(patch);
+				break;
+			}
+			const change = getChange(parentPath);
+			createdById.set(patch.id, {
+				parentPath,
+				path: nextPath
+			});
+			change.createdPaths.push(nextPath);
+			change.patches.push(patch);
+			break;
+		}
+		case "updateState": {
+			const created = createdById.get(patch.stateId);
+			const nextPath = resolveStatePath(nextGraph, patch.stateId);
+			if (created && nextPath && arePathsEqual(created.path, nextPath)) {
+				getChange(created.parentPath).patches.push(patch);
+				break;
+			}
+			remainingPatches.push(patch);
+			break;
+		}
+		case "deleteState": {
+			const prevPath = resolveStatePath(prevGraph, patch.stateId);
+			if (!prevPath || prevPath.length === 0) {
+				remainingPatches.push(patch);
+				break;
+			}
+			const change = getChange(prevPath.slice(0, -1));
+			change.deletedPaths.push(prevPath);
+			change.patches.push(patch);
+			break;
+		}
+		default: remainingPatches.push(patch);
+	}
+	const deletedPaths = [...changesByParent.values()].flatMap((change) => change.deletedPaths);
+	const createdPaths = [...changesByParent.values()].flatMap((change) => change.createdPaths);
+	const remainingPatchesWithSurvivingOwners = remainingPatches.filter((patch) => {
+		const owner = resolvePatchOwner(patch, prevGraph, nextGraph);
+		return owner.type !== "covered" && !isPatchOwnerCoveredByPaths(owner, deletedPaths) && !isPatchOwnerCoveredByPaths(owner, createdPaths);
+	});
+	const split = coalesceMembershipChangesWithRemainingPatches([...changesByParent.values()].filter((change) => !createdPaths.some((path) => isPathEqualOrDescendant(change.parentPath, path))), remainingPatchesWithSurvivingOwners, prevGraph, nextGraph, sourceLocations, allowDisjointDescendantReplacements);
+	return split.changes.length > 0 ? split : null;
+}
+function isPatchOwnerCoveredByPaths(owner, paths) {
+	if (owner.type !== "state" || paths.length === 0) return false;
+	return paths.some((path) => isPathEqualOrDescendant(owner.path, path));
+}
+function coalesceMembershipChangesWithRemainingPatches(changes, remainingPatches, prevGraph, nextGraph, sourceLocations, allowDisjointDescendantReplacements) {
+	if (remainingPatches.length === 0) return {
+		changes,
+		remainingPatches
+	};
+	const remainingPlan = deriveReplacementPlan(remainingPatches, prevGraph, nextGraph);
+	const activeChanges = [];
+	const activeRemainingPatches = [...remainingPatches];
+	for (const change of changes) {
+		if (shouldCoalesceMembershipChangeWithRemainingPlan(change, remainingPlan, sourceLocations, allowDisjointDescendantReplacements)) {
+			activeRemainingPatches.push(...change.patches);
+			continue;
+		}
+		activeChanges.push(change);
+	}
+	return {
+		changes: activeChanges,
+		remainingPatches: activeRemainingPatches
+	};
+}
+function shouldCoalesceMembershipChangeWithRemainingPlan(change, remainingPlan, sourceLocations, allowDisjointDescendantReplacements) {
+	if (change.parentPath.length === 0 && wouldDeModularizeRootReplacement(sourceLocations)) return false;
+	if (remainingPlan.type === "root") return true;
+	return remainingPlan.paths.some((path) => isPathEqualOrDescendant(change.parentPath, path) || !allowDisjointDescendantReplacements && isPathEqualOrDescendant(path, change.parentPath));
+}
+function isPathEqualOrDescendant(path, candidateParentPath) {
+	return candidateParentPath.every((segment, index) => path[index] === segment);
+}
+function createStateMembershipReplacements(document, sourceFile, machineConfigNode, machineConfig, changes, sourceLocations) {
+	const replacements = [];
+	for (const change of changes) {
+		const target = getStateMembershipParentTarget(document, sourceFile, machineConfigNode, sourceLocations, change.parentPath, getStateObjectLiteralByPath);
+		if (!target) return null;
+		const changeReplacements = createStateMembershipReplacementsForTarget(target.document, target.sourceFile, target.node, machineConfig, change, target.nodeKind);
+		if (!changeReplacements) return null;
+		replacements.push(...changeReplacements);
+		replacements.push(...createStateMembershipInitialReplacements(change.parentPath.length === 0 ? document : target.document, change.parentPath.length === 0 ? sourceFile : target.sourceFile, change.parentPath.length === 0 ? machineConfigNode : target.node, machineConfig, change));
+	}
+	return replacements.sort(compareReplacementRangesDescending);
+}
+async function createStateMembershipReplacementsForDocuments(document, sourceFile, machineConfigNode, machineConfig, changes, sourceLocations, openTextDocument) {
+	const replacements = [];
+	for (const change of changes) {
+		const target = await getStateMembershipParentTargetForDocuments(document, sourceFile, machineConfigNode, sourceLocations, change.parentPath, openTextDocument, getStateObjectLiteralByPath);
+		if (!target) return null;
+		const changeReplacements = createStateMembershipReplacementsForTarget(target.document, target.sourceFile, target.node, machineConfig, change, target.nodeKind);
+		if (!changeReplacements) return null;
+		replacements.push(...changeReplacements);
+		replacements.push(...createStateMembershipInitialReplacements(change.parentPath.length === 0 ? document : target.document, change.parentPath.length === 0 ? sourceFile : target.sourceFile, change.parentPath.length === 0 ? machineConfigNode : target.node, machineConfig, change));
+	}
+	return replacements.sort(compareReplacementRangesDescending);
+}
+function createStateMembershipReplacementsForTarget(document, sourceFile, parentObject, machineConfig, change, nodeKind = "machineConfig") {
+	const statesObject = nodeKind === "statesObject" ? parentObject : getObjectLiteralProperty(parentObject, "states");
+	if (!statesObject) return null;
+	const stateEntries = [];
+	for (const path of change.createdPaths) {
+		const key = path[path.length - 1];
+		const stateConfig = getStateConfigByPath(machineConfig, path);
+		if (!key || !isMachineConfig(stateConfig)) return null;
+		stateEntries.push({
+			key,
+			config: stateConfig
+		});
+	}
+	const deletionReplacements = [];
+	for (const path of change.deletedPaths) {
+		const key = path[path.length - 1];
+		const property = key ? findObjectLiteralProperty(statesObject, key) : null;
+		if (!property) return null;
+		deletionReplacements.push(createObjectLiteralPropertyDeletion(document, sourceFile, statesObject, property));
+	}
+	return [...stateEntries.length > 0 ? [createObjectLiteralPropertiesInsertion(document, sourceFile, statesObject, stateEntries)] : [], ...deletionReplacements].sort(compareReplacementRangesDescending);
+}
+function createStateMembershipInitialReplacements(document, sourceFile, parentObject, machineConfig, change) {
+	if (!change.patches.some((patch) => patch.op === "createState" && patch.initial === true || patch.op === "deleteState")) return [];
+	const parentConfig = getStateConfigByPath(machineConfig, change.parentPath);
+	if (!parentConfig) return [];
+	const nextInitial = parentConfig.initial;
+	const initialProperty = getPropertyAssignment(parentObject, "initial");
+	if (nextInitial === void 0) return initialProperty ? [createObjectLiteralPropertyDeletion(document, sourceFile, parentObject, initialProperty)] : [];
+	if (isMachineConfig(nextInitial)) {
+		if (!initialProperty) return [createObjectLiteralPropertiesInsertion(document, sourceFile, parentObject, [{
+			key: "initial",
+			config: nextInitial
+		}])];
+		const initializer = unwrapExpression$1(initialProperty.initializer);
+		const targetProperty = ts$1.isObjectLiteralExpression(initializer) ? getPropertyAssignment(initializer, "target") : null;
+		if (targetProperty && typeof nextInitial.target === "string") {
+			const targetInitializer = unwrapExpression$1(targetProperty.initializer);
+			if (ts$1.isStringLiteralLike(targetInitializer) && targetInitializer.text === nextInitial.target) return [];
+			return [createPropertyValueReplacement(document, sourceFile, targetProperty, nextInitial.target)];
+		}
+		return [createPropertyValueReplacement(document, sourceFile, initialProperty, nextInitial)];
+	}
+	if (typeof nextInitial !== "string") return [];
+	if (initialProperty) {
+		const initializer = unwrapExpression$1(initialProperty.initializer);
+		if (ts$1.isStringLiteralLike(initializer) && initializer.text === nextInitial) return [];
+		return [createPropertyValueReplacement(document, sourceFile, initialProperty, nextInitial)];
+	}
+	return [createObjectLiteralPropertiesInsertion(document, sourceFile, parentObject, [{
+		key: "initial",
+		config: nextInitial
+	}])];
+}
+function createObjectLiteralPropertiesInsertion(document, sourceFile, objectLiteral, entries) {
+	const formatting = getFormattingContext(document, sourceFile, objectLiteral);
+	const lineSeparator = formatting.newLineKind === ts$1.NewLineKind.CarriageReturnLineFeed ? "\r\n" : "\n";
+	const propertyTexts = entries.map((entry) => printObjectLiteralProperty(entry.key, entry.config, sourceFile, formatting));
+	const existingProperties = objectLiteral.properties;
+	const closeBraceOffset = objectLiteral.getEnd() - 1;
+	const startOffset = existingProperties.length === 0 ? closeBraceOffset : existingProperties[existingProperties.length - 1].getEnd();
+	const start = document.positionAt(startOffset);
+	const end = document.positionAt(closeBraceOffset);
+	const prefix = existingProperties.length === 0 ? lineSeparator : `,${lineSeparator}`;
+	const suffix = `${lineSeparator}${formatting.baseIndent}`;
+	return {
+		uri: getDocumentUri(document),
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		newText: `${prefix}${propertyTexts.join(`,${lineSeparator}`)}${suffix}`
+	};
+}
+function createObjectLiteralPropertyDeletion(document, sourceFile, objectLiteral, property) {
+	const range = getObjectLiteralPropertyDeletionRange(sourceFile, objectLiteral, property);
+	const start = document.positionAt(range.start);
+	const end = document.positionAt(range.end);
+	return {
+		uri: getDocumentUri(document),
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		newText: ""
+	};
+}
+function getObjectLiteralPropertyDeletionRange(sourceFile, objectLiteral, property) {
+	const properties = [...objectLiteral.properties];
+	const propertyIndex = properties.indexOf(property);
+	const propertyStart = property.getFullStart();
+	const propertyEnd = property.getEnd();
+	if (properties.length === 1) return {
+		start: propertyStart,
+		end: propertyEnd
+	};
+	if (propertyIndex === properties.length - 1) {
+		const previousProperty = properties[propertyIndex - 1];
+		const commaOffset = sourceFile.text.lastIndexOf(",", propertyStart - 1);
+		return {
+			start: commaOffset >= previousProperty.getEnd() && commaOffset < propertyStart ? commaOffset : propertyStart,
+			end: propertyEnd
+		};
+	}
+	const nextProperty = properties[propertyIndex + 1];
+	const commaOffset = sourceFile.text.indexOf(",", propertyEnd);
+	return {
+		start: propertyStart,
+		end: commaOffset >= propertyEnd && commaOffset < nextProperty.getFullStart() ? commaOffset + 1 : propertyEnd
+	};
+}
+function findObjectLiteralProperty(objectLiteral, propertyName) {
+	for (const property of objectLiteral.properties) {
+		if (ts$1.isShorthandPropertyAssignment(property) && property.name.text === propertyName) return property;
+		if (ts$1.isPropertyAssignment(property)) {
+			if (getPropertyNameText$1(property.name) === propertyName) return property;
+		}
+	}
+	return null;
+}
+function findObjectLiteralPropertyByRange(sourceFile, objectLiteral, range) {
+	if (!range) return null;
+	const start = offsetAtRangePosition(sourceFile.text, range.startLine, range.startChar);
+	const end = offsetAtRangePosition(sourceFile.text, range.endLine, range.endChar);
+	for (const property of objectLiteral.properties) {
+		const propertyName = getObjectLiteralElementName(property);
+		if (propertyName && propertyName.getStart(sourceFile) === start && propertyName.getEnd() === end) return property;
+	}
+	return null;
+}
+function getObjectLiteralElementName(property) {
+	if (ts$1.isPropertyAssignment(property) || ts$1.isShorthandPropertyAssignment(property) || ts$1.isMethodDeclaration(property) || ts$1.isGetAccessorDeclaration(property) || ts$1.isSetAccessorDeclaration(property)) return property.name;
+	return null;
+}
+function getStatePropertyKeyText(property) {
+	if (ts$1.isShorthandPropertyAssignment(property)) return property.name.text;
+	if (ts$1.isPropertyAssignment(property)) return getPropertyNameText$1(property.name);
+	return null;
+}
+function printObjectLiteralProperty(key, value, sourceFile, formatting) {
+	const objectText = printExpression(valueToExpression({ [key]: value }), 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*\}$/, "");
+	return lines.slice(1, -1).join(lineSeparator);
+}
+function wouldDeModularizeRootReplacement(sourceLocations) {
+	const root = sourceLocations?.root;
+	return sourceLocations?.states.some((location) => location.kind !== "inline" || (root ? !isSourceLocationInsideRoot(location, root) : false)) ?? false;
+}
+function isSourceLocationInsideRoot(location, root) {
+	if (location.uri !== root.uri) return false;
+	const startsAfterRootStart = location.range.startLine > root.range.startLine || location.range.startLine === root.range.startLine && location.range.startChar >= root.range.startChar;
+	const endsBeforeRootEnd = location.range.endLine < root.range.endLine || location.range.endLine === root.range.endLine && location.range.endChar <= root.range.endChar;
+	return startsAfterRootStart && endsBeforeRootEnd;
+}
+function parseGraphPatches(value) {
+	if (!Array.isArray(value)) return null;
+	return value.filter(isGraphPatch);
+}
+function parseGraph(value) {
+	if (!value || typeof value !== "object") return null;
+	const candidate = value;
+	if (!Array.isArray(candidate.nodes) || !Array.isArray(candidate.edges)) return null;
+	return candidate;
+}
+function isGraphPatch(value) {
+	return Boolean(value && typeof value === "object" && "op" in value && typeof value.op === "string");
+}
+function isMachineConfig(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function findMachineConfigObjectLiteral(sourceFile, machineIndex = 0) {
+	const firstArgument = findCreateMachineCall(sourceFile, machineIndex)?.arguments[0];
+	return firstArgument ? unwrapObjectLiteralExpression(firstArgument) : null;
+}
+function findCreateMachineCall(sourceFile, machineIndex = 0) {
+	let found = null;
+	let currentMachineIndex = 0;
+	const visit = (node) => {
+		if (found) return;
+		if (ts$1.isCallExpression(node)) {
+			const expression = node.expression;
+			if (isCreateMachineExpression$1(expression)) {
+				const isSelectedMachine = currentMachineIndex === machineIndex;
+				currentMachineIndex += 1;
+				if (!isSelectedMachine) return;
+				found = node;
+				return;
+			}
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+}
+function findImplementationObjectLiteralForMachine(sourceFile, createMachineCall) {
+	const setupObject = findSetupObjectLiteralForMachine(sourceFile, createMachineCall);
+	if (setupObject) return setupObject;
+	const secondArgument = createMachineCall.arguments[1];
+	if (secondArgument) {
+		const implementationObject = unwrapObjectLiteralExpression(secondArgument);
+		if (implementationObject) return implementationObject;
+	}
+	if (isObjectOfProvideCall(createMachineCall)) {
+		const provideCall = createMachineCall.parent.parent;
+		if (ts$1.isCallExpression(provideCall)) {
+			const firstArgument = provideCall.arguments[0];
+			return firstArgument ? unwrapObjectLiteralExpression(firstArgument) : null;
+		}
+	}
+	return null;
+}
+function findSetupObjectLiteralForMachine(sourceFile, createMachineCall) {
+	const expression = createMachineCall.expression;
+	if (!ts$1.isPropertyAccessExpression(expression)) return null;
+	const receiver = unwrapExpression$1(expression.expression);
+	if (ts$1.isCallExpression(receiver) && isSetupCallExpression(receiver)) {
+		const setupArgument = receiver.arguments[0];
+		return setupArgument ? unwrapObjectLiteralExpression(setupArgument) : null;
+	}
+	if (!ts$1.isIdentifier(receiver)) return null;
+	for (const statement of sourceFile.statements) {
+		if (!ts$1.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) {
+			if (!ts$1.isIdentifier(declaration.name) || declaration.name.text !== receiver.text || !declaration.initializer) continue;
+			const initializer = unwrapExpression$1(declaration.initializer);
+			if (!ts$1.isCallExpression(initializer) || !isSetupCallExpression(initializer)) return null;
+			const setupArgument = initializer.arguments[0];
+			return setupArgument ? unwrapObjectLiteralExpression(setupArgument) : null;
+		}
+	}
+	return null;
+}
+function isObjectOfProvideCall(node) {
+	const parent = node.parent;
+	const grandparent = parent?.parent;
+	return !!parent && !!grandparent && ts$1.isPropertyAccessExpression(parent) && parent.expression === node && parent.name.text === "provide" && ts$1.isCallExpression(grandparent) && grandparent.expression === parent;
+}
+function isCreateMachineExpression$1(expression) {
+	const isMachineFactoryName = (name) => name === "createMachine" || name === "createMachineFromConfig";
+	return ts$1.isIdentifier(expression) && isMachineFactoryName(expression.text) || ts$1.isPropertyAccessExpression(expression) && isMachineFactoryName(expression.name.text);
+}
+function isSetupCallExpression(node) {
+	const expression = node.expression;
+	return ts$1.isIdentifier(expression) && expression.text === "setup" || ts$1.isPropertyAccessExpression(expression) && expression.name.text === "setup";
+}
+function unwrapObjectLiteralExpression(expression) {
+	const current = unwrapExpression$1(expression);
+	return ts$1.isObjectLiteralExpression(current) ? current : null;
+}
+function unwrapExpression$1(expression) {
+	let current = expression;
+	for (;;) {
+		if (ts$1.isParenthesizedExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts$1.isAsExpression(current) || ts$1.isSatisfiesExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts$1.isTypeAssertionExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		break;
+	}
+	return current;
+}
+function resolveStatePath(graph, nodeId) {
+	const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+	const segments = [];
+	let current = nodeById.get(nodeId);
+	if (!current) return null;
+	while (current && current.parentId !== null) {
+		segments.push(current.data.key);
+		current = nodeById.get(current.parentId);
+	}
+	return segments.reverse();
+}
+function getEdgeSourceId(graph, edgeId) {
+	return graph.edges.find((edge) => edge.id === edgeId)?.sourceId ?? null;
+}
+function resolveEdgeSourcePath(graph, edgeId) {
+	const sourceId = getEdgeSourceId(graph, edgeId);
+	return sourceId ? resolveStatePath(graph, sourceId) : null;
+}
+function resolvePatchOwner(patch, prevGraph, nextGraph) {
+	switch (patch.op) {
+		case "createState": {
+			const parentPath = resolveStatePath(nextGraph, patch.parentId);
+			return parentPath ? {
+				type: "state",
+				path: parentPath
+			} : { type: "covered" };
+		}
+		case "updateState": {
+			const nextPath = resolveStatePath(nextGraph, patch.stateId);
+			const prevPath = resolveStatePath(prevGraph, patch.stateId);
+			if (patch.key !== void 0 && prevPath && nextPath) return { type: "root" };
+			const path = nextPath ?? prevPath;
+			return path ? {
+				type: "state",
+				path
+			} : { type: "covered" };
+		}
+		case "deleteState": {
+			const node = prevGraph.nodes.find((item) => item.id === patch.stateId);
+			if (!node) return { type: "covered" };
+			if (!node.parentId) return { type: "root" };
+			const parentPath = resolveStatePath(prevGraph, node.parentId);
+			return parentPath ? {
+				type: "state",
+				path: parentPath
+			} : { type: "root" };
+		}
+		case "createTransition": {
+			const path = resolveStatePath(nextGraph, patch.sourceId);
+			return path ? {
+				type: "state",
+				path
+			} : { type: "covered" };
+		}
+		case "updateTransition": {
+			const path = resolveEdgeSourcePath(nextGraph, patch.transitionId) ?? resolveEdgeSourcePath(prevGraph, patch.transitionId);
+			return path ? {
+				type: "state",
+				path
+			} : { type: "covered" };
+		}
+		case "deleteTransition":
+		case "setGuard":
+		case "deleteGuard": {
+			const edgeId = "transitionId" in patch ? patch.transitionId : patch.edgeId;
+			const path = resolveEdgeSourcePath(nextGraph, edgeId) ?? resolveEdgeSourcePath(prevGraph, edgeId);
+			return path ? {
+				type: "state",
+				path
+			} : { type: "covered" };
+		}
+		case "createAction":
+		case "updateAction":
+		case "deleteAction": {
+			if ("nodeId" in patch.location) {
+				const path = resolveStatePath(nextGraph, patch.location.nodeId) ?? resolveStatePath(prevGraph, patch.location.nodeId);
+				return path ? {
+					type: "state",
+					path
+				} : { type: "covered" };
+			}
+			const path = resolveEdgeSourcePath(nextGraph, patch.location.edgeId) ?? resolveEdgeSourcePath(prevGraph, patch.location.edgeId);
+			return path ? {
+				type: "state",
+				path
+			} : { type: "covered" };
+		}
+		case "createInvoke":
+		case "updateInvoke":
+		case "deleteInvoke":
+		case "createTag":
+		case "deleteTag": {
+			const path = resolveStatePath(nextGraph, patch.nodeId) ?? resolveStatePath(prevGraph, patch.nodeId);
+			return path ? {
+				type: "state",
+				path
+			} : { type: "covered" };
+		}
+		case "updateSchemas": return { type: "root" };
+		default: return { type: "root" };
+	}
+}
+function deriveReplacementPlan(patches, prevGraph, nextGraph) {
+	const rawPaths = [];
+	const hasConcretePatch = patches.some((patch) => patch.op !== "updateSchemas");
+	for (const patch of patches) {
+		if (patch.op === "updateSchemas" && hasConcretePatch) continue;
+		const owner = resolvePatchOwner(patch, prevGraph, nextGraph);
+		if (owner.type === "root") return { type: "root" };
+		if (owner.type === "covered") continue;
+		rawPaths.push(owner.path);
+	}
+	const reducedPaths = reducePaths(rawPaths);
+	if (reducedPaths.length === 0 || reducedPaths.some((path) => path.length === 0)) return { type: "root" };
+	return {
+		type: "states",
+		paths: reducedPaths
+	};
+}
+function dropCoveredSchemaPatches(patches, hasConcreteReplacement) {
+	return hasConcreteReplacement ? patches.filter((patch) => patch.op !== "updateSchemas") : patches;
+}
+function reducePaths(paths) {
+	const uniquePaths = Array.from(new Set(paths.map((path) => path.join(".")))).map((value) => value === "" ? [] : value.split(".")).sort((a, b) => a.length - b.length);
+	return uniquePaths.filter((path, index) => {
+		return !uniquePaths.some((candidate, candidateIndex) => {
+			if (candidateIndex === index || candidate.length >= path.length) return false;
+			return candidate.every((segment, segmentIndex) => segment === path[segmentIndex]);
+		});
+	});
+}
+function getStateConfigByPath(machineConfig, path) {
+	let current = machineConfig;
+	for (const segment of path) {
+		const states = current?.states;
+		if (!isMachineConfig(states)) return;
+		const next = states[segment];
+		if (!isMachineConfig(next)) return;
+		current = next;
+	}
+	return current;
+}
+function getStateObjectLiteralByPath(root, path) {
+	let current = root;
+	for (const segment of path) {
+		if (!current) return null;
+		const statesProperty = getObjectLiteralProperty(current, "states");
+		current = statesProperty && getObjectLiteralProperty(statesProperty, segment);
+	}
+	return current;
+}
+function offsetAtRangePosition(sourceText, line, character) {
+	if (line <= 0) return character;
+	let currentLine = 0;
+	for (let index = 0; index < sourceText.length; index += 1) {
+		if (sourceText.charCodeAt(index) !== 10) continue;
+		currentLine += 1;
+		if (currentLine === line) return index + 1 + character;
+	}
+	return sourceText.length;
+}
+function getObjectLiteralProperty(objectLiteral, propertyName) {
+	for (const property of objectLiteral.properties) {
+		if (!ts$1.isPropertyAssignment(property)) continue;
+		if (getPropertyNameText$1(property.name) !== propertyName) continue;
+		return unwrapObjectLiteralExpression(property.initializer) ?? null;
+	}
+	return null;
+}
+function getPropertyNameText$1(name) {
+	if (ts$1.isIdentifier(name) || ts$1.isStringLiteral(name) || ts$1.isNumericLiteral(name)) return name.text;
+	if (ts$1.isComputedPropertyName(name)) {
+		const expression = name.expression;
+		if (ts$1.isStringLiteral(expression) || ts$1.isNoSubstitutionTemplateLiteral(expression) || ts$1.isNumericLiteral(expression)) return expression.text;
+	}
+	return null;
+}
+function createReplacement(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, node), sourceFile, formatting)
+	};
+}
+function addCodeImportReplacements(document, sourceFile, machineConfig, replacements) {
+	const importReplacements = createCodeImportReplacements(document, sourceFile, collectCodeImports(machineConfig));
+	return [...replacements, ...importReplacements];
+}
+function collectCodeImports(value) {
+	const imports = [];
+	const visit = (item) => {
+		if (!item || typeof item !== "object") return;
+		if (Array.isArray(item)) {
+			for (const child of item) visit(child);
+			return;
+		}
+		if (isInlineExpressionDirective(item)) {
+			const itemImports = item.imports;
+			if (Array.isArray(itemImports)) {
+				for (const candidate of itemImports) if (isCodeImport(candidate)) imports.push(candidate);
+			}
+		}
+		for (const child of Object.values(item)) visit(child);
+	};
+	visit(value);
+	return imports;
+}
+function isCodeImport(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const candidate = value;
+	return typeof candidate.package === "string" && typeof candidate.import === "string" && (!candidate.version || typeof candidate.version === "string") && (!candidate.importKind || candidate.importKind === "named" || candidate.importKind === "default" || candidate.importKind === "namespace");
+}
+function createCodeImportReplacements(document, sourceFile, imports) {
+	const namedImportsByPackage = /* @__PURE__ */ new Map();
+	for (const codeImport of imports) {
+		if ((codeImport.importKind ?? "named") !== "named") continue;
+		const namedImports = namedImportsByPackage.get(codeImport.package) ?? /* @__PURE__ */ new Set();
+		namedImports.add(codeImport.import);
+		namedImportsByPackage.set(codeImport.package, namedImports);
+	}
+	const replacements = [];
+	for (const [packageName, importNames] of namedImportsByPackage) {
+		const missing = new Set(importNames);
+		const importDeclaration = findImportDeclaration(sourceFile, packageName);
+		if (importDeclaration) {
+			const namedBindings = importDeclaration.importClause?.namedBindings;
+			if (namedBindings && ts$1.isNamedImports(namedBindings)) {
+				for (const element of namedBindings.elements) missing.delete(element.name.text);
+				if (missing.size > 0) {
+					const insertion = `${namedBindings.elements.length > 0 ? ", " : ""}${[...missing].sort().join(", ")}`;
+					replacements.push(createOffsetReplacement(document, namedBindings.elements.end, namedBindings.elements.end, insertion));
+				}
+			}
+			continue;
+		}
+		replacements.push(createOffsetReplacement(document, getImportInsertionOffset(sourceFile), getImportInsertionOffset(sourceFile), `import { ${[...missing].sort().join(", ")} } from "${packageName}";${getLineBreak(sourceFile)}`));
+	}
+	return replacements;
+}
+function findImportDeclaration(sourceFile, packageName) {
+	for (const statement of sourceFile.statements) if (ts$1.isImportDeclaration(statement) && ts$1.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === packageName) return statement;
+	return null;
+}
+function getImportInsertionOffset(sourceFile) {
+	let offset = 0;
+	for (const statement of sourceFile.statements) {
+		if (!ts$1.isImportDeclaration(statement)) break;
+		offset = statement.getEnd();
+		const nextLineStart = getLineStartOffset(sourceFile.text, offset + 1);
+		if (nextLineStart > offset) offset = nextLineStart;
+	}
+	return offset;
+}
+function getDocumentUri(document) {
+	return (typeof document.uri === "string" ? document.uri : document.uri?.toString()) ?? document.fileName;
+}
+function tryCreateSemanticReplacements(document, sourceFile, machineConfigNode, patches, prevGraph, nextGraph) {
+	const split = getSemanticStateRenamePatchSplit(patches, prevGraph, nextGraph);
+	if (!split || split.remainingPatches.length > 0) return null;
+	const replacements = [];
+	const targetLiterals = collectTargetStringLiterals(machineConfigNode).map((target) => ({
+		...target,
+		document,
+		sourceFile
+	}));
+	for (const rename of split.renames) {
+		const parentObject = getStateObjectLiteralByPath(machineConfigNode, rename.parentPath);
+		if (!parentObject) return null;
+		const renameReplacements = createStateKeyRenameReplacementsForTarget(document, sourceFile, parentObject, rename, void 0, targetLiterals);
+		if (!renameReplacements || hasDuplicateReplacementRange([...replacements, ...renameReplacements])) return null;
+		replacements.push(...renameReplacements);
+	}
+	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 targetLiterals = await collectMappedTargetStringLiterals(document, sourceFile, machineConfigNode, sourceLocations, openTextDocument);
+	let activeSourceLocations = sourceLocations;
+	for (const rename of split.renames) {
+		const parentTarget = await getStateMembershipParentTargetForDocuments(document, sourceFile, machineConfigNode, activeSourceLocations, rename.parentPath, openTextDocument, getStateObjectLiteralByPath);
+		if (!parentTarget) return null;
+		const renameReplacements = createStateKeyRenameReplacementsForTarget(parentTarget.document, parentTarget.sourceFile, parentTarget.node, rename, activeSourceLocations, targetLiterals, parentTarget.nodeKind, parentTarget.nodeKind === "statesObject" && rename.parentPath.length === 0 ? machineConfigNode : parentTarget.node);
+		if (!renameReplacements || hasDuplicateReplacementRange([...replacements, ...renameReplacements])) return null;
+		replacements.push(...renameReplacements);
+		activeSourceLocations = createRenamedSourceLocations(activeSourceLocations, rename);
+	}
+	return {
+		replacements: replacements.sort(compareReplacementRangesDescending),
+		remainingPatches: split.remainingPatches,
+		sourceLocations: activeSourceLocations
+	};
+}
+function getSemanticStateRenameFromPatch(patch, prevGraph, nextGraph) {
+	if (patch.op !== "updateState" || patch.key === void 0) return null;
+	const prevPath = resolveStatePath(prevGraph, patch.stateId);
+	const nextPath = resolveStatePath(nextGraph, patch.stateId);
+	if (!prevPath || !nextPath || prevPath.length !== nextPath.length || prevPath.length === 0) return null;
+	const oldKey = prevPath[prevPath.length - 1];
+	const newKey = nextPath[nextPath.length - 1];
+	const parentPath = prevPath.slice(0, -1);
+	if (oldKey === newKey) return null;
+	return {
+		oldKey,
+		newKey,
+		oldPath: prevPath,
+		newPath: nextPath,
+		parentPath,
+		oldAbsolutePath: getAbsoluteStatePath(prevGraph, patch.stateId),
+		newAbsolutePath: getAbsoluteStatePath(nextGraph, patch.stateId)
+	};
+}
+function getSemanticStateRenamePatchSplit(patches, prevGraph, nextGraph) {
+	const renames = [];
+	const remainingPatches = [];
+	for (const patch of patches) {
+		const patchRename = getSemanticStateRenameFromPatch(patch, prevGraph, nextGraph);
+		if (patchRename) {
+			renames.push(patchRename);
+			if (getStatePropertyNamesFromUpdatePatch(patch).length > 0) remainingPatches.push(patch);
+			continue;
+		}
+		remainingPatches.push(patch);
+	}
+	return renames.length > 0 ? {
+		renames,
+		remainingPatches
+	} : null;
+}
+function hasNestedStateRenameBatch(patches, prevGraph, nextGraph) {
+	const renames = patches.flatMap((patch) => {
+		const rename = getSemanticStateRenameFromPatch(patch, prevGraph, nextGraph);
+		return rename ? [rename] : [];
+	});
+	return renames.some((ancestor, ancestorIndex) => renames.some((descendant, descendantIndex) => ancestorIndex !== descendantIndex && ancestor.oldPath.length < descendant.oldPath.length && isPathEqualOrDescendant(descendant.oldPath, ancestor.oldPath)));
+}
+function hasDuplicateReplacementRange(replacements) {
+	const ranges = /* @__PURE__ */ new Set();
+	for (const replacement of replacements) {
+		const key = `${replacement.uri ?? ""}:${replacement.range.startLine}:${replacement.range.startChar}:${replacement.range.endLine}:${replacement.range.endChar}`;
+		if (ranges.has(key)) return true;
+		ranges.add(key);
+	}
+	return false;
+}
+function createRenamedSourceLocations(sourceLocations, rename) {
+	if (!sourceLocations) return;
+	return {
+		...sourceLocations,
+		states: sourceLocations.states.map((location) => {
+			if (!isPathEqualOrDescendant(location.path, rename.oldPath)) return location;
+			return {
+				...location,
+				path: [...rename.newPath, ...location.path.slice(rename.oldPath.length)]
+			};
+		}),
+		transitionFunctions: sourceLocations.transitionFunctions?.map((location) => ({
+			...location,
+			sourcePaths: location.sourcePaths.map((path) => isPathEqualOrDescendant(path, rename.oldPath) ? [...rename.newPath, ...path.slice(rename.oldPath.length)] : path)
+		}))
+	};
+}
+function createStateKeyRenameReplacementsForTarget(document, sourceFile, parentObject, rename, sourceLocations, targetLiterals, nodeKind = "machineConfig", initialOwnerObject = parentObject) {
+	const statesObject = nodeKind === "statesObject" ? parentObject : getObjectLiteralProperty(parentObject, "states");
+	const location = sourceLocations?.states.find((item) => rename.oldPath && arePathsEqual(item.path, rename.oldPath));
+	const stateProperty = statesObject && (findObjectLiteralProperty(statesObject, rename.oldKey) ?? findObjectLiteralPropertyByRange(sourceFile, statesObject, location?.keyRange));
+	if (!statesObject || !stateProperty) return null;
+	const keyReplacement = createStatePropertyRenameReplacement(document, sourceFile, stateProperty, rename.oldKey, rename.newKey, location?.keySource);
+	if (!keyReplacement) return null;
+	const replacements = [keyReplacement];
+	const initialProperty = getPropertyAssignment(initialOwnerObject, "initial");
+	if (initialProperty) {
+		const initialReplacement = createStringInitializerRenameReplacement(document, sourceFile, initialProperty.initializer, rename.oldKey, rename.newKey);
+		if (initialReplacement) replacements.push(initialReplacement);
+	}
+	const supportedScope = new Set([rename.parentPath.join("."), ...getDirectChildStatePaths(nodeKind === "statesObject" ? initialOwnerObject : parentObject, rename.parentPath).map((path) => path.join("."))]);
+	for (const target of targetLiterals) {
+		if (!referencesRenamedState(target.node.text, rename)) continue;
+		if (!referencesRenamedAbsoluteState(target.node.text, rename)) {
+			const initialSourcePaths = target.initialSourcePaths ?? [];
+			if (initialSourcePaths.length > 0) {
+				if (!target.sourcePaths.every((sourcePath) => arePathsEqual(sourcePath, rename.parentPath))) {
+					if (initialSourcePaths.length === target.sourcePaths.length && !initialSourcePaths.some((sourcePath) => arePathsEqual(sourcePath, rename.parentPath))) continue;
+					return null;
+				}
+			} else for (const sourcePath of target.sourcePaths) {
+				const sourceKey = sourcePath.join(".");
+				if (!(sourcePath.length === rename.parentPath.length || arePathsEqual(sourcePath.slice(0, -1), rename.parentPath)) || !supportedScope.has(sourceKey)) return null;
+			}
+		}
+		const replacement = createStringLiteralReplacement(target.document, target.sourceFile, target.node, renameStateReference(target.node.text, rename));
+		replacements.push(replacement);
+	}
+	return replacements;
+}
+function getDirectChildStatePaths(stateObject, parentPath) {
+	const statesObject = getObjectLiteralProperty(stateObject, "states");
+	if (!statesObject) return [];
+	return statesObject.properties.flatMap((property) => {
+		const key = getStatePropertyKeyText(property);
+		if (!key) return [];
+		return [[...parentPath, key]];
+	});
+}
+function collectTargetStringLiterals(machineConfigNode) {
+	const literals = [];
+	const bindings = collectTopLevelExpressionBindings(machineConfigNode.getSourceFile());
+	const visitStateObject = (stateObject, sourcePath) => {
+		collectInitialTargetStringLiterals(stateObject, sourcePath, literals, bindings);
+		for (const propertyName of [
+			"always",
+			"after",
+			"on",
+			"onDone"
+		]) {
+			const property = getPropertyAssignment(stateObject, propertyName);
+			if (!property) continue;
+			collectTargetStringLiteralsFromExpression(property.initializer, sourcePath, literals, bindings);
+		}
+		const statesObject = getObjectLiteralProperty(stateObject, "states");
+		if (!statesObject) return;
+		for (const property of statesObject.properties) {
+			if (!ts$1.isPropertyAssignment(property)) continue;
+			const key = getPropertyNameText$1(property.name);
+			const childState = unwrapObjectLiteralExpression(property.initializer);
+			if (!key || !childState) continue;
+			visitStateObject(childState, [...sourcePath, key]);
+		}
+	};
+	visitStateObject(machineConfigNode, []);
+	return literals;
+}
+function collectInitialTargetStringLiterals(stateObject, sourcePath, literals, bindings) {
+	const initialProperty = getPropertyAssignment(stateObject, "initial");
+	if (!initialProperty) return;
+	const initializer = unwrapExpression$1(initialProperty.initializer);
+	if (ts$1.isObjectLiteralExpression(initializer)) {
+		const initialLiterals = [];
+		collectTargetStringLiteralsFromExpression(initializer, sourcePath, initialLiterals, bindings);
+		for (const literal of initialLiterals) for (const literalSourcePath of literal.sourcePaths) addTargetLiteral(literals, literal.node, literalSourcePath, true);
+	}
+}
+async function collectMappedTargetStringLiterals(rootDocument, rootSourceFile, machineConfigNode, sourceLocations, openTextDocument) {
+	const literals = collectTargetStringLiterals(machineConfigNode).map((target) => ({
+		...target,
+		document: rootDocument,
+		sourceFile: rootSourceFile
+	}));
+	if (!sourceLocations) return literals;
+	const seen = new Set(literals.map((target) => getTargetLiteralReplacementKey(rootDocument, rootSourceFile, target.node)));
+	const targetByKey = new Map(literals.map((target) => [getTargetLiteralReplacementKey(rootDocument, rootSourceFile, target.node), target]));
+	for (const location of sourceLocations.states) {
+		const targetDocument = isSourceLocationForDocument(location.uri, rootDocument) ? rootDocument : await openDocumentBySourceUri(location.uri, openTextDocument);
+		if (!targetDocument) continue;
+		const targetSourceFile = isSourceLocationForDocument(location.uri, rootDocument) ? rootSourceFile : createSourceFile(targetDocument, targetDocument.getText());
+		const stateObject = findObjectLiteralByRange(targetSourceFile, location.range);
+		if (!stateObject) continue;
+		const stateLiterals = [];
+		collectTargetStringLiteralsFromStateObject(stateObject, location.path, stateLiterals, collectTopLevelExpressionBindings(targetSourceFile));
+		for (const target of stateLiterals) {
+			const key = getTargetLiteralReplacementKey(targetDocument, targetSourceFile, target.node);
+			if (seen.has(key)) {
+				const existing = targetByKey.get(key);
+				if (existing) {
+					mergeTargetSourcePaths(existing, target.sourcePaths);
+					mergeInitialSourcePaths(existing, target.initialSourcePaths ?? []);
+				}
+				continue;
+			}
+			seen.add(key);
+			const mappedTarget = {
+				...target,
+				document: targetDocument,
+				sourceFile: targetSourceFile
+			};
+			literals.push(mappedTarget);
+			targetByKey.set(key, mappedTarget);
+		}
+	}
+	for (const location of sourceLocations.transitionFunctions ?? []) {
+		const targetDocument = isSourceLocationForDocument(location.uri, rootDocument) ? rootDocument : await openDocumentBySourceUri(location.uri, openTextDocument);
+		if (!targetDocument) continue;
+		const targetSourceFile = isSourceLocationForDocument(location.uri, rootDocument) ? rootSourceFile : createSourceFile(targetDocument, targetDocument.getText());
+		const fn = findTransitionFunctionByRange(targetSourceFile, location.range);
+		if (!fn) continue;
+		const targetParameterIndexes = getTransitionTargetParameterIndexes(fn);
+		if (targetParameterIndexes.length > 0) {
+			const callTargets = collectTransitionCallArgumentLiterals(machineConfigNode, location.symbol, targetParameterIndexes);
+			for (const target of callTargets) {
+				const key = getTargetLiteralReplacementKey(rootDocument, rootSourceFile, target.node);
+				if (seen.has(key)) {
+					const existing = targetByKey.get(key);
+					if (existing) {
+						mergeTargetSourcePaths(existing, target.sourcePaths);
+						mergeInitialSourcePaths(existing, target.initialSourcePaths ?? []);
+					}
+					continue;
+				}
+				seen.add(key);
+				const mappedTarget = {
+					...target,
+					document: rootDocument,
+					sourceFile: rootSourceFile
+				};
+				literals.push(mappedTarget);
+				targetByKey.set(key, mappedTarget);
+			}
+		}
+		const functionLiterals = [];
+		const bindings = collectTopLevelExpressionBindings(targetSourceFile);
+		for (const sourcePath of location.sourcePaths) collectTargetStringLiteralsFromFunction(fn, sourcePath, functionLiterals, bindings, new Set([location.symbol]));
+		for (const target of functionLiterals) {
+			const key = getTargetLiteralReplacementKey(targetDocument, targetSourceFile, target.node);
+			if (seen.has(key)) {
+				const existing = targetByKey.get(key);
+				if (existing) {
+					mergeTargetSourcePaths(existing, target.sourcePaths);
+					mergeInitialSourcePaths(existing, target.initialSourcePaths ?? []);
+				}
+				continue;
+			}
+			seen.add(key);
+			const mappedTarget = {
+				...target,
+				document: targetDocument,
+				sourceFile: targetSourceFile
+			};
+			literals.push(mappedTarget);
+			targetByKey.set(key, mappedTarget);
+		}
+	}
+	return literals;
+}
+function findTransitionFunctionByRange(sourceFile, range) {
+	const start = offsetAtRangePosition(sourceFile.text, range.startLine, range.startChar);
+	const end = offsetAtRangePosition(sourceFile.text, range.endLine, range.endChar);
+	let found = null;
+	const visit = (node) => {
+		if (found) return;
+		if ((ts$1.isArrowFunction(node) || ts$1.isFunctionExpression(node) || ts$1.isFunctionDeclaration(node)) && node.getStart(sourceFile) === start && node.getEnd() >= end) {
+			found = node;
+			return;
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+}
+function getTransitionTargetParameterIndexes(fn) {
+	const parameterIndexes = /* @__PURE__ */ new Map();
+	for (const [index, parameter] of fn.parameters.entries()) if (ts$1.isIdentifier(parameter.name)) parameterIndexes.set(parameter.name.text, index);
+	const indexes = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (ts$1.isObjectLiteralExpression(node)) for (const property of node.properties) {
+			const targetIdentifier = ts$1.isShorthandPropertyAssignment(property) && property.name.text === "target" ? property.name : ts$1.isPropertyAssignment(property) && getPropertyNameText$1(property.name) === "target" && ts$1.isIdentifier(unwrapExpression$1(property.initializer)) ? unwrapExpression$1(property.initializer) : null;
+			if (targetIdentifier) {
+				const index = parameterIndexes.get(targetIdentifier.text);
+				if (index !== void 0) indexes.add(index);
+			}
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(fn);
+	return [...indexes];
+}
+function collectTransitionCallArgumentLiterals(machineConfigNode, symbol, targetParameterIndexes) {
+	const literals = [];
+	const visitExpression = (expression, sourcePath) => {
+		const current = unwrapExpression$1(expression);
+		if (ts$1.isCallExpression(current) && ts$1.isIdentifier(current.expression) && current.expression.text === symbol) {
+			for (const index of targetParameterIndexes) {
+				const argument = current.arguments[index];
+				if (argument && ts$1.isStringLiteralLike(unwrapExpression$1(argument))) addTargetLiteral(literals, unwrapExpression$1(argument), sourcePath);
+			}
+			return;
+		}
+		if (ts$1.isObjectLiteralExpression(current)) {
+			for (const property of current.properties) if (ts$1.isPropertyAssignment(property)) visitExpression(property.initializer, sourcePath);
+			else if (ts$1.isShorthandPropertyAssignment(property)) visitExpression(property.name, sourcePath);
+			else if (ts$1.isSpreadAssignment(property)) visitExpression(property.expression, sourcePath);
+			return;
+		}
+		if (ts$1.isArrayLiteralExpression(current)) {
+			for (const element of current.elements) if (ts$1.isExpression(element)) visitExpression(element, sourcePath);
+			return;
+		}
+		ts$1.forEachChild(current, (child) => {
+			if (ts$1.isExpression(child)) visitExpression(child, sourcePath);
+		});
+	};
+	const visitState = (stateObject, sourcePath) => {
+		for (const propertyName of [
+			"always",
+			"after",
+			"on",
+			"onDone"
+		]) {
+			const property = getPropertyAssignment(stateObject, propertyName);
+			if (property) visitExpression(property.initializer, sourcePath);
+		}
+		const states = getObjectLiteralProperty(stateObject, "states");
+		if (!states) return;
+		for (const property of states.properties) {
+			if (!ts$1.isPropertyAssignment(property)) continue;
+			const key = getPropertyNameText$1(property.name);
+			const child = unwrapObjectLiteralExpression(property.initializer);
+			if (key && child) visitState(child, [...sourcePath, key]);
+		}
+	};
+	visitState(machineConfigNode, []);
+	return literals;
+}
+function getTargetLiteralReplacementKey(document, sourceFile, node) {
+	return `${getDocumentUri(document)}:${node.getStart(sourceFile)}:${node.getEnd()}`;
+}
+function collectTargetStringLiteralsFromStateObject(stateObject, sourcePath, literals, bindings) {
+	collectInitialTargetStringLiterals(stateObject, sourcePath, literals, bindings);
+	for (const propertyName of [
+		"always",
+		"after",
+		"on",
+		"onDone"
+	]) {
+		const property = getPropertyAssignment(stateObject, propertyName);
+		if (!property) continue;
+		collectTargetStringLiteralsFromExpression(property.initializer, sourcePath, literals, bindings);
+	}
+	const statesObject = getObjectLiteralProperty(stateObject, "states");
+	if (!statesObject) return;
+	for (const property of statesObject.properties) {
+		if (!ts$1.isPropertyAssignment(property)) continue;
+		const key = getPropertyNameText$1(property.name);
+		const childState = unwrapObjectLiteralExpression(property.initializer);
+		if (!key || !childState) continue;
+		collectTargetStringLiteralsFromStateObject(childState, [...sourcePath, key], literals, bindings);
+	}
+}
+function collectTargetStringLiteralsFromExpression(expression, sourcePath, literals, bindings, seenBindings = /* @__PURE__ */ new Set()) {
+	const current = unwrapExpression$1(expression);
+	if (ts$1.isStringLiteralLike(current)) {
+		addTargetLiteral(literals, current, sourcePath);
+		return;
+	}
+	if (ts$1.isIdentifier(current)) {
+		if (seenBindings.has(current.text)) return;
+		const binding = bindings.get(current.text);
+		if (binding) {
+			const nextSeenBindings = new Set([...seenBindings, current.text]);
+			if (isTransitionFunctionBinding(binding)) collectTargetStringLiteralsFromFunction(binding, sourcePath, literals, bindings, nextSeenBindings);
+			else collectTargetStringLiteralsFromExpression(binding, sourcePath, literals, bindings, nextSeenBindings);
+		}
+		return;
+	}
+	if (ts$1.isArrowFunction(current) || ts$1.isFunctionExpression(current)) {
+		collectTargetStringLiteralsFromFunction(current, sourcePath, literals, bindings, seenBindings);
+		return;
+	}
+	if (ts$1.isCallExpression(current) && ts$1.isIdentifier(current.expression)) {
+		const binding = bindings.get(current.expression.text);
+		if (binding && isTransitionFunctionBinding(binding)) {
+			const scopedBindings = new Map(bindings);
+			for (const [index, parameter] of binding.parameters.entries()) {
+				if (!ts$1.isIdentifier(parameter.name)) continue;
+				const argument = current.arguments[index];
+				if (argument) scopedBindings.set(parameter.name.text, argument);
+				else if (parameter.initializer) scopedBindings.set(parameter.name.text, parameter.initializer);
+			}
+			collectTargetStringLiteralsFromFunction(binding, sourcePath, literals, scopedBindings, seenBindings);
+		}
+		return;
+	}
+	if (ts$1.isArrayLiteralExpression(current)) {
+		for (const element of current.elements) if (ts$1.isExpression(element)) collectTargetStringLiteralsFromExpression(element, sourcePath, literals, bindings, seenBindings);
+		return;
+	}
+	if (!ts$1.isObjectLiteralExpression(current)) return;
+	const targetProperty = current.properties.find((property) => ts$1.isPropertyAssignment(property) && getPropertyNameText$1(property.name) === "target" || ts$1.isShorthandPropertyAssignment(property) && property.name.text === "target");
+	if (targetProperty) {
+		collectTargetStringLiteralsFromExpression(ts$1.isPropertyAssignment(targetProperty) ? targetProperty.initializer : targetProperty.name, sourcePath, literals, bindings, seenBindings);
+		return;
+	}
+	for (const property of current.properties) {
+		if (!ts$1.isPropertyAssignment(property)) continue;
+		collectTargetStringLiteralsFromExpression(property.initializer, sourcePath, literals, bindings, seenBindings);
+	}
+}
+function collectTargetStringLiteralsFromFunctionBody(body, sourcePath, literals, bindings, seenBindings) {
+	const visit = (node) => {
+		if (ts$1.isFunctionLike(node)) return;
+		if (ts$1.isReturnStatement(node) && node.expression) {
+			collectTargetStringLiteralsFromExpression(node.expression, sourcePath, literals, bindings, seenBindings);
+			return;
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	ts$1.forEachChild(body, visit);
+}
+function isTransitionFunctionBinding(binding) {
+	return ts$1.isArrowFunction(binding) || ts$1.isFunctionExpression(binding) || ts$1.isFunctionDeclaration(binding);
+}
+function collectTargetStringLiteralsFromFunction(fn, sourcePath, literals, bindings, seenBindings) {
+	if (!fn.body) return;
+	if (ts$1.isBlock(fn.body)) {
+		collectTargetStringLiteralsFromFunctionBody(fn.body, sourcePath, literals, bindings, seenBindings);
+		return;
+	}
+	collectTargetStringLiteralsFromExpression(fn.body, sourcePath, literals, bindings, seenBindings);
+}
+function collectTopLevelExpressionBindings(sourceFile) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts$1.isFunctionDeclaration(statement) && statement.name) {
+			bindings.set(statement.name.text, statement);
+			continue;
+		}
+		if (!ts$1.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (ts$1.isIdentifier(declaration.name) && declaration.initializer) bindings.set(declaration.name.text, declaration.initializer);
+	}
+	return bindings;
+}
+function addTargetLiteral(literals, node, sourcePath, isInitialTarget = false) {
+	const existing = literals.find((literal) => literal.node.getStart() === node.getStart() && literal.node.getEnd() === node.getEnd());
+	if (existing) {
+		mergeTargetSourcePaths(existing, [sourcePath]);
+		if (isInitialTarget) mergeInitialSourcePaths(existing, [sourcePath]);
+		return;
+	}
+	literals.push({
+		node,
+		sourcePaths: [sourcePath],
+		...isInitialTarget ? { initialSourcePaths: [sourcePath] } : {}
+	});
+}
+function mergeInitialSourcePaths(target, initialSourcePaths) {
+	if (initialSourcePaths.length === 0) return;
+	const merged = target.initialSourcePaths ?? [];
+	for (const sourcePath of initialSourcePaths) if (!merged.some((existing) => arePathsEqual(existing, sourcePath))) merged.push(sourcePath);
+	target.initialSourcePaths = merged;
+}
+function mergeTargetSourcePaths(target, sourcePaths) {
+	for (const sourcePath of sourcePaths) if (!target.sourcePaths.some((existing) => arePathsEqual(existing, sourcePath))) target.sourcePaths.push(sourcePath);
+}
+function referencesRenamedState(value, rename) {
+	if (referencesRenamedSibling(value, rename.oldKey)) return true;
+	return referencesRenamedAbsoluteState(value, rename);
+}
+function referencesRenamedAbsoluteState(value, rename) {
+	const oldAbsolutePath = rename.oldAbsolutePath;
+	return oldAbsolutePath !== void 0 && (value === oldAbsolutePath || value.startsWith(`${oldAbsolutePath}.`));
+}
+function renameStateReference(value, rename) {
+	const oldAbsolutePath = rename.oldAbsolutePath;
+	const newAbsolutePath = rename.newAbsolutePath;
+	if (oldAbsolutePath && newAbsolutePath) {
+		if (value === oldAbsolutePath) return newAbsolutePath;
+		if (value.startsWith(`${oldAbsolutePath}.`)) return `${newAbsolutePath}${value.slice(oldAbsolutePath.length)}`;
+	}
+	return renameSiblingReference(value, rename.oldKey, rename.newKey);
+}
+function referencesRenamedSibling(value, oldKey) {
+	return value === oldKey || value.startsWith(`${oldKey}.`);
+}
+function getAbsoluteStatePath(graph, nodeId) {
+	const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+	const node = nodeById.get(nodeId);
+	if (!node) return;
+	const resolvedId = resolveGraphStateId(node, nodeById);
+	return resolvedId ? `#${resolvedId}` : void 0;
+}
+function resolveGraphStateId(node, nodeById) {
+	const authoredId = node.data.nodeId;
+	if (authoredId && !authoredId.startsWith("$auto-")) return authoredId.replace(/^#/, "");
+	if (node.parentId === null) return node.data.key;
+	const parent = nodeById.get(node.parentId);
+	const parentId = parent && resolveGraphStateId(parent, nodeById);
+	return parentId ? `${parentId}.${node.data.key}` : node.data.key;
+}
+function renameSiblingReference(value, oldKey, newKey) {
+	if (value === oldKey) return newKey;
+	return value.startsWith(`${oldKey}.`) ? `${newKey}${value.slice(oldKey.length)}` : value;
+}
+function arePathsEqual(left, right) {
+	return left.length === right.length && left.every((segment, index) => segment === right[index]);
+}
+function createPropertyNameReplacement(document, sourceFile, propertyName, nextName) {
+	if (!isSupportedPropertyName(propertyName)) return null;
+	const start = document.positionAt(propertyName.getStart(sourceFile));
+	const end = document.positionAt(propertyName.getEnd());
+	const sourceText = sourceFile.text.slice(propertyName.getStart(sourceFile), propertyName.getEnd());
+	return {
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		uri: getDocumentUri(document),
+		newText: formatPropertyNameText(propertyName, nextName, sourceText)
+	};
+}
+function createStatePropertyRenameReplacement(document, sourceFile, property, oldKey, newKey, keySource) {
+	if (keySource?.machineLocal && keySource.valueRange && isSourceRangeInDocument(sourceFile, keySource.valueRange)) return createSourceRangeReplacement(document, sourceFile, keySource.valueRange, formatStringLiteralText(sourceFile.text.slice(offsetAtRangePosition(sourceFile.text, keySource.valueRange.startLine, keySource.valueRange.startChar), offsetAtRangePosition(sourceFile.text, keySource.valueRange.endLine, keySource.valueRange.endChar)), newKey));
+	if (ts$1.isPropertyAssignment(property)) {
+		if (ts$1.isComputedPropertyName(property.name)) return createPropertyNameLiteralReplacement(document, sourceFile, property.name, newKey);
+		return createPropertyNameReplacement(document, sourceFile, property.name, newKey);
+	}
+	if (!ts$1.isShorthandPropertyAssignment(property)) return null;
+	const start = document.positionAt(property.name.getStart(sourceFile));
+	const end = document.positionAt(property.name.getEnd());
+	const sourceText = sourceFile.text.slice(property.name.getStart(sourceFile), property.name.getEnd());
+	const nextPropertyName = formatPropertyNameText(property.name, newKey, sourceText);
+	return {
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		uri: getDocumentUri(document),
+		newText: `${nextPropertyName}: ${oldKey}`
+	};
+}
+function createPropertyNameLiteralReplacement(document, sourceFile, propertyName, nextName) {
+	const start = document.positionAt(propertyName.getStart(sourceFile));
+	const end = document.positionAt(propertyName.getEnd());
+	return {
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		uri: getDocumentUri(document),
+		newText: isIdentifierText(nextName) ? nextName : JSON.stringify(nextName)
+	};
+}
+function createStringInitializerRenameReplacement(document, sourceFile, expression, oldValue, newValue) {
+	if (!ts$1.isStringLiteralLike(expression) || expression.text !== oldValue) return null;
+	return createStringLiteralReplacement(document, sourceFile, expression, newValue);
+}
+function createStringLiteralReplacement(document, sourceFile, expression, nextValue) {
+	const start = document.positionAt(expression.getStart(sourceFile));
+	const end = document.positionAt(expression.getEnd());
+	const sourceText = sourceFile.text.slice(expression.getStart(sourceFile), expression.getEnd());
+	return {
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		uri: getDocumentUri(document),
+		newText: formatStringLiteralText(sourceText, nextValue)
+	};
+}
+function createSourceRangeReplacement(document, sourceFile, range, newText) {
+	const startOffset = offsetAtRangePosition(sourceFile.text, range.startLine, range.startChar);
+	const endOffset = offsetAtRangePosition(sourceFile.text, range.endLine, range.endChar);
+	const start = document.positionAt(startOffset);
+	const end = document.positionAt(endOffset);
+	return {
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		uri: getDocumentUri(document),
+		newText
+	};
+}
+function isSourceRangeInDocument(sourceFile, range) {
+	return offsetAtRangePosition(sourceFile.text, range.startLine, range.startChar) <= sourceFile.text.length;
+}
+function isSupportedPropertyName(propertyName) {
+	if (ts$1.isIdentifier(propertyName) || ts$1.isStringLiteral(propertyName) || ts$1.isNumericLiteral(propertyName)) return true;
+	if (ts$1.isComputedPropertyName(propertyName)) {
+		const expression = propertyName.expression;
+		return ts$1.isStringLiteral(expression) || ts$1.isNoSubstitutionTemplateLiteral(expression) || ts$1.isNumericLiteral(expression);
+	}
+	return false;
+}
+function formatPropertyNameText(propertyName, nextName, sourceText) {
+	if (ts$1.isIdentifier(propertyName) && isIdentifierText(nextName)) return nextName;
+	if (ts$1.isComputedPropertyName(propertyName)) return `[${formatStringLiteralText(sourceText.slice(1, -1), nextName)}]`;
+	return formatStringLiteralText(sourceText, nextName);
+}
+function formatStringLiteralText(sourceText, nextValue) {
+	const quote = sourceText.startsWith("'") ? "'" : sourceText.startsWith("`") ? "`" : "\"";
+	return `${quote}${quote === "'" ? nextValue.replace(/\\/g, "\\\\").replace(/'/g, "\\'") : quote === "\"" ? nextValue.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") : nextValue.replace(/\\/g, "\\\\").replace(/`/g, "\\`")}${quote}`;
+}
+function compareReplacementRangesDescending(a, b) {
+	if (a.range.startLine !== b.range.startLine) return b.range.startLine - a.range.startLine;
+	return b.range.startChar - a.range.startChar;
+}
+function normalizeOverlappingReplacements(replacements) {
+	const result = [];
+	for (const candidate of replacements) {
+		if (replacements.find((other) => other !== candidate && other.uri === candidate.uri && rangeContains(other.range, candidate.range))) continue;
+		const overlappingDeletion = result.find((other) => other.uri === candidate.uri && other.newText === "" && candidate.newText === "" && rangesOverlap(other.range, candidate.range));
+		if (overlappingDeletion) {
+			overlappingDeletion.range = unionRanges(overlappingDeletion.range, candidate.range);
+			continue;
+		}
+		result.push(candidate);
+	}
+	return result;
+}
+const position = (line, char) => [line, char];
+const comparePosition = (a, b) => a[0] - b[0] || a[1] - b[1];
+const rangeStart = (range) => position(range.startLine, range.startChar);
+const rangeEnd = (range) => position(range.endLine, range.endChar);
+const rangeContains = (outer, inner) => comparePosition(rangeStart(outer), rangeStart(inner)) <= 0 && comparePosition(rangeEnd(outer), rangeEnd(inner)) >= 0;
+const rangesOverlap = (a, b) => comparePosition(rangeStart(a), rangeEnd(b)) <= 0 && comparePosition(rangeStart(b), rangeEnd(a)) <= 0;
+function unionRanges(a, b) {
+	const start = comparePosition(rangeStart(a), rangeStart(b)) <= 0 ? a : b;
+	const end = comparePosition(rangeEnd(a), rangeEnd(b)) >= 0 ? a : b;
+	return {
+		startLine: start.startLine,
+		startChar: start.startChar,
+		endLine: end.endLine,
+		endChar: end.endChar
+	};
+}
+function printExpression(expression, sourceFile, formatting) {
+	return reindentPrintedExpression(ts$1.createPrinter({ newLine: formatting.newLineKind }).printNode(ts$1.EmitHint.Expression, expression, sourceFile), formatting);
+}
+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;
+	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);
+		return `${formatting.baseIndent}${formatting.indentUnit.repeat(indentLevel)}${line.slice(leadingSpaces)}`;
+	}).join(lineSeparator);
+}
+function getFormattingContext(document, sourceFile, node) {
+	const sourceText = sourceFile.text;
+	const lineStart = getLineStartOffset(sourceText, node.getStart(sourceFile));
+	const lineIndent = sourceText.slice(lineStart).match(/^[ \t]*/)?.[0] ?? "";
+	const editorIndentUnit = getEditorIndentUnit(document);
+	const inferredIndentUnit = inferIndentUnitFromNode(sourceText, node, sourceFile, lineIndent) ?? inferIndentUnitFromSource(sourceText);
+	return {
+		baseIndent: lineIndent,
+		indentUnit: editorIndentUnit ?? inferredIndentUnit ?? "    ",
+		newLineKind: sourceText.includes("\r\n") ? ts$1.NewLineKind.CarriageReturnLineFeed : ts$1.NewLineKind.LineFeed
+	};
+}
+function getFormattingContextForExpression(document, sourceFile, node) {
+	const sourceText = sourceFile.text;
+	const nodeStart = node.getStart(sourceFile);
+	const lineStart = getLineStartOffset(sourceText, nodeStart);
+	return {
+		baseIndent: sourceText.slice(lineStart, nodeStart).match(/^[ \t]*/)?.[0] ?? "",
+		indentUnit: getEditorIndentUnit(document) ?? inferIndentUnitFromSource(sourceText) ?? "    ",
+		newLineKind: sourceText.includes("\r\n") ? ts$1.NewLineKind.CarriageReturnLineFeed : ts$1.NewLineKind.LineFeed
+	};
+}
+function getEditorIndentUnit(document) {
+	return document.editorIndentUnit ?? null;
+}
+function inferIndentUnitFromNode(sourceText, node, sourceFile, baseIndent) {
+	return getShortestIndent(sourceText.slice(node.getStart(sourceFile), node.getEnd()).split(/\r?\n/).slice(1).map((line) => line.match(/^[ \t]*/)?.[0] ?? "").filter((indent) => indent.startsWith(baseIndent)).map((indent) => indent.slice(baseIndent.length)).filter((indent) => indent.length > 0));
+}
+function inferIndentUnitFromSource(sourceText) {
+	return getShortestIndent(sourceText.split(/\r?\n/).map((line) => line.match(/^[ \t]+(?=\S)/)?.[0] ?? "").filter(Boolean));
+}
+function getShortestIndent(indents) {
+	if (indents.length === 0) return null;
+	return indents.reduce((shortest, current) => current.length < shortest.length ? current : shortest);
+}
+function getLineStartOffset(sourceText, offset) {
+	const lastNewline = sourceText.lastIndexOf("\n", offset - 1);
+	if (lastNewline === -1) return 0;
+	return lastNewline + 1;
+}
+function valueToExpression(value, existingExpression) {
+	const rawCodeExpression = rawCodeToExpression(value);
+	if (rawCodeExpression) return rawCodeExpression;
+	const inlineExpression = inlineExpressionDirectiveToExpression(value);
+	if (inlineExpression) return inlineExpression;
+	if (value === null) return ts$1.factory.createNull();
+	if (typeof value === "string") return ts$1.factory.createStringLiteral(value);
+	if (typeof value === "number") {
+		if (value < 0) return ts$1.factory.createPrefixUnaryExpression(ts$1.SyntaxKind.MinusToken, ts$1.factory.createNumericLiteral(Math.abs(value)));
+		return ts$1.factory.createNumericLiteral(value);
+	}
+	if (typeof value === "boolean") return value ? ts$1.factory.createTrue() : ts$1.factory.createFalse();
+	if (Array.isArray(value)) {
+		const existingArray = existingExpression && ts$1.isArrayLiteralExpression(existingExpression) ? existingExpression : void 0;
+		const elements = value.map((item, index) => valueToExpression(item, existingArray && ts$1.isExpression(existingArray.elements[index]) ? existingArray.elements[index] : void 0));
+		if (existingArray) {
+			const updatedArray = ts$1.factory.createArrayLiteralExpression(elements, true);
+			ts$1.setOriginalNode(updatedArray, existingArray);
+			ts$1.setTextRange(updatedArray, existingArray);
+			return updatedArray;
+		}
+		return ts$1.factory.createArrayLiteralExpression(elements, true);
+	}
+	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 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);
+			return ts$1.factory.createPropertyAssignment(toPropertyName(key), nextInitializer);
+		});
+		if (existingObject) {
+			const updatedObject = ts$1.factory.createObjectLiteralExpression(properties, true);
+			ts$1.setOriginalNode(updatedObject, existingObject);
+			ts$1.setTextRange(updatedObject, existingObject);
+			return updatedObject;
+		}
+		return ts$1.factory.createObjectLiteralExpression(properties, true);
+	}
+	return ts$1.factory.createIdentifier("undefined");
+}
+function rawCodeToExpression(value) {
+	if (!isRawCodeLike(value)) return null;
+	return ts$1.factory.createIdentifier(value.code);
+}
+function isRawCodeLike(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const raw = value;
+	return raw.constructor?.name === "RawCode" && typeof raw.code === "string";
+}
+function inlineExpressionDirectiveToExpression(value) {
+	if (!isInlineExpressionDirective(value)) return null;
+	return ts$1.factory.createIdentifier(value.expr);
+}
+function isInlineExpressionDirective(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const directive = value;
+	return directive["@type"] === "code" && typeof directive.expr === "string";
+}
+function getPreservedPropertyInitializer(propertyName, nextValue, existingInitializer) {
+	if (propertyName !== "description" || typeof nextValue !== "string" || !existingInitializer) return null;
+	if (ts$1.isStringLiteralLike(existingInitializer)) return existingInitializer.text === nextValue ? existingInitializer : null;
+	return existingInitializer;
+}
+function getPropertyAssignment(objectLiteral, propertyName) {
+	for (const property of objectLiteral.properties) {
+		if (!ts$1.isPropertyAssignment(property)) continue;
+		if (getPropertyNameText$1(property.name) === propertyName) return property;
+	}
+	return null;
+}
+function toPropertyName(name) {
+	return isIdentifierText(name) ? ts$1.factory.createIdentifier(name) : ts$1.factory.createStringLiteral(name);
+}
+function isIdentifierText(value) {
+	return /^[$A-Z_][0-9A-Z_$]*$/i.test(value);
+}
+
+//#endregion
+//#region ../editor-sync/src/internal/statelyMetadata.ts
+const STATELY_METADATA_PREFIX = "@statelyai.";
+function isPlainObject(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stripStatelyMetadata(value) {
+	if (Array.isArray(value)) return value.map((item) => stripStatelyMetadata(item));
+	if (!isPlainObject(value)) return value;
+	const result = {};
+	for (const [key, child] of Object.entries(value)) {
+		if (key.startsWith(STATELY_METADATA_PREFIX)) continue;
+		const nextChild = stripStatelyMetadata(child);
+		if (isPlainObject(nextChild) && Object.keys(nextChild).length === 0 && isPlainObject(child)) continue;
+		result[key] = nextChild;
+	}
+	return result;
+}
+
+//#endregion
+//#region ../editor-sync/src/internal/adapters.ts
+const xstateAdapter = {
+	id: "xstate",
+	format: "xstate",
+	matches(document, text) {
+		return isJavaScriptOrTypeScriptFile(document.fileName) && looksLikeXStateMachine(text);
+	},
+	matchesFallback(document) {
+		return isJavaScriptOrTypeScriptFile(document.fileName);
+	},
+	parseSourceToMachine(text, document, options) {
+		return parseSourceToMachine(text, document, options);
+	},
+	collectSourceLocations(text, document, options) {
+		return collectXStateSourceLocations(text, document, options);
+	},
+	async applyMachineToDocument(machineConfig, document, options) {
+		const rootSourceLocation = collectXStateSourceLocations(document.getText(), document, { machineIndex: options?.machineIndex })?.root ?? options?.sourceLocations?.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 [];
+		return replacements;
+	}
+};
+function containsXStateExpressionPlaceholder(replacement) {
+	return /["']\{\{\s*[^}]+\s*\}\}["']/.test(replacement.newText);
+}
+function isImplicitRootReplacement(replacement, root) {
+	if (!root) return false;
+	if (replacement.uri && replacement.uri !== root.uri) return false;
+	const startsBeforeRoot = replacement.range.startLine < root.range.startLine || replacement.range.startLine === root.range.startLine && replacement.range.startChar <= root.range.startChar;
+	const endsAfterRoot = replacement.range.endLine > root.range.endLine || replacement.range.endLine === root.range.endLine && replacement.range.endChar >= root.range.endChar;
+	return startsBeforeRoot && endsAfterRoot;
+}
+function createSerializedExportAdapter(format, matches) {
+	return {
+		id: format,
+		format,
+		matches,
+		parseSourceToMachine(text) {
+			return text;
+		},
+		async applyMachineToDocument(_machineConfig, document, options) {
+			return createSerializedDocumentReplacement(document, options, format);
+		}
+	};
+}
+async function createSerializedDocumentReplacement(document, options, format) {
+	const serialized = await options?.requestSerialized?.(format);
+	if (typeof serialized !== "string") return [];
+	const fullText = document.getText();
+	const end = document.positionAt(fullText.length);
+	return [{
+		range: {
+			startLine: 0,
+			startChar: 0,
+			endLine: end.line,
+			endChar: end.character
+		},
+		newText: serialized
+	}];
+}
+const xstateJsonAdapter = createSerializedExportAdapter("xstate-json", (document, text) => isJsonFile(document.fileName) && looksLikeXStateJson(text));
+const asyncAdapter = createSerializedExportAdapter("async", (document, text) => isJavaScriptOrTypeScriptFile(document.fileName) && looksLikeAsyncWorkflow(text));
+const xgraphAdapter = createSerializedExportAdapter("xgraph", (document, text) => isJsonFile(document.fileName) && looksLikeXGraphJson(text));
+const mermaidAdapter = createSerializedExportAdapter("mermaid", (document, text) => isMermaidFile(document.fileName) || looksLikeMermaid(text));
+const aslJsonAdapter = createSerializedExportAdapter("asl-json", (document, text) => (hasAslExtension(document.fileName) || looksLikeAmazonStatesLanguage(text)) && !isYamlFile(document.fileName));
+const aslYamlAdapter = createSerializedExportAdapter("asl-yaml", (document, text) => (hasAslExtension(document.fileName) || looksLikeAmazonStatesLanguage(text)) && isYamlFile(document.fileName));
+const adapters = [
+	xstateAdapter,
+	asyncAdapter,
+	createSerializedExportAdapter("redux", (document, text) => isJavaScriptOrTypeScriptFile(document.fileName) && looksLikeReduxToolkit(text)),
+	createSerializedExportAdapter("zustand", (document, text) => isJavaScriptOrTypeScriptFile(document.fileName) && looksLikeZustand(text)),
+	aslYamlAdapter,
+	aslJsonAdapter,
+	mermaidAdapter,
+	xgraphAdapter,
+	xstateJsonAdapter
+];
+function isJavaScriptOrTypeScriptFile(fileName) {
+	return /\.(?:c|m)?(?:jsx?|tsx?)$/i.test(fileName);
+}
+function isYamlFile(fileName) {
+	return /\.(?:asl\.)?ya?ml$/i.test(fileName);
+}
+function hasAslExtension(fileName) {
+	return /\.asl\.(?:jsonc?|ya?ml)$/i.test(fileName);
+}
+function isJsonFile(fileName) {
+	return /\.jsonc?$/i.test(fileName);
+}
+function isMermaidFile(fileName) {
+	return /\.(?:mmd|mermaid)$/i.test(fileName);
+}
+function stripMermaidFrontmatter(text) {
+	return text.replace(/^\s*---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
+}
+function looksLikeMermaid(text) {
+	return /^\s*(?:stateDiagram(?:-v2)?|flowchart(?:\s+(?:TB|TD|BT|LR|RL))?|graph\s+(?:TB|TD|BT|LR|RL))\b/.test(stripMermaidFrontmatter(text));
+}
+function looksLikeAmazonStatesLanguage(text) {
+	return /(^|\s|["'])StartAt["']?\s*:/m.test(text) && /(^|\s|["'])States["']?\s*:/m.test(text);
+}
+function looksLikeXStateJson(text) {
+	try {
+		const value = JSON.parse(text);
+		return Boolean(value && typeof value === "object" && !Array.isArray(value) && "states" in value);
+	} catch {
+		return false;
+	}
+}
+function looksLikeXGraphJson(text) {
+	try {
+		const value = JSON.parse(text);
+		return Boolean(value && typeof value === "object" && !Array.isArray(value) && Array.isArray(value.nodes) && Array.isArray(value.edges));
+	} catch {
+		return false;
+	}
+}
+function looksLikeReduxToolkit(text) {
+	return /\bcreateSlice\s*\(/.test(text) && /@reduxjs\/toolkit/.test(text);
+}
+function looksLikeZustand(text) {
+	return /\bcreate\s*\(\s*\(/.test(text) && /from\s+["']zustand["']/.test(text);
+}
+function looksLikeAsyncWorkflow(text) {
+	return /\bawait\b/.test(text) && (/\basync\s+function\b/.test(text) || /\basync\s*\([^)]*\)\s*=>/.test(text) || /\basync\s+\w+\s*=>/.test(text));
+}
+function looksLikeXStateMachine(text) {
+	return /\b(?:createMachine|createMachineFromConfig)\s*\(/.test(text) || /\bMachine\s*\(/.test(text) || /\.createMachine\s*\(/.test(text);
+}
+function getSyncAdapter(document, text = "") {
+	const resolvedText = text || document.getText?.() || "";
+	const matched = adapters.find((adapter) => adapter.matches(document, resolvedText));
+	if (matched) return matched;
+	const fallback = adapters.find((adapter) => adapter.matchesFallback?.(document, resolvedText));
+	if (fallback) return fallback;
+	throw new Error(`Unsupported document for Stately sync: ${document.fileName}`);
+}
+function parseDocumentToMachine(document, options = {}) {
+	const text = document.getText();
+	const adapter = getSyncAdapter(document, text);
+	return {
+		adapter,
+		format: adapter.format,
+		machine: adapter.parseSourceToMachine(text, document, options),
+		sourceLocations: adapter.collectSourceLocations?.(text, document, options)
+	};
+}
+
+//#endregion
+//#region src/pushMerge.ts
+const GEOMETRY_KEYS = [
+	"x",
+	"y",
+	"width",
+	"height"
+];
+const DEFAULT_NODE_SIZE = {
+	width: 160,
+	height: 64
+};
+const DEFAULT_ANNOTATION_SIZE = {
+	width: 240,
+	height: 120
+};
+const NEW_NODE_GAP = 80;
+const MAX_CONCURRENT_MERGE_ATTEMPTS = 3;
+function indexBySemanticId(normalized, original) {
+	const bySemanticId = /* @__PURE__ */ new Map();
+	normalized.forEach((entity, index) => {
+		const source = original[index];
+		if (source && !bySemanticId.has(entity.id)) bySemanticId.set(entity.id, source);
+	});
+	return bySemanticId;
+}
+function carryGeometry(target, remote) {
+	for (const key of GEOMETRY_KEYS) if (remote[key] !== void 0) target[key] = remote[key];
+}
+function collectDigraphNodes(node, into) {
+	into.set(node.id, node);
+	node.nodes.forEach((child) => collectDigraphNodes(child, into));
+	return into;
+}
+function restoreNodeFields(node, remoteNodesById, remoteNodeIdByLocalId) {
+	const structuralChildren = [...node.nodes];
+	const remoteId = remoteNodeIdByLocalId.get(node.id);
+	const remote = remoteId ? remoteNodesById.get(remoteId) : void 0;
+	if (remote) {
+		if (remote.uniqueId !== void 0) node.uniqueId = remote.uniqueId;
+		if (remote.data.assets !== void 0) node.data.assets = structuredClone(remote.data.assets);
+		if (remote.data.blockFlowDirection !== void 0) node.data.blockFlowDirection = remote.data.blockFlowDirection;
+		if (remote.data.order !== void 0) node.data.order = remote.data.order;
+		const existingIds = new Set(node.nodes.map((child) => child.id));
+		const annotations = remote.nodes.filter((child) => child.data.type === "annotation" && !existingIds.has(child.id));
+		node.nodes.push(...annotations.map((annotation) => structuredClone(annotation)));
+	}
+	structuralChildren.forEach((child) => restoreNodeFields(child, remoteNodesById, remoteNodeIdByLocalId));
+}
+function restoreEdgeFields(edges, remoteEdgesById, remoteEdgeIdByLocalId) {
+	for (const edge of edges) {
+		const remoteId = remoteEdgeIdByLocalId.get(edge.id);
+		const remote = remoteId ? remoteEdgesById.get(remoteId) : void 0;
+		if (remote) {
+			if (remote.uniqueId !== void 0) edge.uniqueId = remote.uniqueId;
+			if (remote.data.assets !== void 0) edge.data.assets = structuredClone(remote.data.assets);
+		}
+	}
+}
+function hasFinitePoint(value) {
+	return Boolean(value && Number.isFinite(value.x) && Number.isFinite(value.y));
+}
+function hasFiniteSize(value) {
+	return Boolean(value && Number.isFinite(value.width) && Number.isFinite(value.height) && value.width > 0 && value.height > 0);
+}
+function ensureCompleteNodeGeometry(rootNode) {
+	if (!hasFinitePoint(rootNode.position)) rootNode.position = {
+		x: 0,
+		y: 0
+	};
+	if (!hasFiniteSize(rootNode.size)) rootNode.size = {
+		width: 320,
+		height: 200
+	};
+	const visit = (parent) => {
+		const parentPosition = parent.position;
+		let nextX = parentPosition.x + 40;
+		for (const child of parent.nodes) if (hasFinitePoint(child.position) && hasFiniteSize(child.size)) nextX = Math.max(nextX, child.position.x + child.size.width + NEW_NODE_GAP);
+		for (const child of parent.nodes) {
+			const childSize = hasFiniteSize(child.size) ? child.size : child.data.type === "annotation" ? { ...DEFAULT_ANNOTATION_SIZE } : { ...DEFAULT_NODE_SIZE };
+			child.size = childSize;
+			if (!hasFinitePoint(child.position)) {
+				child.position = {
+					x: nextX,
+					y: parentPosition.y + 80
+				};
+				nextX += childSize.width + NEW_NODE_GAP;
+			}
+			visit(child);
+		}
+	};
+	visit(rootNode);
+}
+function mergeLocalGraphIntoRemoteDefinition(localGraph, remoteDefinition) {
+	const remoteNodesById = collectDigraphNodes(remoteDefinition.rootNode, /* @__PURE__ */ new Map());
+	const annotationIds = new Set([...remoteNodesById.values()].filter((node) => node.data.type === "annotation").map((node) => node.id));
+	const remoteGraph = fromStudioMachine(remoteDefinition);
+	remoteGraph.nodes = remoteGraph.nodes.filter((node) => !annotationIds.has(node.id));
+	remoteGraph.edges = remoteGraph.edges.filter((edge) => !annotationIds.has(edge.sourceId) && !annotationIds.has(edge.targetId));
+	const { base, compare, summary } = diffGraphsSemantically(remoteGraph, localGraph);
+	const remoteNodesBySemanticId = indexBySemanticId(base.nodes, remoteGraph.nodes);
+	const remoteEdgesBySemanticId = indexBySemanticId(base.edges, remoteGraph.edges);
+	const merged = structuredClone(localGraph);
+	const remoteNodeIdByLocalId = /* @__PURE__ */ new Map();
+	const remoteEdgeIdByLocalId = /* @__PURE__ */ new Map();
+	merged.nodes.forEach((node, index) => {
+		const semanticId = compare.nodes[index]?.id;
+		const remote = semanticId ? remoteNodesBySemanticId.get(semanticId) : void 0;
+		if (!remote) return;
+		remoteNodeIdByLocalId.set(node.id, remote.id);
+		carryGeometry(node, remote);
+		if (node.data.color === void 0 && remote.data?.color !== void 0) node.data.color = remote.data.color;
+	});
+	merged.edges.forEach((edge, index) => {
+		const semanticId = compare.edges[index]?.id;
+		const remote = semanticId ? remoteEdgesBySemanticId.get(semanticId) : void 0;
+		if (!remote) return;
+		remoteEdgeIdByLocalId.set(edge.id, remote.id);
+		carryGeometry(edge, remote);
+		if (edge.data.color === void 0 && remote.data?.color !== void 0) edge.data.color = remote.data.color;
+	});
+	const definition = toStudioMachine(merged);
+	restoreNodeFields(definition.rootNode, remoteNodesById, remoteNodeIdByLocalId);
+	restoreEdgeFields(definition.edges, new Map(remoteDefinition.edges.map((edge) => [edge.id, edge])), remoteEdgeIdByLocalId);
+	ensureCompleteNodeGeometry(definition.rootNode);
+	return {
+		definition: {
+			...remoteDefinition,
+			...definition,
+			context: remoteDefinition.context
+		},
+		summary
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isDigraphNodeConfig(value) {
+	if (!isRecord(value) || typeof value.id !== "string") return false;
+	if (!isRecord(value.data) || typeof value.data.key !== "string") return false;
+	if (!Array.isArray(value.data.entry) || !Array.isArray(value.data.exit) || !Array.isArray(value.data.invoke) || !Array.isArray(value.data.tags) || !Array.isArray(value.nodes)) return false;
+	return value.nodes.every(isDigraphNodeConfig);
+}
+function isDigraphEdgeConfig(value) {
+	return isRecord(value) && typeof value.id === "string" && typeof value.source === "string" && (value.target === void 0 || typeof value.target === "string") && isRecord(value.data) && isRecord(value.data.eventTypeData) && Array.isArray(value.data.actions);
+}
+function isDigraphConfig(value) {
+	if (!isRecord(value) || typeof value.id !== "string" || !isDigraphNodeConfig(value.rootNode) || !Array.isArray(value.edges) || !value.edges.every(isDigraphEdgeConfig)) return false;
+	if (value.implementations !== void 0) {
+		if (!isRecord(value.implementations)) return false;
+		if (!isRecord(value.implementations.actions) || !isRecord(value.implementations.actors) || !isRecord(value.implementations.guards)) return false;
+	}
+	return true;
+}
+function requireDigraphConfig(machineId, value) {
+	if (!isDigraphConfig(value)) throw new Error(`Cannot safely push machine "${machineId}": its remote definition is invalid.`);
+	return value;
+}
+function stableStringify(value) {
+	return JSON.stringify(value, (_key, item) => {
+		if (isRecord(item)) return Object.fromEntries(Object.entries(item).sort(([left], [right]) => left.localeCompare(right)));
+		return item;
+	});
+}
+function definitionsMatch(left, right) {
+	return stableStringify(left) === stableStringify(right);
+}
+async function updateMachineDefinition(client, machineId, localGraph) {
+	if (typeof client.machines?.get !== "function") return client.machines.update({
+		id: machineId,
+		definition: toStudioMachine(localGraph)
+	});
+	let remoteRecord = await client.machines.get(machineId);
+	for (let attempt = 0; attempt < MAX_CONCURRENT_MERGE_ATTEMPTS; attempt += 1) {
+		const remoteDefinition = requireDigraphConfig(machineId, remoteRecord.definition);
+		const mergedDefinition = mergeLocalGraphIntoRemoteDefinition(localGraph, remoteDefinition).definition;
+		const latestRecord = await client.machines.get(machineId);
+		requireDigraphConfig(machineId, latestRecord.definition);
+		if (definitionsMatch(remoteDefinition, latestRecord.definition)) return client.machines.update({
+			id: machineId,
+			definition: mergedDefinition
+		});
+		remoteRecord = latestRecord;
+	}
+	throw new Error(`Cannot safely push machine "${machineId}": its remote definition kept changing during the push. Try again after Studio edits have settled.`);
+}
+
+//#endregion
+//#region src/sync.ts
+const execFileAsync = promisify(execFile);
+const MAX_CAPTURED_LOCAL_MACHINES = 100;
+var PullSourceReconciliationError = class extends Error {
+	code = "source_reconciliation_failed";
+	constructor(message) {
+		super(message);
+		this.name = "PullSourceReconciliationError";
+	}
+};
+const INLINE_EXPRESSION_FIELD_SET = new Set(INLINE_EXPRESSION_DIRECTIVE_FIELDS);
+async function extractMachinesFromLocalSource(sourcePath, contents, machineIndex) {
+	try {
+		return { machines: extractMachineConfigsFromAst(sourcePath, parseSourceToMachine(contents, createTextDocument(sourcePath, contents), {
+			machineIndex,
+			resolver: createFileSourceDocumentResolver()
+		}), machineIndex) };
+	} catch (error) {
+		return {
+			machines: [],
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+function isInvalidLocalMachineDefinitionError(message) {
+	return /No initial state specified for compound state node/.test(message) || /Try adding \{\s*initial:\s*['"`]/.test(message);
+}
+function formatLocalMachineExtractionIssue(message) {
+	if (isInvalidLocalMachineDefinitionError(message)) return `Invalid local machine definition: ${message}`;
+	return `Could not extract a local machine from this file: ${message}`;
+}
+function extractMachineConfigsFromAst(fileName, sourceText, selectedMachineIndex) {
+	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(fileName));
+	const bindings = collectLocalBindings(sourceFile);
+	const machines = [];
+	let currentMachineIndex = 0;
+	const visit = (node) => {
+		if (selectedMachineIndex === void 0 && machines.length >= MAX_CAPTURED_LOCAL_MACHINES) return;
+		if (!ts.isCallExpression(node) || !isCreateMachineExpression(node.expression)) {
+			ts.forEachChild(node, visit);
+			return;
+		}
+		const machineIndex = currentMachineIndex;
+		currentMachineIndex += 1;
+		if (selectedMachineIndex !== void 0 && machineIndex !== selectedMachineIndex) return;
+		const [firstArgument] = node.arguments;
+		if (!firstArgument || !ts.isExpression(firstArgument)) return;
+		const config = evaluateExpression(firstArgument, sourceFile, bindings, /* @__PURE__ */ new Set());
+		if (!config || typeof config !== "object" || Array.isArray(config)) return;
+		machines.push({
+			config,
+			_type: ts.isPropertyAccessExpression(unwrapExpression(node.expression)) ? "setup.createMachine" : "createMachine"
+		});
+	};
+	ts.forEachChild(sourceFile, visit);
+	return machines;
+}
+function countSourceMachines(fileName, sourceText) {
+	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(fileName));
+	let count = 0;
+	const visit = (node) => {
+		if (ts.isCallExpression(node) && isCreateMachineExpression(node.expression)) count += 1;
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return count;
+}
+function collectLocalBindings(sourceFile) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts.isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) {
+				if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+				bindings.set(declaration.name.text, {
+					kind: "value",
+					expression: declaration.initializer
+				});
+			}
+			continue;
+		}
+		if (!ts.isEnumDeclaration(statement)) continue;
+		let nextNumericValue = 0;
+		for (const member of statement.members) {
+			const memberName = getPropertyNameText(member.name);
+			if (!memberName) continue;
+			const symbol = `${statement.name.text}.${memberName}`;
+			if (!member.initializer) {
+				bindings.set(symbol, {
+					kind: "enumMember",
+					value: nextNumericValue
+				});
+				nextNumericValue += 1;
+				continue;
+			}
+			const value = evaluateExpression(member.initializer, sourceFile, bindings, /* @__PURE__ */ new Set());
+			if (typeof value === "string" || typeof value === "number") {
+				bindings.set(symbol, {
+					kind: "enumMember",
+					value
+				});
+				if (typeof value === "number") nextNumericValue = value + 1;
+			}
+		}
+	}
+	return bindings;
+}
+function evaluateExpression(expression, sourceFile, bindings, seenBindings) {
+	const unwrapped = unwrapExpression(expression);
+	if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped)) return unwrapped.text;
+	if (ts.isNumericLiteral(unwrapped)) return Number(unwrapped.text);
+	if (unwrapped.kind === ts.SyntaxKind.TrueKeyword) return true;
+	if (unwrapped.kind === ts.SyntaxKind.FalseKeyword) return false;
+	if (unwrapped.kind === ts.SyntaxKind.NullKeyword) return null;
+	if (ts.isIdentifier(unwrapped)) {
+		if (unwrapped.text === "undefined") return;
+		const binding = bindings.get(unwrapped.text);
+		if (!binding || binding.kind !== "value" || seenBindings.has(unwrapped.text)) return unwrapped.getText(sourceFile);
+		const nextSeen = new Set(seenBindings);
+		nextSeen.add(unwrapped.text);
+		return evaluateExpression(binding.expression, sourceFile, bindings, nextSeen);
+	}
+	if (ts.isPropertyAccessExpression(unwrapped) && ts.isIdentifier(unwrapped.expression)) {
+		const binding = bindings.get(`${unwrapped.expression.text}.${unwrapped.name.text}`);
+		if (binding?.kind === "enumMember") return binding.value;
+		return unwrapped.getText(sourceFile);
+	}
+	if (ts.isArrayLiteralExpression(unwrapped)) return unwrapped.elements.map((element) => ts.isSpreadElement(element) ? evaluateExpression(element.expression, sourceFile, bindings, seenBindings) : evaluateExpression(element, sourceFile, bindings, seenBindings));
+	if (ts.isObjectLiteralExpression(unwrapped)) {
+		const result = {};
+		for (const property of unwrapped.properties) {
+			if (ts.isSpreadAssignment(property)) {
+				const spreadValue = evaluateExpression(property.expression, sourceFile, bindings, seenBindings);
+				if (spreadValue && typeof spreadValue === "object" && !Array.isArray(spreadValue)) Object.assign(result, spreadValue);
+				continue;
+			}
+			if (ts.isShorthandPropertyAssignment(property)) {
+				result[property.name.text] = evaluateExpression(property.name, sourceFile, bindings, seenBindings);
+				continue;
+			}
+			if (!ts.isPropertyAssignment(property)) continue;
+			const key = resolvePropertyNameValue(property.name, sourceFile, bindings, seenBindings);
+			if (key == null) continue;
+			const fieldName = String(key);
+			if (shouldPreserveInlineExpression(fieldName, property.initializer, sourceFile, bindings, seenBindings)) {
+				result[fieldName] = createInlineExpressionDirective(property.initializer.getText(sourceFile));
+				continue;
+			}
+			result[fieldName] = evaluateExpression(property.initializer, sourceFile, bindings, seenBindings);
+		}
+		return result;
+	}
+	if (ts.isPrefixUnaryExpression(unwrapped)) {
+		const operand = evaluateExpression(unwrapped.operand, sourceFile, bindings, seenBindings);
+		if (typeof operand !== "number") return unwrapped.getText(sourceFile);
+		switch (unwrapped.operator) {
+			case ts.SyntaxKind.MinusToken: return -operand;
+			case ts.SyntaxKind.PlusToken: return operand;
+			default: return unwrapped.getText(sourceFile);
+		}
+	}
+	if (ts.isTemplateExpression(unwrapped)) {
+		let value = unwrapped.head.text;
+		for (const span of unwrapped.templateSpans) {
+			const expressionValue = evaluateExpression(span.expression, sourceFile, bindings, seenBindings);
+			value += String(expressionValue ?? "");
+			value += span.literal.text;
+		}
+		return value;
+	}
+	return unwrapped.getText(sourceFile);
+}
+function shouldPreserveInlineExpression(fieldName, expression, sourceFile, bindings, seenBindings) {
+	if (!INLINE_EXPRESSION_FIELD_SET.has(fieldName)) return false;
+	const unwrapped = unwrapExpression(expression);
+	if (ts.isIdentifier(unwrapped)) {
+		const binding = bindings.get(unwrapped.text);
+		if (!binding || binding.kind !== "value" || seenBindings.has(unwrapped.text)) return true;
+		const nextSeen = new Set(seenBindings);
+		nextSeen.add(unwrapped.text);
+		return shouldPreserveInlineExpression(fieldName, binding.expression, sourceFile, bindings, nextSeen);
+	}
+	if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped) || ts.isNumericLiteral(unwrapped) || unwrapped.kind === ts.SyntaxKind.TrueKeyword || unwrapped.kind === ts.SyntaxKind.FalseKeyword || unwrapped.kind === ts.SyntaxKind.NullKeyword || ts.isObjectLiteralExpression(unwrapped) || ts.isArrayLiteralExpression(unwrapped)) return false;
+	return unwrapped.getText(sourceFile).trim().length > 0;
+}
+function createInlineExpressionDirective(expr) {
+	return {
+		"@type": "code",
+		lang: "ts",
+		expr
+	};
+}
+function resolvePropertyNameValue(name, sourceFile, bindings, seenBindings) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+	if (!ts.isComputedPropertyName(name)) return null;
+	const value = evaluateExpression(name.expression, sourceFile, bindings, seenBindings);
+	if (typeof value === "string" || typeof value === "number") return value;
+	return name.getText(sourceFile);
+}
+function isCreateMachineExpression(expression) {
+	const unwrapped = unwrapExpression(expression);
+	return ts.isIdentifier(unwrapped) && unwrapped.text === "createMachine" || ts.isPropertyAccessExpression(unwrapped) && unwrapped.name.text === "createMachine";
+}
+function unwrapExpression(expression) {
+	let current = expression;
+	for (;;) {
+		if (ts.isParenthesizedExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts.isAsExpression(current) || ts.isSatisfiesExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts.isTypeAssertionExpression(current) || ts.isNonNullExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		return current;
+	}
+}
+function getPropertyNameText(name) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+	return null;
+}
+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;
+}
+function isUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+async function fileExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
 }
 function parseGitHubRemote(remoteUrl) {
 	const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
@@ -1357,14 +3940,19 @@ async function pushLocalMachineLinks(options) {
 			continue;
 		}
 		if (attachment.pragma?.id && !options.relink) {
-			const updatedMachine = await client.machines.update({
-				id: attachment.pragma.id,
-				definition: toStudioMachine(fromXStateConfig(extractedMachine.config))
-			});
-			updated.push({
-				machineIndex,
-				machine: updatedMachine
-			});
+			const localGraph = fromXStateConfig(extractedMachine.config);
+			try {
+				const updatedMachine = await updateMachineDefinition(client, attachment.pragma.id, localGraph);
+				updated.push({
+					machineIndex,
+					machine: updatedMachine
+				});
+			} catch (error) {
+				skipped.push({
+					machineIndex,
+					reason: error instanceof Error ? error.message : String(error)
+				});
+			}
 			continue;
 		}
 		const machine = await client.machines.create({
@@ -1394,17 +3982,24 @@ async function pushLocalMachineLinks(options) {
 		...outputPath ? { outputPath } : {}
 	};
 }
-async function resolveLocalFile(locator, options) {
+async function resolveLocalFile(locator, options, machineIndex = 0) {
 	const filePath = path.resolve(options.cwd ?? process.cwd(), locator);
 	const contents = await fs.readFile(filePath, "utf8");
 	const extension = path.extname(filePath).toLowerCase();
 	if (extension === ".ts" || extension === ".tsx" || extension === ".js" || extension === ".jsx") {
-		const config = (await (options.client ?? createStatelyClient({
-			apiKey: options.apiKey,
-			baseUrl: options.baseUrl,
-			fetch: options.fetch
-		})).code.extractMachines(contents)).machines[0]?.config;
-		if (!config) throw new Error(`No machines extracted from ${filePath}`);
+		const localExtraction = await extractMachinesFromLocalSource(filePath, contents, machineIndex);
+		let config = localExtraction.machines[0]?.config;
+		const extractionIssue = localExtraction.error;
+		if (!config) {
+			const extracted = await (options.client ?? createStatelyClient({
+				apiKey: options.apiKey,
+				baseUrl: options.baseUrl,
+				fetch: options.fetch
+			})).code.extractMachines(contents);
+			const indexedMachine = extracted.machines.find((machine) => machine.machineIndex === machineIndex);
+			config = extracted.machines.some((machine) => machine.machineIndex !== void 0) ? indexedMachine?.config : extracted.machines[machineIndex]?.config;
+		}
+		if (!config) throw new Error(extractionIssue ? `No machines extracted from ${filePath}: ${formatLocalMachineExtractionIssue(extractionIssue)}` : `No machine at index ${machineIndex} was extracted from ${filePath}`);
 		return {
 			kind: "local-file",
 			locator: filePath,
@@ -1503,7 +4098,7 @@ function summarizeDiff(diff) {
 async function planSync(options) {
 	const source = await resolveSyncInput(options.source, options);
 	const target = await resolveSyncInput(options.target, options);
-	const diff = getDiff(source.graph, target.graph);
+	const { diff } = diffGraphsSemantically(source.graph, target.graph);
 	return {
 		source,
 		target,
@@ -1517,17 +4112,83 @@ async function pullSync(options) {
 	const outputPath = path.resolve(options.cwd ?? process.cwd(), options.target);
 	const fallbackFormat = inferWritableTargetFormat(outputPath);
 	let targetFormat = fallbackFormat;
-	if (await fileExists(outputPath)) try {
-		targetFormat = (await resolveLocalFile(options.target, options)).format;
+	let existingTarget = null;
+	const targetExists = await fileExists(outputPath);
+	let machineIndex = options.machineIndex ?? 0;
+	if (targetExists && options.machineIndex === void 0 && source.remoteMachineId) {
+		const matchingIndex = findStatelyPragmaAttachments(await fs.readFile(outputPath, "utf8"), outputPath).findIndex((attachment) => attachment.pragma?.id === source.remoteMachineId);
+		if (matchingIndex >= 0) machineIndex = matchingIndex;
+	}
+	if (targetExists) try {
+		const target = await resolveLocalFile(options.target, options, machineIndex);
+		existingTarget = target;
+		targetFormat = target.format;
 	} catch (error) {
 		if (!fallbackFormat) throw error;
+		const contents = await fs.readFile(outputPath, "utf8");
+		if (fallbackFormat === "xstate" && contents.trim() !== "" && !options.force) throw new PullSourceReconciliationError(`Could not update ${outputPath} surgically: ${error instanceof Error ? error.message : String(error)} Pass --force to replace the file.`);
 	}
 	if (!targetFormat) throw new Error(`Could not infer a writable target format from ${outputPath}. Use an existing digraph/graph file or a .digraph.json/.graph.json target.`);
-	const serialized = serializeGraph(source.graph, targetFormat, {
-		remoteMachineId: source.remoteMachineId,
-		targetPath: outputPath
-	});
-	await fs.writeFile(outputPath, serialized, "utf8");
+	let wroteSurgically = false;
+	if (targetFormat === "xstate" && existingTarget?.format === "xstate") {
+		const currentSource = await fs.readFile(outputPath, "utf8");
+		const document = createTextDocument(outputPath, currentSource);
+		let parsedTarget = null;
+		try {
+			parsedTarget = parseDocumentToMachine(document, {
+				machineIndex,
+				resolver: createFileSourceDocumentResolver()
+			});
+		} catch (error) {
+			if (!options.force) throw new PullSourceReconciliationError(`Could not update ${outputPath} surgically: ${error instanceof Error ? error.message : String(error)} The source file was left unchanged. Pass --force to replace the file.`);
+		}
+		if (parsedTarget) {
+			const semanticResult = diffGraphsSemantically(existingTarget.graph, source.graph);
+			const alignedSource = alignCompareGraphIds(existingTarget.graph, source.graph, semanticResult.base, semanticResult.compare);
+			const patchResult = graphChangeToPatchesResult(existingTarget.graph, alignedSource);
+			const patches = patchResult.patches;
+			if (patchResult.unsupportedChanges.length > 0) {
+				if (!options.force) throw new PullSourceReconciliationError(`Could not update ${outputPath} surgically: ${patchResult.unsupportedChanges.join(" ")} The source file was left unchanged. Pass --force to replace the file.`);
+			} else if (patches.length > 0) {
+				const replacements = applyMachineToSource(graphToMachineConfig(alignedSource), document, {
+					patches,
+					prevGraph: existingTarget.graph,
+					nextGraph: alignedSource,
+					sourceLocations: parsedTarget.sourceLocations,
+					machineIndex
+				});
+				if (replacements.length === 0) {
+					if (!options.force) throw new PullSourceReconciliationError(`Could not write remote changes to ${outputPath}: source reconciliation produced no replacements. The source file was left unchanged. Pass --force to replace the file.`);
+				} else {
+					let updatedSource = applyReplacementsToText(currentSource, replacements);
+					if (source.remoteMachineId) updatedSource = upsertStatelyPragma(updatedSource, source.remoteMachineId, {
+						fileName: outputPath,
+						machineIndex
+					});
+					await fs.writeFile(outputPath, updatedSource, "utf8");
+					wroteSurgically = true;
+				}
+			} else {
+				const updatedSource = source.remoteMachineId ? upsertStatelyPragma(currentSource, source.remoteMachineId, {
+					fileName: outputPath,
+					machineIndex
+				}) : currentSource;
+				if (updatedSource !== currentSource) await fs.writeFile(outputPath, updatedSource, "utf8");
+				wroteSurgically = true;
+			}
+		}
+	}
+	if (!wroteSurgically) {
+		if (targetFormat === "xstate" && targetExists) {
+			const machineCount = countSourceMachines(outputPath, await fs.readFile(outputPath, "utf8"));
+			if (machineCount > 1) throw new PullSourceReconciliationError(`Could not update ${outputPath} surgically, and full regeneration would remove the other ${machineCount - 1} machine(s) in this file. The source file was left unchanged.`);
+		}
+		const serialized = serializeGraph(source.graph, targetFormat, {
+			remoteMachineId: source.remoteMachineId,
+			targetPath: outputPath
+		});
+		await fs.writeFile(outputPath, serialized, "utf8");
+	}
 	return {
 		source,
 		target: {
@@ -1578,10 +4239,7 @@ async function pushSync(options) {
 	const project = await resolvePushProject(client, sourcePath, options);
 	const existingMachineId = source.format === "xstate" ? getStatelyPragma(await fs.readFile(sourcePath, "utf8"), sourcePath)?.id : void 0;
 	let machine;
-	if (existingMachineId) machine = await client.machines.update({
-		id: existingMachineId,
-		definition: toStudioMachine(source.graph)
-	});
+	if (existingMachineId) machine = await updateMachineDefinition(client, existingMachineId, source.graph);
 	else {
 		if (!project.projectVersionId) throw new Error("Resolved project is missing projectVersionId.");
 		machine = await client.machines.create({
@@ -1608,4 +4266,4 @@ async function pushSync(options) {
 }
 
 //#endregion
-export { planSync, pullSync, pushLocalMachineLinks, pushSync };
+export { PullSourceReconciliationError, planSync, pullSync, pushLocalMachineLinks, pushSync };