@statelyai/sdk 0.34.2 → 0.36.0

package/dist/sync.mjs

@@ -1,4646 +0,0 @@
-import "./openapi-BTDjYWXd.mjs";
-import { r as createStatelyClient } from "./studio-BZP6DaIO.mjs";
-import { C as toXStateV6MachineConfig, S as serializeJS, a as alignCompareGraphIds, b as normalizeMachineProfile, c as diffGraphsSemantically, d as getDelayKeyFromEventType, g as graphToXStateTS, i as XSTATE_V6_FN_TRANSITION_META, m as graphToMachineConfig, p as graphChangeToPatchesResult, r as XSTATE_V6_BRANCH_DESCRIPTION_META, s as detectXStateSourceProfile, t as INLINE_EXPRESSION_DIRECTIVE_FIELDS, u as extractXStateMachineConfigEntries, v as isCodeExpression } from "./dist-DsOTTfYv.mjs";
-import { n as getStatelyPragma, r as upsertStatelyPragma, t as findStatelyPragmaAttachments } from "./statelyPragma-YtVaBuIe.mjs";
-import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
-import * as ts$1 from "typescript";
-import ts from "typescript";
-import { isEmptyDiff } from "@statelyai/graph";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import * as fs$1 from "fs";
-import * as path$1 from "path";
-import { fileURLToPath, pathToFileURL } from "url";
-
-//#region ../editor-sync/src/fs.ts
-function createTextDocument(fileName, text, uri = path$1.isAbsolute(fileName) ? pathToFileURL(fileName).toString() : fileName) {
-	const lineStarts = getLineStarts(text);
-	return {
-		fileName,
-		uri,
-		getText() {
-			return text;
-		},
-		positionAt(offset) {
-			const clampedOffset = Math.max(0, Math.min(offset, text.length));
-			let low = 0;
-			let high = lineStarts.length - 1;
-			while (low <= high) {
-				const mid = Math.floor((low + high) / 2);
-				const start = lineStarts[mid];
-				const nextStart = mid + 1 < lineStarts.length ? lineStarts[mid + 1] : text.length + 1;
-				if (clampedOffset < start) {
-					high = mid - 1;
-					continue;
-				}
-				if (clampedOffset >= nextStart) {
-					low = mid + 1;
-					continue;
-				}
-				return {
-					line: mid,
-					character: clampedOffset - start
-				};
-			}
-			return {
-				line: lineStarts.length - 1,
-				character: clampedOffset - lineStarts[lineStarts.length - 1]
-			};
-		}
-	};
-}
-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}`);
-	return path$1.resolve(uriOrPath);
-}
-function fileNameToUri(fileName) {
-	return pathToFileURL(path$1.resolve(fileName)).toString();
-}
-function createFileSourceDocumentResolver() {
-	return {
-		read(uri) {
-			return readFileSnapshot(sourceUriToFileName(uri));
-		},
-		resolveImport(fromDocument, specifier) {
-			const importedFileName = resolveImportPath(fromDocument.fileName, specifier);
-			return importedFileName ? readFileSnapshot(importedFileName) : null;
-		},
-		resolvePackageJson(fromDocument, packageName) {
-			let directory = path$1.dirname(path$1.resolve(fromDocument.fileName));
-			while (true) {
-				const packageJson = readFileSnapshot(path$1.join(directory, "package.json"));
-				if (packageJson && packageJsonDeclares(packageJson.text, packageName)) return packageJson;
-				const parent = path$1.dirname(directory);
-				if (parent === directory) return null;
-				directory = parent;
-			}
-		}
-	};
-}
-function packageJsonDeclares(text, packageName) {
-	try {
-		const manifest = JSON.parse(text);
-		return [
-			"dependencies",
-			"devDependencies",
-			"peerDependencies",
-			"optionalDependencies"
-		].some((field) => {
-			const dependencies = manifest[field];
-			return Boolean(dependencies && typeof dependencies === "object" && Object.prototype.hasOwnProperty.call(dependencies, packageName));
-		});
-	} catch {
-		return false;
-	}
-}
-function resolveImportPath(fromFileName, specifier) {
-	if (!specifier.startsWith(".")) return null;
-	const basePath = path$1.resolve(path$1.dirname(fromFileName), specifier);
-	return [
-		basePath,
-		`${basePath}.ts`,
-		`${basePath}.tsx`,
-		`${basePath}.js`,
-		`${basePath}.jsx`,
-		path$1.join(basePath, "index.ts"),
-		path$1.join(basePath, "index.tsx"),
-		path$1.join(basePath, "index.js"),
-		path$1.join(basePath, "index.jsx")
-	].find((candidate) => isReadableFile(candidate)) ?? null;
-}
-function isReadableFile(fileName) {
-	try {
-		return fs$1.statSync(fileName).isFile();
-	} catch {
-		return false;
-	}
-}
-function readFileSnapshot(fileName) {
-	try {
-		return {
-			fileName,
-			uri: fileNameToUri(fileName),
-			text: fs$1.readFileSync(fileName, "utf8")
-		};
-	} catch {
-		return null;
-	}
-}
-function getLineStarts(text) {
-	const lineStarts = [0];
-	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$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$1(sourceFile, bindings, options.machineIndex);
-	if (!root) return;
-	const states = [];
-	const statesObjectLocations = [];
-	collectStateLocations(root, [], states, statesObjectLocations, bindings, staticValues, root);
-	const packageProfile = detectXStatePackageProfile(options.resolver?.resolvePackageJson?.({
-		fileName: document.fileName,
-		uri
-	}, "xstate"));
-	const rootProfile = detectXStateSourceProfile(sourceText);
-	const referencedStateSymbols = new Set([...states, ...statesObjectLocations].map((state) => state.symbol).filter((symbol) => typeof symbol === "string"));
-	const resolvedTransitionFunctions = collectResolvedTransitionFunctions(root, bindings);
-	const inferredProfile = rootProfile === "xstate-v6-alpha" || resolvedTransitionFunctions.size > 0 || [...referencedStateSymbols].some((symbol) => {
-		const binding = bindings.get(symbol);
-		return binding?.kind === "createStateConfig" || detectXStateSourceProfile(binding?.sourceFile.text ?? "") === "xstate-v6-alpha";
-	}) ? "xstate-v6-alpha" : rootProfile;
-	return {
-		version: 1,
-		profile: packageProfile?.profile ?? inferredProfile,
-		profileRef: packageProfile?.profileRef ?? normalizeMachineProfile(inferredProfile),
-		root: {
-			uri,
-			range: toSourceRange$1(sourceFile, root)
-		},
-		statesObject: statesObjectLocations[0],
-		states,
-		staticValues: collectStaticValueReferences(sourceFile, uri, root, staticValues),
-		transitionFunctions: [...resolvedTransitionFunctions].flatMap(([symbol, resolved]) => resolved.binding.uri === uri ? [] : [{
-			symbol,
-			uri: resolved.binding.uri,
-			range: toSourceRange$1(resolved.binding.sourceFile, resolved.binding.node),
-			sourcePaths: resolved.sourcePaths
-		}])
-	};
-}
-function detectXStatePackageProfile(packageJson) {
-	if (!packageJson) return void 0;
-	let manifest;
-	try {
-		manifest = JSON.parse(packageJson.text);
-	} catch {
-		return;
-	}
-	const dependencyFields = [
-		"dependencies",
-		"devDependencies",
-		"peerDependencies",
-		"optionalDependencies"
-	];
-	let range;
-	for (const field of dependencyFields) {
-		const dependencies = manifest[field];
-		if (!dependencies || typeof dependencies !== "object") continue;
-		const value = dependencies.xstate;
-		if (typeof value === "string") {
-			range = value;
-			break;
-		}
-	}
-	if (!range) return void 0;
-	const normalizedRange = range.replace(/^(?:workspace:|npm:xstate@)/, "");
-	const clauseProfiles = normalizedRange.split("||").map((clause) => detectXStateRangeClauseProfile(clause.trim()));
-	const profiles = new Set(clauseProfiles);
-	if (profiles.size !== 1 || profiles.has(void 0)) return void 0;
-	const profile = clauseProfiles[0];
-	if (!profile) return void 0;
-	return {
-		profile,
-		profileRef: /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(normalizedRange) ? `@statelyai/xstate@${normalizedRange}` : normalizeMachineProfile(profile)
-	};
-}
-function detectXStateRangeClauseProfile(clause) {
-	const normalizedClause = clause.replace(/([<>]=?)\s+/g, "$1");
-	let lowerRequiresV6 = false;
-	let upperRequiresV5 = false;
-	let directProfile;
-	for (const match of normalizedClause.matchAll(/(?:^|\s)([<>]=?|[~^])?v?(\d+)(?:\.(\d+|x|\*))?(?:\.(\d+|x|\*))?(?:-[0-9A-Za-z.-]+)?(?=\s|$)/g)) {
-		const operator = match[1] ?? "";
-		const major = Number(match[2]);
-		const minor = parseRangePart(match[3]);
-		const patch = parseRangePart(match[4]);
-		if (operator === ">" || operator === ">=") {
-			if (major >= 6) lowerRequiresV6 = true;
-			continue;
-		}
-		if (operator === "<") {
-			if (major < 6 || major === 6 && (minor ?? 0) === 0 && (patch ?? 0) === 0) upperRequiresV5 = true;
-			continue;
-		}
-		if (operator === "<=") {
-			if (major < 6) upperRequiresV5 = true;
-			continue;
-		}
-		const profile = major >= 6 ? "xstate-v6-alpha" : "xstate-v5";
-		if (directProfile && directProfile !== profile) return void 0;
-		directProfile = profile;
-	}
-	if (lowerRequiresV6 && upperRequiresV5) return void 0;
-	if (lowerRequiresV6) return "xstate-v6-alpha";
-	if (upperRequiresV5) return "xstate-v5";
-	return directProfile;
-}
-function parseRangePart(value) {
-	return value && /^\d+$/.test(value) ? Number(value) : void 0;
-}
-function collectImportedXStateTransitionSources(sourceText, document, options = {}) {
-	if (!options.resolver) return [];
-	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$1(sourceFile, bindings, options.machineIndex);
-	if (!root) return [];
-	return [...collectResolvedTransitionFunctions(root, bindings)].flatMap(([localName, resolved]) => {
-		const { binding } = resolved;
-		if (binding.uri === uri) return [];
-		if (ts$1.isFunctionDeclaration(binding.node)) {
-			const name = binding.node.name;
-			if (!name) return [];
-			const suffix = binding.node.getText(binding.sourceFile).slice(name.getEnd() - binding.node.getStart(binding.sourceFile));
-			return [`${binding.node.modifiers?.some((modifier) => modifier.kind === ts$1.SyntaxKind.AsyncKeyword) ? "async " : ""}function ${localName}${suffix}`];
-		}
-		return [`const ${localName} = ${binding.node.getText(binding.sourceFile)};`];
-	});
-}
-function collectStaticValueBindings(sourceFile) {
-	const bindings = /* @__PURE__ */ new Map();
-	for (const statement of sourceFile.statements) {
-		if (ts$1.isVariableStatement(statement)) {
-			if (!((statement.declarationList.flags & ts$1.NodeFlags.Const) === ts$1.NodeFlags.Const)) continue;
-			for (const declaration of statement.declarationList.declarations) {
-				if (!ts$1.isIdentifier(declaration.name) || !declaration.initializer) continue;
-				const value = getStaticStringValue(declaration.initializer);
-				if (value === null) continue;
-				bindings.set(declaration.name.text, {
-					kind: "const",
-					symbol: declaration.name.text,
-					value,
-					valueRange: toSourceRange$1(sourceFile, declaration.initializer)
-				});
-			}
-			continue;
-		}
-		if (ts$1.isEnumDeclaration(statement)) for (const member of statement.members) {
-			const memberName = getEnumMemberName(member.name);
-			if (!memberName || !member.initializer) continue;
-			const value = getStaticStringValue(member.initializer);
-			if (value === null) continue;
-			const symbol = `${statement.name.text}.${memberName}`;
-			bindings.set(symbol, {
-				kind: "enumMember",
-				symbol,
-				value,
-				valueRange: toSourceRange$1(sourceFile, member.initializer)
-			});
-		}
-	}
-	return bindings;
-}
-function collectBindings(sourceFile, uri, fileName, options, cache = /* @__PURE__ */ new Map()) {
-	const cached = cache.get(fileName);
-	if (cached) return cached;
-	const bindings = collectTopLevelBindings(sourceFile, uri);
-	cache.set(fileName, bindings);
-	addImportedBindings(bindings, sourceFile, uri, fileName, options, cache);
-	return bindings;
-}
-function collectTopLevelBindings(sourceFile, uri) {
-	const bindings = /* @__PURE__ */ new Map();
-	for (const statement of sourceFile.statements) {
-		if (ts$1.isFunctionDeclaration(statement) && statement.name) {
-			bindings.set(statement.name.text, {
-				kind: "transitionFunction",
-				node: statement,
-				sourceFile,
-				uri,
-				bindings
-			});
-			continue;
-		}
-		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$2(declaration.initializer);
-			if (ts$1.isArrowFunction(initializer) || ts$1.isFunctionExpression(initializer)) {
-				bindings.set(declaration.name.text, {
-					kind: "transitionFunction",
-					node: initializer,
-					sourceFile,
-					uri,
-					bindings
-				});
-				continue;
-			}
-			const objectLiteral = unwrapObjectLiteralExpression$1(declaration.initializer);
-			if (objectLiteral) {
-				bindings.set(declaration.name.text, {
-					kind: "objectReference",
-					node: objectLiteral,
-					sourceFile,
-					uri,
-					bindings
-				});
-				continue;
-			}
-			const stateConfig = unwrapCreateConfigArgument(declaration.initializer);
-			if (stateConfig) bindings.set(declaration.name.text, {
-				kind: "createStateConfig",
-				node: stateConfig,
-				sourceFile,
-				uri,
-				bindings
-			});
-		}
-	}
-	return bindings;
-}
-function addImportedBindings(bindings, sourceFile, uri, fileName, options, cache) {
-	const resolver = options.resolver;
-	if (!resolver) return;
-	for (const statement of sourceFile.statements) {
-		if (!ts$1.isImportDeclaration(statement) || !ts$1.isStringLiteral(statement.moduleSpecifier)) continue;
-		const namedBindings = statement.importClause?.namedBindings;
-		if (!namedBindings || !ts$1.isNamedImports(namedBindings)) continue;
-		const importedDocument = resolver.resolveImport({
-			fileName,
-			uri
-		}, statement.moduleSpecifier.text);
-		if (!importedDocument) continue;
-		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) {
-			const importedName = element.propertyName?.text ?? element.name.text;
-			const binding = importedBindings.get(importedName);
-			if (binding) bindings.set(element.name.text, binding);
-		}
-	}
-}
-function collectResolvedTransitionFunctions(root, bindings) {
-	const found = /* @__PURE__ */ new Map();
-	const visitExpression = (expression, sourcePath) => {
-		const current = unwrapExpression$2(expression);
-		if (ts$1.isIdentifier(current)) {
-			const binding = bindings.get(current.text);
-			if (binding?.kind === "transitionFunction") {
-				const resolved = found.get(current.text) ?? {
-					binding,
-					sourcePaths: []
-				};
-				if (!resolved.sourcePaths.some((existing) => existing.length === sourcePath.length && existing.every((segment, index) => segment === sourcePath[index]))) resolved.sourcePaths.push(sourcePath);
-				found.set(current.text, resolved);
-			}
-			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 = (state, sourcePath) => {
-		for (const propertyName of [
-			"on",
-			"after",
-			"always",
-			"onDone",
-			"onError",
-			"onSnapshot",
-			"onTimeout"
-		]) {
-			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$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$1(property.initializer);
-			const key = getPropertyNameText$2(property.name);
-			if (child && key) visitState(child, [...sourcePath, key]);
-		}
-	};
-	visitState(root, []);
-	return found;
-}
-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$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$1(firstArgument) ?? resolveIdentifierObject(firstArgument, bindings);
-			return;
-		}
-		ts$1.forEachChild(node, visit);
-	};
-	visit(sourceFile);
-	return found;
-}
-function collectStateLocations(stateObject, parentPath, locations, statesObjectLocations, bindings, staticValues, root) {
-	const statesObject = resolveObjectLiteralProperty(stateObject, "states", bindings);
-	if (!statesObject) return;
-	statesObjectLocations.push({
-		uri: statesObject.uri,
-		path: parentPath,
-		kind: statesObject.kind,
-		symbol: statesObject.symbol,
-		keyRange: statesObject.keyRange,
-		referenceRange: statesObject.referenceRange,
-		range: toSourceRange$1(statesObject.sourceFile, statesObject.object)
-	});
-	for (const property of statesObject.object.properties) {
-		const resolved = resolveStateProperty(property, statesObject.bindings, staticValues, root);
-		if (!resolved) continue;
-		const path = [...parentPath, resolved.key];
-		locations.push({
-			uri: resolved.uri,
-			path,
-			kind: resolved.kind,
-			symbol: resolved.symbol,
-			keyRange: resolved.keyRange,
-			referenceRange: resolved.referenceRange,
-			keySource: resolved.keySource,
-			keyReplacementText: resolved.keyReplacementText,
-			range: toSourceRange$1(resolved.sourceFile, resolved.stateObject)
-		});
-		collectStateLocations(resolved.stateObject, path, locations, statesObjectLocations, resolved.bindings, staticValues, root);
-	}
-}
-function resolveStateProperty(property, bindings, staticValues, root) {
-	if (ts$1.isShorthandPropertyAssignment(property)) {
-		const binding = bindings.get(property.name.text);
-		if (!binding || binding.kind === "transitionFunction") return null;
-		return {
-			key: property.name.text,
-			kind: binding.kind,
-			symbol: property.name.text,
-			keyRange: toSourceRange$1(property.getSourceFile(), property.name),
-			referenceRange: toSourceRange$1(property.getSourceFile(), property.name),
-			stateObject: binding.node,
-			sourceFile: binding.sourceFile,
-			uri: binding.uri,
-			bindings: binding.bindings
-		};
-	}
-	if (!ts$1.isPropertyAssignment(property)) return null;
-	const resolvedKey = resolvePropertyKey(property.name, staticValues, root);
-	if (!resolvedKey) return null;
-	const inlineObject = unwrapObjectLiteralExpression$1(property.initializer);
-	if (inlineObject) return {
-		key: resolvedKey.key,
-		kind: "inline",
-		keyRange: toSourceRange$1(property.getSourceFile(), property.name),
-		keySource: resolvedKey.keySource,
-		keyReplacementText: resolvedKey.keyReplacementText,
-		stateObject: inlineObject,
-		sourceFile: property.getSourceFile(),
-		uri: getSourceFileUri(property.getSourceFile()),
-		bindings
-	};
-	if (ts$1.isIdentifier(property.initializer)) {
-		const binding = bindings.get(property.initializer.text);
-		if (!binding || binding.kind === "transitionFunction") return null;
-		return {
-			key: resolvedKey.key,
-			kind: binding.kind,
-			symbol: property.initializer.text,
-			keyRange: toSourceRange$1(property.getSourceFile(), property.name),
-			referenceRange: toSourceRange$1(property.getSourceFile(), property.initializer),
-			keySource: resolvedKey.keySource,
-			keyReplacementText: resolvedKey.keyReplacementText,
-			stateObject: binding.node,
-			sourceFile: binding.sourceFile,
-			uri: binding.uri,
-			bindings: binding.bindings
-		};
-	}
-	return null;
-}
-function getSourceFileUri(sourceFile) {
-	return sourceFileUris.get(sourceFile) ?? sourceFile.fileName;
-}
-function unwrapCreateConfigArgument(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$1(firstArgument);
-}
-function isSetupCreateConfigName(name) {
-	return /^create[A-Z_$][\w$]*Config$/.test(name);
-}
-function resolveIdentifierObject(expression, bindings) {
-	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;
-}
-function resolveObjectLiteralProperty(objectLiteral, propertyName, bindings) {
-	for (const property of objectLiteral.properties) {
-		if (!ts$1.isPropertyAssignment(property) && !ts$1.isShorthandPropertyAssignment(property)) continue;
-		if (getPropertyNameText$2(property.name) !== propertyName) continue;
-		const initializer = ts$1.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
-		const inlineObject = unwrapObjectLiteralExpression$1(initializer);
-		if (inlineObject) return {
-			object: inlineObject,
-			kind: "inline",
-			keyRange: toSourceRange$1(property.getSourceFile(), property.name),
-			sourceFile: property.getSourceFile(),
-			uri: getSourceFileUri(property.getSourceFile()),
-			bindings
-		};
-		if (ts$1.isIdentifier(initializer)) {
-			const binding = bindings.get(initializer.text);
-			if (binding?.kind !== "objectReference") return null;
-			return {
-				object: binding.node,
-				kind: binding.kind,
-				symbol: initializer.text,
-				keyRange: toSourceRange$1(property.getSourceFile(), property.name),
-				referenceRange: toSourceRange$1(property.getSourceFile(), initializer),
-				sourceFile: binding.sourceFile,
-				uri: binding.uri,
-				bindings: binding.bindings
-			};
-		}
-		return null;
-	}
-	return null;
-}
-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;
-		if (ts$1.isStringLiteral(expression) || ts$1.isNoSubstitutionTemplateLiteral(expression) || ts$1.isNumericLiteral(expression)) return expression.text;
-	}
-	return null;
-}
-function resolvePropertyKey(name, staticValues, root) {
-	const literalKey = getPropertyNameText$2(name);
-	if (literalKey !== null) {
-		if (ts$1.isComputedPropertyName(name)) return {
-			key: literalKey,
-			keySource: { kind: "computedLiteral" },
-			keyReplacementText: JSON.stringify(literalKey)
-		};
-		return { key: literalKey };
-	}
-	if (!ts$1.isComputedPropertyName(name)) return null;
-	const binding = getStaticValueBindingForExpression(name.expression, staticValues);
-	if (!binding) return null;
-	return {
-		key: binding.value,
-		keySource: {
-			kind: binding.kind,
-			symbol: binding.symbol,
-			valueRange: binding.valueRange,
-			machineLocal: isStaticValueMachineLocal(name.getSourceFile(), binding, root)
-		},
-		keyReplacementText: JSON.stringify(binding.value)
-	};
-}
-function getStaticValueBindingForExpression(expression, staticValues) {
-	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;
-}
-function collectStaticValueReferences(sourceFile, uri, root, staticValues) {
-	const references = [];
-	if (staticValues.size === 0) return references;
-	const rootStart = root.getStart(sourceFile);
-	const rootEnd = root.getEnd();
-	const visit = (node) => {
-		if (ts$1.isComputedPropertyName(node)) {
-			const binding = getStaticValueBindingForExpression(node.expression, staticValues);
-			if (binding && !isStateKeyComputedPropertyName(node)) references.push({
-				uri,
-				range: toSourceRange$1(sourceFile, node),
-				value: binding.value
-			});
-			return;
-		}
-		if (!(node.getStart(sourceFile) >= rootStart && node.getEnd() <= rootEnd)) {
-			ts$1.forEachChild(node, visit);
-			return;
-		}
-		const binding = getStaticValueReferenceBinding(node, staticValues);
-		if (binding) {
-			references.push({
-				uri,
-				range: toSourceRange$1(sourceFile, node),
-				value: binding.value
-			});
-			return;
-		}
-		ts$1.forEachChild(node, visit);
-	};
-	visit(root);
-	return references;
-}
-function getStaticValueReferenceBinding(node, staticValues) {
-	if (ts$1.isIdentifier(node)) {
-		if (ts$1.isVariableDeclaration(node.parent) && node.parent.name === node) return null;
-		if (ts$1.isPropertyAssignment(node.parent) && node.parent.name === node) return null;
-		if (ts$1.isPropertyAccessExpression(node.parent)) return null;
-		return staticValues.get(node.text) ?? null;
-	}
-	if (ts$1.isPropertyAccessExpression(node) && ts$1.isIdentifier(node.expression)) {
-		if (ts$1.isComputedPropertyName(node.parent) && ts$1.isEnumMember(node.parent.parent)) return null;
-		return staticValues.get(`${node.expression.text}.${node.name.text}`) ?? null;
-	}
-	return null;
-}
-function isStaticValueMachineLocal(sourceFile, binding, root) {
-	const rootStart = root.getStart(sourceFile);
-	const rootEnd = root.getEnd();
-	let referenceCount = 0;
-	let hasOutsideReference = false;
-	const visit = (node) => {
-		if (getStaticValueReferenceBinding(node, new Map([[binding.symbol, binding]]))) {
-			referenceCount += 1;
-			if (node.getStart(sourceFile) < rootStart || node.getEnd() > rootEnd) hasOutsideReference = true;
-			return;
-		}
-		ts$1.forEachChild(node, visit);
-	};
-	visit(sourceFile);
-	return referenceCount > 0 && !hasOutsideReference;
-}
-function isStateKeyComputedPropertyName(name) {
-	const property = name.parent;
-	if (!ts$1.isPropertyAssignment(property)) return false;
-	const objectLiteral = property.parent;
-	if (!ts$1.isObjectLiteralExpression(objectLiteral)) return false;
-	const parentProperty = objectLiteral.parent;
-	if (!ts$1.isPropertyAssignment(parentProperty)) return false;
-	return getPropertyNameText$2(parentProperty.name) === "states";
-}
-function getStaticStringValue(expression) {
-	const unwrapped = unwrapExpression$2(expression);
-	if (ts$1.isStringLiteral(unwrapped) || ts$1.isNoSubstitutionTemplateLiteral(unwrapped) || ts$1.isNumericLiteral(unwrapped)) return unwrapped.text;
-	return null;
-}
-function getEnumMemberName(name) {
-	if (ts$1.isIdentifier(name) || ts$1.isStringLiteral(name) || ts$1.isNumericLiteral(name)) return name.text;
-	return null;
-}
-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$1(expression) {
-	const unwrapped = unwrapExpression$2(expression);
-	return ts$1.isObjectLiteralExpression(unwrapped) ? unwrapped : null;
-}
-function unwrapExpression$2(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) || ts$1.isNonNullExpression(current)) {
-			current = current.expression;
-			continue;
-		}
-		return current;
-	}
-}
-function toSourceRange$1(sourceFile, node) {
-	const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-	const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-	return {
-		startLine: start.line,
-		startChar: start.character,
-		endLine: end.line,
-		endChar: end.character
-	};
-}
-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;
-	return ts$1.ScriptKind.TS;
-}
-
-//#endregion
-//#region ../editor-sync/src/internal/codeToGraph.ts
-/**
-* Returns source text for the embed to parse.
-*
-* The returned text is still a temporary parse payload, not the source we write
-* back to. Directly imported modular states are hydrated into the root
-* `states` object so Viz can see their transition bodies even though it only
-* receives one string.
-*/
-function parseSourceToMachine(text, document, options = {}) {
-	const sourceLocations = collectXStateSourceLocations(text, document, options);
-	if (!sourceLocations) return text;
-	const staticValueReplacements = (sourceLocations.staticValues ?? []).map((location) => ({
-		range: location.range,
-		newText: JSON.stringify(location.value)
-	}));
-	const stateReplacements = sourceLocations.states.filter((location) => location.path.length === 1 && location.keyRange && !sourceLocations.statesObject?.referenceRange).flatMap((location) => {
-		const keyRange = location.keyRange;
-		const keyReplacement = location.keyReplacementText ? [{
-			range: keyRange,
-			newText: location.keyReplacementText
-		}] : [];
-		const stateText = readSourceRange(location.uri, location.range, options.resolver);
-		if (!stateText) return keyReplacement;
-		if (location.referenceRange && !areSourceRangesEqual(location.referenceRange, keyRange)) return [...keyReplacement, {
-			range: location.referenceRange,
-			newText: stateText
-		}];
-		if (!canHydrateShorthandState(text, keyRange)) return keyReplacement;
-		return [...keyReplacement, {
-			range: keyRange,
-			newText: `${location.path[0]}: ${stateText}`
-		}];
-	});
-	const statesObjectReplacements = sourceLocations.statesObject?.referenceRange && sourceLocations.statesObject.kind !== "inline" ? (() => {
-		const statesText = readHydratedStatesObject(sourceLocations.statesObject.uri, sourceLocations.statesObject.range, sourceLocations.states, options.resolver);
-		return statesText ? [{
-			range: sourceLocations.statesObject.referenceRange,
-			newText: areSourceRangesEqual(sourceLocations.statesObject.referenceRange, sourceLocations.statesObject.keyRange) ? `states: ${statesText}` : statesText
-		}] : [];
-	})() : [];
-	const importReplacements = collectHydratedImportReplacements(text, document, new Set([...sourceLocations.states.filter((location) => location.path.length === 1 && location.referenceRange).map((location) => location.symbol).filter((symbol) => typeof symbol === "string"), ...sourceLocations.statesObject?.symbol ? [sourceLocations.statesObject.symbol] : []]));
-	const hydratedText = applySourceRangeReplacements(text, [
-		...staticValueReplacements,
-		...stateReplacements,
-		...statesObjectReplacements,
-		...importReplacements
-	].filter(removeOverlappingRanges).sort(compareSourceRangesDescending));
-	if (sourceLocations.profile === "xstate-v6-alpha" || options.machineIndex !== void 0) {
-		const importedTransitionSources = collectImportedXStateTransitionSources(text, document, options);
-		const parseText = importedTransitionSources.length ? `${hydratedText}\n${importedTransitionSources.join("\n")}` : hydratedText;
-		const selectedMachineIndex = options.machineIndex ?? 0;
-		const config = extractXStateMachineConfigEntries(parseText, { profile: sourceLocations.profile }).find((entry) => entry.machineIndex === selectedMachineIndex)?.config;
-		if (!config) throw new Error(`No machine at index ${selectedMachineIndex} was found in ${document.fileName}.`);
-		return `import { createMachine } from "xstate";
-
-export const machine = createMachine(${serializeJS(config, 0)});
-`;
-	}
-	return hydratedText;
-}
-function readHydratedStatesObject(uri, range, states, resolver) {
-	if (!resolver) return null;
-	const document = resolver.read(uri);
-	if (!document) return null;
-	const replacements = states.filter((state) => state.path.length === 1 && state.referenceRange).flatMap((state) => {
-		const stateText = readSourceRange(state.uri, state.range, resolver);
-		if (!stateText || !state.referenceRange) return [];
-		const isShorthand = state.keyRange && areSourceRangesEqual(state.referenceRange, state.keyRange);
-		return [{
-			range: state.referenceRange,
-			newText: isShorthand ? `${state.path[0]}: ${stateText}` : stateText
-		}];
-	});
-	return applySourceRangeReplacementsToSlice(document.text, range, replacements);
-}
-function applySourceRangeReplacementsToSlice(text, range, replacements) {
-	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$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;
-		updated = `${updated.slice(0, localStart)}${replacement.newText}${updated.slice(localEnd)}`;
-	}
-	return updated;
-}
-function collectHydratedImportReplacements(text, document, hydratedSymbols) {
-	if (hydratedSymbols.size === 0) return [];
-	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;
-		if (!statement.moduleSpecifier.text.startsWith(".")) continue;
-		const namedBindings = statement.importClause?.namedBindings;
-		if (!namedBindings || !ts$1.isNamedImports(namedBindings)) continue;
-		const importedNames = namedBindings.elements.map((element) => element.name.text);
-		if (importedNames.length === 0 || !importedNames.every((name) => hydratedSymbols.has(name))) continue;
-		replacements.push({
-			range: toSourceRange(sourceFile, statement, { includeTrailingNewline: true }),
-			newText: ""
-		});
-	}
-	return replacements;
-}
-function toSourceRange(sourceFile, node, options = {}) {
-	const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-	let endOffset = node.getEnd();
-	if (options.includeTrailingNewline) {
-		const match = sourceFile.text.slice(endOffset).match(/^\r?\n/);
-		if (match) endOffset += match[0].length;
-	}
-	const end = sourceFile.getLineAndCharacterOfPosition(endOffset);
-	return {
-		startLine: start.line,
-		startChar: start.character,
-		endLine: end.line,
-		endChar: end.character
-	};
-}
-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;
-	return ts$1.ScriptKind.TS;
-}
-function removeOverlappingRanges(replacement, index, replacements) {
-	return !replacements.some((candidate, candidateIndex) => {
-		if (candidateIndex === index) return false;
-		return compareSourceRangesDescending(candidate, replacement) < 0 && rangesOverlap$1(candidate.range, replacement.range);
-	});
-}
-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);
-	return leftStart < rangePositionKey(right.endLine, right.endChar) && rightStart < leftEnd;
-}
-function rangePositionKey(line, character) {
-	return line * 1e6 + character;
-}
-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$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$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$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;
-}
-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$2(text, line, character) {
-	if (line <= 0) return character;
-	let currentLine = 0;
-	for (let index = 0; index < text.length; index += 1) {
-		if (text.charCodeAt(index) !== 10) continue;
-		currentLine += 1;
-		if (currentLine === line) return index + 1 + character;
-	}
-	return text.length;
-}
-
-//#endregion
-//#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 await openTextDocument(uri);
-	} catch {
-		return null;
-	}
-}
-function isSourceLocationForDocument(uri, document) {
-	return uri === (typeof document.uri === "string" ? document.uri : document.uri?.toString()) || uri === document.fileName;
-}
-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 (found) return;
-		if (ts$1.isObjectLiteralExpression(node) && node.getStart(sourceFile) === start && node.getEnd() >= end) {
-			found = node;
-			return;
-		}
-		ts$1.forEachChild(node, visit);
-	};
-	visit(sourceFile);
-	return found;
-}
-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 Math.min(lineStart + character, sourceText.length);
-}
-
-//#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 = getMappedRootObjectLiteral(document, sourceFile, options.sourceLocations) ?? findMachineConfigObjectLiteral(sourceFile, options.machineIndex);
-	if (!machineConfigNode) return [];
-	if (options.sourceUpdateStrategy === "rewrite") return addCodeImportReplacements(document, sourceFile, machineConfig, [createRewriteReplacement(document, sourceFile, machineConfigNode, machineConfig)]).sort(compareReplacementRangesDescending);
-	const parsedPatches = parseGraphPatches(options.patches);
-	const prevGraph = parseGraph(options.prevGraph);
-	const nextGraph = parseGraph(options.nextGraph);
-	const rootNode = machineConfigNode;
-	if (!parsedPatches || !prevGraph || !nextGraph || parsedPatches.length === 0) {
-		if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
-		return [createReplacement(document, sourceFile, rootNode, machineConfig)];
-	}
-	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)];
-			}
-			replacements.push(createReplacement(document, sourceFile, currentNode, nextValue));
-		}
-		return replacements.sort(compareReplacementRangesDescending);
-	}
-	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)];
-		}
-		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 replacements.sort(compareReplacementRangesDescending);
-	}
-	const plan = deriveReplacementPlan(patchesForSplit, prevGraph, nextGraph);
-	if (plan.type === "root") {
-		if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
-		return [createReplacement(document, sourceFile, rootNode, machineConfig)];
-	}
-	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);
-}
-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 [];
-	if (options.sourceUpdateStrategy === "rewrite") return addCodeImportReplacements(document, sourceFile, machineConfig, [createRewriteReplacement(document, sourceFile, machineConfigNode, machineConfig)]).sort(compareReplacementRangesDescending);
-	const parsedPatches = parseGraphPatches(options.patches);
-	const prevGraph = parseGraph(options.prevGraph);
-	const nextGraph = parseGraph(options.nextGraph);
-	const 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 fallbackRootReplacement(document, sourceFile, machineConfigNode, machineConfig, sourceLocations) {
-	if (wouldDeModularizeRootReplacement(sourceLocations)) return [];
-	return addCodeImportReplacements(document, sourceFile, machineConfig, [createReplacement(document, sourceFile, machineConfigNode, machineConfig)]).sort(compareReplacementRangesDescending);
-}
-async function tryCreateTransitionPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
-	if (isXStateV6Source(sourceLocations)) {
-		const v6Split = await tryCreateV6TransitionPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patches, prevGraph, nextGraph, sourceLocations, openTextDocument);
-		if (v6Split) return v6Split;
-	}
-	const replacements = [];
-	const remainingPatches = [];
-	const handledTransitionKeys = /* @__PURE__ */ new Set();
-	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;
-		}
-		const [statePropertyTarget] = getStatePropertyPatchTargets(patch, prevGraph, nextGraph);
-		if (!statePropertyTarget) {
-			remainingPatches.push(patch);
-			continue;
-		}
-		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;
-		}
-		replacements.push(...patchReplacements);
-		for (const propertyName of propertyNames) handledStatePropertyKeys.add(`${statePathKey}:${propertyName}`);
-	}
-	return replacements.length > 0 ? {
-		replacements: replacements.sort(compareReplacementRangesDescending),
-		remainingPatches
-	} : null;
-}
-async function tryCreateV6TransitionPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
-	applyV6FunctionDescriptionEdits(machineConfig, machineConfigNode, patches, prevGraph, nextGraph);
-	const propertiesByPath = /* @__PURE__ */ new Map();
-	const remainingPatches = [];
-	const deletedStatePaths = patches.flatMap((patch) => {
-		if (patch.op !== "deleteState") return [];
-		const path = resolveStatePath(prevGraph, patch.stateId);
-		return path ? [path] : [];
-	});
-	for (const patch of patches) {
-		const edgeId = getTransitionPatchEdgeId(patch, prevGraph, nextGraph);
-		if ((edgeId ? prevGraph.edges.find((edge) => edge.id === edgeId) ?? nextGraph.edges.find((edge) => edge.id === edgeId) : void 0)?.data?.meta?.[XSTATE_V6_FN_TRANSITION_META] === true && patch.op !== "deleteTransition") return {
-			replacements: [],
-			remainingPatches: []
-		};
-		const targets = getV6TransitionPropertyTargets(patch, prevGraph, nextGraph);
-		if (targets.length === 0) {
-			remainingPatches.push(patch);
-			continue;
-		}
-		for (const target of targets) {
-			if (deletedStatePaths.some((deletedPath) => isPathEqualOrDescendant(target.path, deletedPath))) continue;
-			const key = target.path.join(".");
-			const group = propertiesByPath.get(key) ?? {
-				path: target.path,
-				properties: /* @__PURE__ */ new Map()
-			};
-			const slots = group.properties.get(target.propertyName) ?? /* @__PURE__ */ new Set();
-			if (target.slotKey !== null) slots.add(target.slotKey);
-			group.properties.set(target.propertyName, slots);
-			propertiesByPath.set(key, group);
-		}
-	}
-	if (propertiesByPath.size === 0) return null;
-	const replacements = [];
-	for (const { path, properties } of propertiesByPath.values()) {
-		if (!canSerializeXStateV6TransitionProperties(machineConfig, path, properties)) return {
-			replacements: [],
-			remainingPatches: []
-		};
-		const propertyReplacements = await createStatePropertiesReplacementForDocuments(document, sourceFile, machineConfigNode, machineConfig, path, [...properties.keys()], sourceLocations, openTextDocument, properties);
-		if (!propertyReplacements) return null;
-		replacements.push(...propertyReplacements);
-	}
-	return {
-		replacements: replacements.sort(compareReplacementRangesDescending),
-		remainingPatches
-	};
-}
-function applyV6FunctionDescriptionEdits(machineConfig, machineConfigNode, patches, prevGraph, nextGraph) {
-	for (const patch of patches) {
-		if (patch.op !== "updateTransition" || patch.transitionDescription === void 0 || Object.prototype.hasOwnProperty.call(patch.meta ?? {}, XSTATE_V6_BRANCH_DESCRIPTION_META)) continue;
-		const target = getTransitionPatchTarget(patch, prevGraph, nextGraph);
-		if (!target) continue;
-		const stateObject = getStateObjectLiteralByPath(machineConfigNode, target.sourcePath);
-		if (!stateObject || !isV6FunctionTransitionSource(stateObject, target.previousEventType)) continue;
-		const stateConfig = getStateConfigByPath(machineConfig, target.sourcePath);
-		const transitions = (isMachineConfig(stateConfig?.on) ? stateConfig.on : null)?.[target.eventType];
-		if (!Array.isArray(transitions)) continue;
-		for (const transition of transitions) {
-			if (!isMachineConfig(transition)) continue;
-			if (patch.transitionDescription === null) delete transition.description;
-			else transition.description = patch.transitionDescription;
-		}
-	}
-}
-function isV6FunctionTransitionSource(stateObject, eventType) {
-	const onObject = getObjectLiteralProperty(stateObject, "on");
-	if (!onObject) return false;
-	const eventProperty = findObjectLiteralProperty(onObject, eventType);
-	if (!eventProperty || !ts$1.isPropertyAssignment(eventProperty)) return false;
-	const initializer = unwrapExpression$1(eventProperty.initializer);
-	if (ts$1.isArrowFunction(initializer) || ts$1.isFunctionExpression(initializer)) return true;
-	if (!ts$1.isObjectLiteralExpression(initializer)) return false;
-	return initializer.properties.some((property) => ts$1.isPropertyAssignment(property) && property.name.getText().replace(/^['"]|['"]$/g, "") === "to");
-}
-function canSerializeXStateV6TransitionProperties(machineConfig, path, properties) {
-	const stateConfig = getStateConfigByPath(machineConfig, path);
-	if (!stateConfig) return false;
-	for (const [propertyName, slots] of properties) {
-		const value = stateConfig[propertyName];
-		if (value === void 0) continue;
-		const converted = getXStateV6PropertyValue(propertyName, value);
-		if (propertyName === "on" || propertyName === "after") {
-			if (!isMachineConfig(converted)) return false;
-			if ([...slots].some((slot) => Array.isArray(converted[slot]))) return false;
-			continue;
-		}
-		if (propertyName === "invoke") {
-			const invokes = Array.isArray(converted) ? converted : [converted];
-			for (const slotRef of slots) {
-				const match = /^@statelyai\.invoke\.(done|error|snapshot|timeout)\.(.+)$/.exec(slotRef);
-				if (!match) return false;
-				const invoke = invokes[findXStateV6InvokeIndex(invokes, match[2])];
-				const slot = {
-					done: "onDone",
-					error: "onError",
-					snapshot: "onSnapshot",
-					timeout: "onTimeout"
-				}[match[1]];
-				if (!isMachineConfig(invoke) || Array.isArray(invoke[slot])) return false;
-			}
-			continue;
-		}
-		if (Array.isArray(converted)) return false;
-	}
-	return true;
-}
-async function createDeleteTransitionReplacementsForDocuments(document, sourceFile, machineConfigNode, transitionTarget, sourceLocations, openTextDocument) {
-	const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, transitionTarget.sourcePath, openTextDocument);
-	const targetDocument = mappedTarget?.document ?? document;
-	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)];
-}
-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 });
-}
-async function createStatePropertiesReplacementForDocuments(document, sourceFile, machineConfigNode, machineConfig, path, propertyNames, sourceLocations, openTextDocument, affectedV6Slots) {
-	const nextStateConfig = getStateConfigByPath(machineConfig, path);
-	if (!isMachineConfig(nextStateConfig)) return null;
-	const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, path, openTextDocument);
-	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 rawNextValue = nextStateConfig[propertyName];
-		const property = findObjectLiteralProperty(stateObject, propertyName);
-		const affectedSlots = affectedV6Slots?.get(propertyName);
-		const nextValue = rawNextValue === void 0 || !isXStateV6Source(sourceLocations) ? rawNextValue : getXStateV6PropertyValue(propertyName, rawNextValue);
-		if (affectedSlots && (propertyName === "on" || propertyName === "after") && property && ts$1.isPropertyAssignment(property) && isMachineConfig(nextValue)) {
-			const existingMap = unwrapObjectLiteralExpression(property.initializer);
-			if (existingMap) {
-				const insertedSlots = [];
-				for (const slot of affectedSlots) {
-					const existingSlot = findObjectLiteralProperty(existingMap, slot);
-					const nextSlotValue = nextValue[slot];
-					if (nextSlotValue === void 0) {
-						if (existingSlot) replacements.push(createObjectLiteralPropertyDeletion(targetDocument, targetSourceFile, existingMap, existingSlot));
-					} else if (existingSlot) replacements.push(createPropertyValueReplacement(targetDocument, targetSourceFile, existingSlot, nextSlotValue));
-					else insertedSlots.push({
-						key: slot,
-						config: nextSlotValue
-					});
-				}
-				if (insertedSlots.length > 0) replacements.push(createObjectLiteralPropertiesInsertion(targetDocument, targetSourceFile, existingMap, insertedSlots));
-				continue;
-			}
-		}
-		if (affectedSlots && propertyName === "invoke" && property && ts$1.isPropertyAssignment(property)) {
-			const invokeReplacements = createXStateV6InvokeSlotReplacements(targetDocument, targetSourceFile, property.initializer, nextValue, affectedSlots);
-			if (invokeReplacements) {
-				replacements.push(...invokeReplacements);
-				continue;
-			}
-		}
-		if (nextValue === void 0) {
-			if (!property) continue;
-			replacements.push(createObjectLiteralPropertyDeletion(targetDocument, targetSourceFile, stateObject, property));
-			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) : [];
-}
-function createXStateV6InvokeSlotReplacements(document, sourceFile, initializer, nextValue, affectedSlots) {
-	const expression = unwrapExpression$1(initializer);
-	const existingInvokes = ts$1.isArrayLiteralExpression(expression) ? expression.elements.filter(ts$1.isExpression) : [expression];
-	const nextInvokes = Array.isArray(nextValue) ? nextValue : [nextValue];
-	const replacements = [];
-	const insertions = /* @__PURE__ */ new Map();
-	for (const slotRef of affectedSlots) {
-		const match = /^@statelyai\.invoke\.(done|error|snapshot|timeout)\.(.+)$/.exec(slotRef);
-		if (!match) return null;
-		const propertyName = {
-			done: "onDone",
-			error: "onError",
-			snapshot: "onSnapshot",
-			timeout: "onTimeout"
-		}[match[1]];
-		const invokeId = match[2];
-		const invokeIndex = findXStateV6InvokeIndex(nextInvokes, invokeId);
-		const existingInvoke = existingInvokes[invokeIndex];
-		const nextInvoke = nextInvokes[invokeIndex];
-		if (invokeIndex < 0 || !existingInvoke || !nextInvoke || !isMachineConfig(nextInvoke)) return null;
-		const existingObject = unwrapObjectLiteralExpression(existingInvoke);
-		if (!existingObject) return null;
-		const existingProperty = findObjectLiteralProperty(existingObject, propertyName);
-		const nextSlotValue = nextInvoke[propertyName];
-		if (nextSlotValue === void 0) {
-			if (existingProperty) replacements.push(createObjectLiteralPropertyDeletion(document, sourceFile, existingObject, existingProperty));
-		} else if (existingProperty) replacements.push(createPropertyValueReplacement(document, sourceFile, existingProperty, nextSlotValue));
-		else {
-			const entries = insertions.get(existingObject) ?? [];
-			entries.push({
-				key: propertyName,
-				config: nextSlotValue
-			});
-			insertions.set(existingObject, entries);
-		}
-	}
-	for (const [existingObject, entries] of insertions) replacements.push(createObjectLiteralPropertiesInsertion(document, sourceFile, existingObject, entries));
-	return replacements;
-}
-function findXStateV6InvokeIndex(invokes, invokeId) {
-	return invokes.findIndex((candidate, index) => {
-		if (!isMachineConfig(candidate)) return false;
-		if (candidate.id === invokeId) return true;
-		if (candidate.id !== void 0) return false;
-		if (invokeId === `$auto-inline-${index}`) return true;
-		return typeof candidate.src === "string" && invokeId === `$auto-invoke-${candidate.src}`;
-	});
-}
-function getXStateV6PropertyValue(propertyName, value) {
-	const converted = toXStateV6MachineConfig({ [propertyName]: value });
-	return isMachineConfig(converted) ? converted[propertyName] : value;
-}
-function getTransitionPatchTarget(patch, prevGraph, nextGraph) {
-	const patchRecord = patch;
-	if (patch.op === "createTransition") {
-		const edge = getCreatedTransitionEdge(patch, prevGraph, nextGraph);
-		if (!edge) return null;
-		const sourcePath = resolveStatePath(nextGraph, patch.sourceId);
-		const eventType = edge?.data?.eventType ?? edge?.label ?? patchRecord.eventType;
-		if (!sourcePath || !eventType) return null;
-		return {
-			sourcePath,
-			eventType,
-			previousEventType: eventType,
-			transitionId: edge.id,
-			index: getTransitionIndexFromId(edge.id)
-		};
-	}
-	const edgeId = patch.op === "updateTransition" || patch.op === "deleteTransition" ? patch.transitionId : patch.op === "setGuard" || patch.op === "deleteGuard" ? patch.edgeId : patch.op === "createAction" || patch.op === "updateAction" || patch.op === "deleteAction" ? "edgeId" in patch.location ? patch.location.edgeId : null : null;
-	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 isXStateV6Source(sourceLocations) {
-	return sourceLocations?.profile === "xstate-v6-alpha" || sourceLocations?.profileRef?.startsWith("@statelyai/xstate@6") === true;
-}
-function getV6TransitionPropertyTargets(patch, prevGraph, nextGraph) {
-	const edgeId = getTransitionPatchEdgeId(patch, prevGraph, nextGraph);
-	if (!edgeId) return [];
-	const candidates = [{
-		edge: prevGraph.edges.find((edge) => edge.id === edgeId),
-		graph: prevGraph
-	}, {
-		edge: nextGraph.edges.find((edge) => edge.id === edgeId),
-		graph: nextGraph
-	}];
-	const targets = /* @__PURE__ */ new Map();
-	for (const { edge, graph } of candidates) {
-		if (!edge || edge.data?.route) continue;
-		const path = resolveStatePath(graph, edge.sourceId);
-		if (!path) continue;
-		const eventType = edge.data?.eventType ?? edge.label ?? "";
-		const sourceNode = graph.nodes.find((node) => node.id === edge.sourceId);
-		let propertyName;
-		let slotKey = null;
-		if (eventType === "") propertyName = sourceNode?.data.type === "choice" ? "choice" : "always";
-		else if (eventType.startsWith("xstate.after.")) {
-			propertyName = "after";
-			slotKey = getDelayKeyFromEventType(eventType, edge.sourceId);
-		} else if (eventType.startsWith("@statelyai.invoke.")) {
-			propertyName = "invoke";
-			slotKey = eventType;
-		} else if (eventType.startsWith("@statelyai.state.done.")) propertyName = "onDone";
-		else if (eventType.startsWith("@statelyai.state.error.")) propertyName = "onError";
-		else if (eventType.startsWith("@statelyai.state.timeout.")) propertyName = "onTimeout";
-		else {
-			propertyName = "on";
-			slotKey = eventType;
-		}
-		targets.set(`${path.join(".")}:${propertyName}:${slotKey ?? ""}`, {
-			path,
-			propertyName,
-			slotKey
-		});
-	}
-	return [...targets.values()];
-}
-function getCreatedTransitionEdge(patch, prevGraph, nextGraph) {
-	const previousIds = new Set(prevGraph.edges.map((edge) => edge.id));
-	let candidates = nextGraph.edges.filter((edge) => !previousIds.has(edge.id) && edge.sourceId === patch.sourceId);
-	const createdWithRequestedId = patch.id ? candidates.find((edge) => edge.id === patch.id) : void 0;
-	if (createdWithRequestedId) return createdWithRequestedId;
-	if (patch.eventType !== void 0) candidates = candidates.filter((edge) => (edge.data?.eventType ?? edge.label) === patch.eventType);
-	if (patch.targetId !== void 0) candidates = candidates.filter((edge) => edge.targetId === patch.targetId);
-	if (patch.transitionType !== void 0) candidates = candidates.filter((edge) => edge.data?.transitionType === patch.transitionType);
-	if (patch.matches !== void 0) candidates = candidates.filter((edge) => JSON.stringify(edge.data?.matches) === JSON.stringify(patch.matches));
-	return candidates.length === 1 ? candidates[0] : null;
-}
-function getTransitionPatchEdgeId(patch, prevGraph, nextGraph) {
-	if (patch.op === "createTransition") return getCreatedTransitionEdge(patch, prevGraph, nextGraph)?.id ?? null;
-	if (patch.op === "updateTransition" || patch.op === "deleteTransition") return patch.transitionId;
-	if (patch.op === "setGuard" || patch.op === "deleteGuard") return patch.edgeId;
-	if ((patch.op === "createAction" || patch.op === "updateAction" || patch.op === "deleteAction") && "edgeId" in patch.location) return patch.location.edgeId;
-	return null;
-}
-function getStatePropertyPatchTargets(patch, prevGraph, nextGraph) {
-	if (patch.op === "updateSchemas") return [{
-		path: [],
-		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);
-	const printed = containsRawCodeLike(nextValue) ? reindentPrintedExpression(serializeJS(nextValue), formatting) : printExpression(valueToExpression(nextValue, unwrapExpression$1(expression)), sourceFile, formatting);
-	return createOffsetReplacement(document, expression.getStart(sourceFile), expression.getEnd(), preserveExpressionComments(expression, sourceFile, printed, formatting));
-}
-function preserveExpressionComments(expression, sourceFile, printed, formatting) {
-	const original = sourceFile.text.slice(expression.getStart(sourceFile), expression.getEnd());
-	const scanner = ts$1.createScanner(ts$1.ScriptTarget.Latest, false, ts$1.LanguageVariant.JSX, original);
-	const comments = [];
-	for (let token = scanner.scan(); token !== ts$1.SyntaxKind.EndOfFileToken; token = scanner.scan()) if (token === ts$1.SyntaxKind.SingleLineCommentTrivia || token === ts$1.SyntaxKind.MultiLineCommentTrivia) comments.push(scanner.getTokenText());
-	const missing = comments.filter((comment) => !printed.includes(comment));
-	if (missing.length === 0) return printed;
-	const lineSeparator = formatting.newLineKind === ts$1.NewLineKind.CarriageReturnLineFeed ? "\r\n" : "\n";
-	const bodyStart = printed.indexOf("=> {");
-	if (bodyStart >= 0) {
-		const insertion = bodyStart + 4;
-		const indent = `${formatting.baseIndent}${formatting.indentUnit}`;
-		return `${printed.slice(0, insertion)}${lineSeparator}${missing.map((comment) => `${indent}${comment}`).join(lineSeparator)}${printed.slice(insertion)}`;
-	}
-	return `${missing.join(lineSeparator)}${lineSeparator}${formatting.baseIndent}${printed}`;
-}
-function createPropertyValueReplacement(document, sourceFile, property, nextValue) {
-	if (!ts$1.isPropertyAssignment(property)) return createPropertyAssignmentReplacement(document, sourceFile, property, getStatePropertyKeyText(property) ?? "value", nextValue);
-	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 propertyText = objectPropertyTextForInsertion(objectLiteral, printObjectLiteralProperty(key, nextValue, sourceFile, getFormattingContext(document, sourceFile, objectLiteral)));
-	return createObjectPropertyInsertionReplacements(document, objectLiteral, getObjectLiteralPropertyInsertionOffset(sourceFile, objectLiteral), propertyText);
-}
-function getObjectLiteralPropertyInsertionOffset(sourceFile, objectLiteral) {
-	const propertiesEnd = objectLiteral.properties.end;
-	const objectEnd = objectLiteral.getEnd() - 1;
-	const trailingTrivia = sourceFile.text.slice(propertiesEnd, objectEnd);
-	const commentMatch = /^[ \t]*(\/\/|\/\*)/.exec(trailingTrivia);
-	if (!commentMatch) return propertiesEnd;
-	const commentStart = propertiesEnd + commentMatch.index + commentMatch[0].length - 2;
-	if (commentMatch[1] === "//") {
-		const lineFeed = sourceFile.text.indexOf("\n", commentStart);
-		const lineEnd = lineFeed === -1 ? objectEnd : Math.min(lineFeed, objectEnd);
-		return lineEnd > commentStart && sourceFile.text.charCodeAt(lineEnd - 1) === 13 ? lineEnd - 1 : lineEnd;
-	}
-	const commentEnd = sourceFile.text.indexOf("*/", commentStart + 2);
-	return commentEnd === -1 ? propertiesEnd : Math.min(commentEnd + 2, objectEnd);
-}
-function createObjectPropertyInsertionReplacements(document, objectLiteral, insertionOffset, propertyText) {
-	const propertiesEnd = objectLiteral.properties.end;
-	const needsComma = objectLiteral.properties.length > 0 && !objectLiteral.properties.hasTrailingComma;
-	const replacements = [createOffsetReplacement(document, insertionOffset, insertionOffset, `${needsComma && insertionOffset === propertiesEnd ? "," : ""}${propertyText}`)];
-	if (needsComma && insertionOffset !== propertiesEnd) replacements.push(createOffsetReplacement(document, propertiesEnd, propertiesEnd, ","));
-	return replacements;
-}
-function getArrayElementDeletionRange(sourceFile, arrayLiteral, element) {
-	const elements = [...arrayLiteral.elements];
-	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 propertyText = objectPropertyTextForInsertion(implementationRoot, `${propertyNameTextForSource(categoryName)}: {\n${getIndentForNewObjectProperty(sourceFile, implementationRoot)}${propertyNameTextForSource(implementation.id)}: ${implementationCode},\n${getIndentForObjectClose(sourceFile, implementationRoot)}}`);
-		return createObjectPropertyInsertionReplacements(document, implementationRoot, getObjectLiteralPropertyInsertionOffset(sourceFile, implementationRoot), propertyText);
-	}
-	const propertyText = objectPropertyTextForInsertion(categoryObject, `${propertyNameTextForSource(implementation.id)}: ${implementationCode}`);
-	return createObjectPropertyInsertionReplacements(document, categoryObject, getObjectLiteralPropertyInsertionOffset(sourceFile, categoryObject), propertyText);
-}
-function objectPropertyTextForInsertion(objectLiteral, propertyText) {
-	const lineBreak = getLineBreak(objectLiteral.getSourceFile());
-	const indent = getIndentForNewObjectProperty(objectLiteral.getSourceFile(), objectLiteral);
-	return `${lineBreak}${indent}${propertyText.startsWith(indent) ? propertyText.slice(indent.length) : propertyText}`;
-}
-function getLineBreak(sourceFile) {
-	return sourceFile.text.includes("\r\n") ? "\r\n" : "\n";
-}
-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: objectLiteral.properties.hasTrailingComma ? objectLiteral.properties.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 objectValue = { [key]: value };
-	const objectText = containsRawCodeLike(value) ? reindentPrintedExpression(serializeJS(objectValue), formatting) : printExpression(valueToExpression(objectValue), sourceFile, formatting);
-	const lineSeparator = formatting.newLineKind === ts$1.NewLineKind.CarriageReturnLineFeed ? "\r\n" : "\n";
-	const lines = objectText.split(/\r?\n/);
-	if (lines.length <= 2) return objectText.replace(/^\{\s*/, "").replace(/\s*\}$/, "");
-	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 createRewriteReplacement(document, sourceFile, node, value) {
-	const start = document.positionAt(node.getStart(sourceFile));
-	const end = document.positionAt(node.getEnd());
-	const formatting = getFormattingContext(document, sourceFile, node);
-	return {
-		uri: getDocumentUri(document),
-		range: {
-			startLine: start.line,
-			startChar: start.character,
-			endLine: end.line,
-			endChar: end.character
-		},
-		newText: printExpression(valueToExpression(value), sourceFile, formatting)
-	};
-}
-function addCodeImportReplacements(document, sourceFile, machineConfig, replacements) {
-	const importReplacements = createCodeImportReplacements(document, sourceFile, collectCodeImports(machineConfig));
-	return [...replacements, ...importReplacements];
-}
-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 (isCodeExpression(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 descriptionSplit = isXStateV6Source(sourceLocations) ? await tryCreateV6WrapperDescriptionPatchSplitForDocuments(document, sourceFile, machineConfigNode, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) : null;
-	const split = getSemanticStateRenamePatchSplit(descriptionSplit?.remainingPatches ?? patches, prevGraph, nextGraph);
-	if (!split) return descriptionSplit;
-	const replacements = [...descriptionSplit?.replacements ?? []];
-	const targetLiterals = await collectMappedTargetStringLiterals(document, sourceFile, machineConfigNode, sourceLocations, openTextDocument);
-	let activeSourceLocations = sourceLocations;
-	for (const rename of split.renames) {
-		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
-	};
-}
-async function tryCreateV6WrapperDescriptionPatchSplitForDocuments(document, sourceFile, machineConfigNode, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
-	const replacements = [];
-	const remainingPatches = [];
-	const descriptionsByTarget = /* @__PURE__ */ new Map();
-	for (const patch of patches) {
-		if (patch.op !== "updateTransition" || patch.transitionDescription === void 0 || Object.entries(patch).some(([key, value]) => value !== void 0 && ![
-			"op",
-			"transitionId",
-			"transitionDescription"
-		].includes(key))) {
-			remainingPatches.push(patch);
-			continue;
-		}
-		const target = getTransitionPatchTarget(patch, prevGraph, nextGraph);
-		if (!target || target.previousEventType !== target.eventType) {
-			remainingPatches.push(patch);
-			continue;
-		}
-		const targetKey = `${target.sourcePath.join(".")}:${target.eventType}`;
-		if (descriptionsByTarget.has(targetKey)) {
-			if (descriptionsByTarget.get(targetKey) !== patch.transitionDescription) return null;
-			continue;
-		}
-		descriptionsByTarget.set(targetKey, patch.transitionDescription);
-		const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, target.sourcePath, openTextDocument);
-		const targetDocument = mappedTarget?.document ?? document;
-		const targetSourceFile = mappedTarget?.sourceFile ?? sourceFile;
-		const stateObject = mappedTarget?.node ?? getStateObjectLiteralByPath(machineConfigNode, target.sourcePath);
-		const onObject = stateObject ? getObjectLiteralProperty(stateObject, "on") : null;
-		const eventProperty = onObject ? findObjectLiteralProperty(onObject, target.eventType) : null;
-		const initializer = eventProperty && ts$1.isPropertyAssignment(eventProperty) ? unwrapExpression$1(eventProperty.initializer) : null;
-		const wrapper = initializer && ts$1.isObjectLiteralExpression(initializer) ? initializer : null;
-		const toProperty = wrapper ? getPropertyAssignment(wrapper, "to") : null;
-		if (!wrapper || !toProperty) {
-			remainingPatches.push(patch);
-			continue;
-		}
-		const descriptionProperty = getPropertyAssignment(wrapper, "description");
-		if (patch.transitionDescription === null) {
-			if (descriptionProperty) replacements.push(createObjectLiteralPropertyDeletion(targetDocument, targetSourceFile, wrapper, descriptionProperty));
-		} else if (descriptionProperty) replacements.push(createPropertyValueReplacement(targetDocument, targetSourceFile, descriptionProperty, patch.transitionDescription));
-		else replacements.push(...createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, wrapper, "description", patch.transitionDescription));
-	}
-	return replacements.length > 0 ? {
-		replacements,
-		remainingPatches,
-		sourceLocations
-	} : null;
-}
-function getSemanticStateRenameFromPatch(patch, prevGraph, nextGraph) {
-	if (patch.op !== "updateState" || patch.key === void 0) return null;
-	const prevPath = resolveStatePath(prevGraph, patch.stateId);
-	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;
-	const printedIndentUnit = Math.min(...lines.slice(1).map((line) => line.match(/^ */)?.[0].length ?? 0).filter((indent) => indent > 0), 4);
-	return lines.map((line, index) => {
-		if (index === 0) return line;
-		if (line.trim() === "") return "";
-		const leadingSpaces = line.match(/^ */)?.[0].length ?? 0;
-		const indentLevel = Math.floor(leadingSpaces / printedIndentUnit);
-		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 entries = Object.entries(value).filter(([, propertyValue]) => propertyValue !== void 0);
-		if (existingObject) {
-			const existingOrder = new Map(existingObject.properties.map((property, index) => [getStatePropertyKeyText(property), index]));
-			entries.sort(([left], [right]) => (existingOrder.get(left) ?? Number.MAX_SAFE_INTEGER) - (existingOrder.get(right) ?? Number.MAX_SAFE_INTEGER));
-		}
-		const properties = entries.map(([key, propertyValue]) => {
-			const existingProperty = existingObject ? getPropertyAssignment(existingObject, key) : null;
-			const nextInitializer = getPreservedPropertyInitializer(key, propertyValue, existingProperty?.initializer) ?? valueToExpression(propertyValue, existingProperty?.initializer);
-			if (existingProperty) return ts$1.factory.updatePropertyAssignment(existingProperty, existingProperty.name, nextInitializer);
-			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 containsRawCodeLike(value) {
-	if (isRawCodeLike(value)) return true;
-	if (Array.isArray(value)) return value.some(containsRawCodeLike);
-	return Boolean(value) && typeof value === "object" && Object.values(value).some(containsRawCodeLike);
-}
-function inlineExpressionDirectiveToExpression(value) {
-	if (!isCodeExpression(value)) return null;
-	return ts$1.factory.createIdentifier(value.expr);
-}
-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 detectedSourceLocations = collectXStateSourceLocations(document.getText(), document, { machineIndex: options?.machineIndex });
-		const rootSourceLocation = options?.sourceLocations?.root ?? detectedSourceLocations?.root;
-		const sanitizedMachineConfig = options?.preserveStatelyMetadata === false ? stripStatelyMetadata(machineConfig) : machineConfig;
-		if (!options?.patches?.length) return [];
-		const replacements = await applyMachineToSourceDocuments(sanitizedMachineConfig, document, options);
-		if (replacements.some(containsXStateExpressionPlaceholder) || options?.sourceUpdateStrategy !== "rewrite" && 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 === void 0 ? void 0 : 0) };
-	} 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)?$/);
-	if (httpsMatch) {
-		const [, owner, repo] = httpsMatch;
-		if (!owner || !repo) return null;
-		return {
-			url: `https://github.com/${owner}/${repo}`,
-			owner,
-			repo
-		};
-	}
-	const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
-	if (sshMatch) {
-		const [, owner, repo] = sshMatch;
-		if (!owner || !repo) return null;
-		return {
-			url: `https://github.com/${owner}/${repo}`,
-			owner,
-			repo
-		};
-	}
-	return null;
-}
-async function inferConnectedRepo(filePath, cwd) {
-	const workingDir = cwd ?? path.dirname(filePath);
-	try {
-		const [{ stdout: repoRootStdout }, { stdout: remoteStdout }, { stdout: branchStdout }, { stdout: treeShaStdout }] = await Promise.all([
-			execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd: workingDir }),
-			execFileAsync("git", [
-				"remote",
-				"get-url",
-				"origin"
-			], { cwd: workingDir }),
-			execFileAsync("git", ["branch", "--show-current"], { cwd: workingDir }),
-			execFileAsync("git", ["rev-parse", "HEAD"], { cwd: workingDir })
-		]);
-		const repoRoot = repoRootStdout.trim();
-		const remote = parseGitHubRemote(remoteStdout.trim());
-		const branch = branchStdout.trim();
-		const treeSha = treeShaStdout.trim();
-		if (!remote || !branch || !treeSha) return;
-		const relativePath = path.relative(repoRoot, filePath).replace(/\\/g, "/");
-		const relativeDir = path.dirname(relativePath).replace(/\\/g, "/");
-		const selectedPaths = relativePath && relativePath !== "." ? [relativePath] : [];
-		return {
-			...remote,
-			branch,
-			treeSha,
-			autoSync: false,
-			pathForNewFiles: relativeDir && relativeDir !== "." ? relativeDir : "src/stately-studio",
-			selectedPaths
-		};
-	} catch {
-		return;
-	}
-}
-function normalizeActions(value) {
-	if (value == null) return [];
-	return (Array.isArray(value) ? value : [value]).map((item) => {
-		if (typeof item === "string") return { type: item };
-		if (typeof item === "object" && item !== null && "type" in item) {
-			const type = item.type;
-			const params = "params" in item && typeof item.params === "object" && item.params ? item.params : void 0;
-			return {
-				type,
-				...params ? { params } : {}
-			};
-		}
-		return { type: String(item) };
-	});
-}
-function normalizeTags(value) {
-	if (!value) return [];
-	if (Array.isArray(value)) return value.map((tag) => String(tag));
-	return [String(value)];
-}
-function normalizeInvoke(value) {
-	if (!value) return [];
-	return (Array.isArray(value) ? value : [value]).map((invoke, index) => ({
-		src: invoke.src,
-		id: invoke.id ?? `invoke[${index}]`,
-		...invoke.input ? { input: invoke.input } : {}
-	}));
-}
-function resolveTargetId(sourceParentPath, target) {
-	if (!target) return;
-	if (target.startsWith("#")) {
-		const stripped = target.slice(1);
-		const machineIndex = stripped.indexOf(".");
-		if (machineIndex >= 0) return `(machine).${stripped.slice(machineIndex + 1)}`;
-		return `(machine).${stripped}`;
-	}
-	if (target.startsWith("(machine)")) return target;
-	if (target.includes(".")) return `(machine).${target}`;
-	return `${sourceParentPath}.${target}`;
-}
-function appendTransitionEdges(edges, sourceId, sourceParentPath, eventType, transition, edgeCounts) {
-	const transitions = Array.isArray(transition) ? transition : [transition];
-	for (const item of transitions) {
-		const normalized = typeof item === "string" ? { target: item } : item;
-		const targetId = resolveTargetId(sourceParentPath, Array.isArray(normalized.target) ? normalized.target[0] : normalized.target);
-		const groupKey = `${sourceId}:${eventType}`;
-		const index = edgeCounts.get(groupKey) ?? 0;
-		edgeCounts.set(groupKey, index + 1);
-		edges.push({
-			type: "edge",
-			id: `${sourceId}#${eventType}[${index}]`,
-			sourceId,
-			targetId: targetId ?? sourceId,
-			label: eventType,
-			data: {
-				eventType,
-				transitionType: normalized.reenter === true ? "reenter" : normalized.internal === true || !targetId ? "targetless" : "normal",
-				...normalized.guard ? { guard: typeof normalized.guard === "string" ? { type: normalized.guard } : {
-					type: normalized.guard.type,
-					...normalized.guard.params ? { params: normalized.guard.params } : {}
-				} } : {},
-				actions: normalizeActions(normalized.actions),
-				...normalized.description ? { description: normalized.description } : {}
-			}
-		});
-	}
-}
-function fromXStateConfig(config) {
-	const nodes = [];
-	const edges = [];
-	const edgeCounts = /* @__PURE__ */ new Map();
-	function visitNode(key, nodeConfig, parentId, parentPath) {
-		const nodeId = parentPath ? `${parentPath}.${key}` : "(machine)";
-		const currentPath = parentPath ? nodeId : "(machine)";
-		const initialId = nodeConfig.initial ? `${currentPath}.${nodeConfig.initial}` : void 0;
-		nodes.push({
-			type: "node",
-			id: nodeId,
-			parentId,
-			label: key,
-			...initialId ? { initialNodeId: initialId } : {},
-			data: {
-				key,
-				...nodeConfig.type ? { type: nodeConfig.type } : {},
-				...nodeConfig.history ? { history: nodeConfig.history } : {},
-				...initialId ? { initialId } : {},
-				entry: normalizeActions(nodeConfig.entry),
-				exit: normalizeActions(nodeConfig.exit),
-				invokes: normalizeInvoke(nodeConfig.invoke),
-				tags: normalizeTags(nodeConfig.tags),
-				...nodeConfig.description ? { description: nodeConfig.description } : {}
-			}
-		});
-		for (const [eventType, transition] of Object.entries(nodeConfig.on ?? {})) appendTransitionEdges(edges, nodeId, parentPath ?? "(machine)", eventType, transition, edgeCounts);
-		if (nodeConfig.always) appendTransitionEdges(edges, nodeId, parentPath ?? "(machine)", "", nodeConfig.always, edgeCounts);
-		for (const [childKey, childConfig] of Object.entries(nodeConfig.states ?? {})) visitNode(childKey, childConfig, nodeId, currentPath);
-	}
-	visitNode("(machine)", config, null, null);
-	return {
-		id: config.id ?? "machine",
-		nodes,
-		edges,
-		data: {}
-	};
-}
-async function pushLocalMachineLinks(options) {
-	const client = options.client ?? createStatelyClient({
-		apiKey: options.apiKey,
-		baseUrl: options.baseUrl,
-		fetch: options.fetch
-	});
-	const sourcePath = path.resolve(options.cwd ?? process.cwd(), options.source);
-	const project = await resolvePushProject(client, sourcePath, options);
-	if (!project.projectVersionId) throw new Error("Resolved project is missing projectVersionId.");
-	const contents = await fs.readFile(sourcePath, "utf8");
-	const attachments = findStatelyPragmaAttachments(contents, sourcePath);
-	const extracted = await extractMachinesFromLocalSource(sourcePath, contents);
-	if (attachments.length === 0 || extracted.machines.length === 0) return {
-		sourcePath,
-		project,
-		created: [],
-		updated: [],
-		skipped: [{
-			machineIndex: 0,
-			reason: extracted.error != null ? formatLocalMachineExtractionIssue(extracted.error) : "No local machines were discovered in this file."
-		}]
-	};
-	if (attachments.length !== extracted.machines.length) return {
-		sourcePath,
-		project,
-		created: [],
-		updated: [],
-		skipped: [{
-			machineIndex: 0,
-			reason: "The local machine extractor did not align with the source attachments for this file."
-		}]
-	};
-	let nextContents = contents;
-	let outputPath;
-	const created = [];
-	const updated = [];
-	const skipped = [];
-	for (const [machineIndex, attachment] of attachments.entries()) {
-		const extractedMachine = extracted.machines[machineIndex];
-		if (!extractedMachine?.config) {
-			skipped.push({
-				machineIndex,
-				reason: "No extracted machine config was available for this source."
-			});
-			continue;
-		}
-		if (attachment.pragma?.id && !options.relink) {
-			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({
-			projectVersionId: project.projectVersionId,
-			definition: toStudioMachine(fromXStateConfig(extractedMachine.config)),
-			xstateVersion: Math.max(5, options.xstateVersion ?? 5)
-		});
-		nextContents = upsertStatelyPragma(nextContents, machine.id, {
-			fileName: sourcePath,
-			machineIndex
-		});
-		created.push({
-			machineIndex,
-			machine
-		});
-	}
-	if (nextContents !== contents) {
-		await fs.writeFile(sourcePath, nextContents, "utf8");
-		outputPath = sourcePath;
-	}
-	return {
-		sourcePath,
-		project,
-		created,
-		updated,
-		skipped,
-		...outputPath ? { outputPath } : {}
-	};
-}
-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 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,
-			format: "xstate",
-			graph: fromXStateConfig(config)
-		};
-	}
-	const parsed = JSON.parse(contents);
-	if ("rootNode" in parsed && "edges" in parsed) return {
-		kind: "local-file",
-		locator: filePath,
-		format: "digraph",
-		graph: fromStudioMachine(parsed)
-	};
-	if ("nodes" in parsed && "edges" in parsed) return {
-		kind: "local-file",
-		locator: filePath,
-		format: "graph",
-		graph: parsed
-	};
-	if ("states" in parsed) return {
-		kind: "local-file",
-		locator: filePath,
-		format: "xstate",
-		graph: fromXStateConfig(parsed)
-	};
-	throw new Error(`Unsupported local sync input: ${filePath}`);
-}
-function inferWritableTargetFormat(filePath) {
-	if (filePath.endsWith(".ts") || filePath.endsWith(".tsx") || filePath.endsWith(".js") || filePath.endsWith(".jsx")) return "xstate";
-	if (filePath.endsWith(".digraph.json")) return "digraph";
-	if (filePath.endsWith(".graph.json")) return "graph";
-	return null;
-}
-function resolveLocalXStateMachineId(graph) {
-	const rootKey = (graph.nodes.find((node) => node.parentId == null) ?? null)?.data?.key;
-	if (rootKey && rootKey !== "(machine)") return rootKey;
-	return graph.id;
-}
-function serializeGraph(graph, format, options = {}) {
-	switch (format) {
-		case "digraph": return `${JSON.stringify(toStudioMachine(graph), null, 2)}\n`;
-		case "graph": return `${JSON.stringify(graph, null, 2)}\n`;
-		case "xstate": {
-			const targetLanguage = inferXStateTargetLanguage(options.targetPath);
-			const source = graphToXStateTS({
-				...graph,
-				id: resolveLocalXStateMachineId(graph)
-			}, { targetLanguage });
-			if (!options.remoteMachineId) return source;
-			return upsertStatelyPragma(source, options.remoteMachineId, options.targetPath ? { fileName: options.targetPath } : {});
-		}
-		default: {
-			const exhaustive = format;
-			throw new Error(`Unsupported sync output format: ${exhaustive}`);
-		}
-	}
-}
-function inferXStateTargetLanguage(targetPath) {
-	if (!targetPath) return "typescript";
-	return /\.(?:c|m)?jsx?$/i.test(targetPath) ? "javascript" : "typescript";
-}
-async function resolveRemoteMachine(machineId, baseUrl, kind, locator, options) {
-	const digraph = (await (options.client ?? createStatelyClient({
-		apiKey: options.apiKey,
-		baseUrl,
-		fetch: options.fetch
-	})).machines.get(machineId)).definition;
-	return {
-		kind,
-		locator,
-		format: "digraph",
-		graph: fromStudioMachine(digraph),
-		remoteMachineId: machineId
-	};
-}
-async function resolveSyncInput(locator, options) {
-	if (await fileExists(path.resolve(options.cwd ?? process.cwd(), locator))) return resolveLocalFile(locator, options);
-	if (isUrl(locator)) {
-		const url = new URL(locator);
-		const machineId = url.pathname.split("/").filter(Boolean).at(-1);
-		if (!machineId) throw new Error(`Could not resolve machine ID from URL: ${locator}`);
-		return resolveRemoteMachine(machineId, url.origin, "studio-url", locator, options);
-	}
-	return resolveRemoteMachine(locator, options.baseUrl, "studio-machine-id", locator, options);
-}
-function summarizeDiff(diff) {
-	const nodeChanges = diff.nodes.added.length + diff.nodes.removed.length + diff.nodes.updated.length;
-	const edgeChanges = diff.edges.added.length + diff.edges.removed.length + diff.edges.updated.length;
-	return {
-		hasChanges: !isEmptyDiff(diff),
-		nodeChanges,
-		edgeChanges
-	};
-}
-async function planSync(options) {
-	const source = await resolveSyncInput(options.source, options);
-	const target = await resolveSyncInput(options.target, options);
-	const { diff } = diffGraphsSemantically(source.graph, target.graph);
-	return {
-		source,
-		target,
-		diff,
-		summary: summarizeDiff(diff),
-		warnings: []
-	};
-}
-async function pullSync(options) {
-	const source = await resolveSyncInput(options.source, options);
-	const outputPath = path.resolve(options.cwd ?? process.cwd(), options.target);
-	const fallbackFormat = inferWritableTargetFormat(outputPath);
-	let targetFormat = fallbackFormat;
-	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.`);
-	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: {
-			kind: "local-file",
-			locator: outputPath,
-			format: targetFormat,
-			graph: source.graph
-		},
-		outputPath
-	};
-}
-function inferDefaultProjectName(sourcePath, repo) {
-	if (repo?.repo) return repo.repo;
-	const parentDir = path.basename(path.dirname(sourcePath));
-	if (parentDir && parentDir !== ".") return parentDir;
-	return path.basename(sourcePath, path.extname(sourcePath));
-}
-async function resolvePushProject(client, sourcePath, options) {
-	const explicitProject = options.project;
-	if (explicitProject?.projectId) return client.projects.get(explicitProject.projectId);
-	if (explicitProject?.projectVersionId) {
-		const matchedProject = (await client.projects.list()).find((candidate) => candidate.projectVersionId === explicitProject.projectVersionId);
-		if (!matchedProject) throw new Error(`No project found for projectVersionId "${explicitProject.projectVersionId}".`);
-		return client.projects.get(matchedProject.projectId);
-	}
-	const inferredRepo = explicitProject?.repo ?? await inferConnectedRepo(sourcePath, options.cwd);
-	const projectInput = {
-		name: explicitProject?.name ?? inferDefaultProjectName(sourcePath, inferredRepo),
-		visibility: explicitProject?.visibility ?? "private",
-		...explicitProject?.description ? { description: explicitProject.description } : {},
-		...explicitProject?.keywords ? { keywords: explicitProject.keywords } : {},
-		...inferredRepo ? { repo: inferredRepo } : {}
-	};
-	return client.projects.ensure(projectInput);
-}
-async function pushSync(options) {
-	const client = options.client ?? createStatelyClient({
-		apiKey: options.apiKey,
-		baseUrl: options.baseUrl,
-		fetch: options.fetch
-	});
-	const source = await resolveSyncInput(options.source, {
-		...options,
-		target: options.source
-	});
-	if (source.kind !== "local-file") throw new Error("pushSync currently requires a local source file.");
-	const sourcePath = source.locator;
-	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 updateMachineDefinition(client, existingMachineId, source.graph);
-	else {
-		if (!project.projectVersionId) throw new Error("Resolved project is missing projectVersionId.");
-		machine = await client.machines.create({
-			projectVersionId: project.projectVersionId,
-			definition: toStudioMachine(source.graph),
-			xstateVersion: options.xstateVersion ?? 5
-		});
-	}
-	let outputPath;
-	if (source.format === "xstate") {
-		const contents = await fs.readFile(sourcePath, "utf8");
-		const nextContents = upsertStatelyPragma(contents, machine.id, { fileName: sourcePath });
-		if (nextContents !== contents) {
-			await fs.writeFile(sourcePath, nextContents, "utf8");
-			outputPath = sourcePath;
-		}
-	}
-	return {
-		source,
-		project,
-		machine,
-		...outputPath ? { outputPath } : {}
-	};
-}
-
-//#endregion
-export { PullSourceReconciliationError, planSync, pullSync, pushLocalMachineLinks, pushSync };