@statelyai/sdk 0.6.1 → 0.7.1

package/dist/sync-DLkTmSyA.mjs

@@ -0,0 +1,2513 @@
+import { createStatelyClient } from "./studio.mjs";
+import { d as upsertStatelyPragma, l as findStatelyPragmaAttachments, t as graphToXStateTS, u as getStatelyPragma } from "./graphToXStateTS-Gzh0ZqbN.mjs";
+import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
+import * as ts$1 from "typescript";
+import { getDiff, 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 vm from "node:vm";
+import * as esbuild from "esbuild";
+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 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;
+}
+
+//#endregion
+//#region ../editor-sync/src/internal/sourceLocations.ts
+function collectXStateSourceLocations(sourceText, document) {
+	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$1(document.fileName));
+	const uri = document.uri?.toString() ?? document.fileName;
+	const bindings = collectBindings(sourceFile, uri, document.fileName);
+	const staticValues = collectStaticValueBindings(sourceFile);
+	const root = findMachineConfigObjectLiteral$1(sourceFile, bindings);
+	if (!root) return;
+	const states = [];
+	collectStateLocations(root, [], states, bindings, staticValues, root);
+	return {
+		version: 1,
+		root: {
+			uri,
+			range: toSourceRange(sourceFile, root)
+		},
+		states,
+		staticValues: collectStaticValueReferences(sourceFile, uri, root, staticValues)
+	};
+}
+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(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(sourceFile, member.initializer)
+			});
+		}
+	}
+	return bindings;
+}
+function collectBindings(sourceFile, uri, fileName) {
+	const bindings = collectTopLevelBindings(sourceFile, uri);
+	addImportedBindings(bindings, sourceFile, fileName);
+	return bindings;
+}
+function collectTopLevelBindings(sourceFile, uri) {
+	const bindings = /* @__PURE__ */ new Map();
+	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.initializer) 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, fileName) {
+	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 importedFileName = resolveImportPath(fileName, statement.moduleSpecifier.text);
+		if (!importedFileName) continue;
+		const importedText = readSourceFile(importedFileName);
+		if (importedText === null) continue;
+		const importedBindings = collectBindings(ts$1.createSourceFile(importedFileName, importedText, ts$1.ScriptTarget.Latest, true, getScriptKind$1(importedFileName)), pathToFileURL(importedFileName).toString(), importedFileName);
+		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 findMachineConfigObjectLiteral$1(sourceFile, bindings) {
+	let found = null;
+	const visit = (node) => {
+		if (found) return;
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression(node.expression)) {
+			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, bindings, staticValues, root) {
+	const statesObject = getObjectLiteralProperty$1(stateObject, "states");
+	if (!statesObject) return;
+	for (const property of statesObject.properties) {
+		const resolved = resolveStateProperty(property, 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(resolved.sourceFile, resolved.stateObject)
+		});
+		collectStateLocations(resolved.stateObject, path, locations, resolved.bindings, staticValues, root);
+	}
+}
+function resolveStateProperty(property, bindings, staticValues, root) {
+	if (ts$1.isShorthandPropertyAssignment(property)) {
+		const binding = bindings.get(property.name.text);
+		if (!binding) return null;
+		return {
+			key: property.name.text,
+			kind: binding.kind,
+			symbol: property.name.text,
+			keyRange: toSourceRange(property.getSourceFile(), property.name),
+			referenceRange: toSourceRange(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(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) return null;
+		return {
+			key: resolvedKey.key,
+			kind: binding.kind,
+			symbol: property.initializer.text,
+			keyRange: toSourceRange(property.getSourceFile(), property.name),
+			referenceRange: toSourceRange(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 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 readSourceFile(fileName) {
+	try {
+		return fs$1.readFileSync(fileName, "utf8");
+	} catch {
+		return null;
+	}
+}
+function getSourceFileUri(sourceFile) {
+	return path$1.isAbsolute(sourceFile.fileName) ? pathToFileURL(sourceFile.fileName).toString() : sourceFile.fileName;
+}
+function unwrapCreateConfigArgument(expression) {
+	const unwrapped = unwrapExpression(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(expression);
+	if (!ts$1.isIdentifier(unwrapped)) return null;
+	const binding = bindings.get(unwrapped.text);
+	return binding?.kind === "objectReference" ? binding.node : null;
+}
+function getObjectLiteralProperty$1(objectLiteral, propertyName) {
+	for (const property of objectLiteral.properties) {
+		if (!ts$1.isPropertyAssignment(property)) continue;
+		if (getPropertyNameText$1(property.name) !== propertyName) continue;
+		return unwrapObjectLiteralExpression$1(property.initializer);
+	}
+	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 resolvePropertyKey(name, staticValues, root) {
+	const literalKey = getPropertyNameText$1(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(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(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(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$1(parentProperty.name) === "states";
+}
+function getStaticStringValue(expression) {
+	const unwrapped = unwrapExpression(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(expression) {
+	return ts$1.isIdentifier(expression) && expression.text === "createMachine" || ts$1.isPropertyAccessExpression(expression) && expression.name.text === "createMachine";
+}
+function unwrapObjectLiteralExpression$1(expression) {
+	const unwrapped = unwrapExpression(expression);
+	return ts$1.isObjectLiteralExpression(unwrapped) ? unwrapped : null;
+}
+function unwrapExpression(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(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$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;
+}
+
+//#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) {
+	const sourceLocations = collectXStateSourceLocations(text, document);
+	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).flatMap((location) => {
+		const keyRange = location.keyRange;
+		const keyReplacement = location.keyReplacementText ? [{
+			range: keyRange,
+			newText: location.keyReplacementText
+		}] : [];
+		const stateText = readSourceRange(location.uri, location.range);
+		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}`
+		}];
+	});
+	return applySourceRangeReplacements(text, [...staticValueReplacements, ...stateReplacements].filter(removeOverlappingRanges).sort(compareSourceRangesDescending));
+}
+function removeOverlappingRanges(replacement, index, replacements) {
+	return !replacements.some((candidate, candidateIndex) => {
+		if (candidateIndex === index) return false;
+		return compareSourceRangesDescending(candidate, replacement) < 0 && rangesOverlap(candidate.range, replacement.range);
+	});
+}
+function rangesOverlap(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$1(text, range.endLine, range.endChar);
+	return text.slice(end).match(/\S/)?.[0] !== ":";
+}
+function readSourceRange(uri, range) {
+	const fileName = sourceUriToFileName(uri);
+	if (!fileName) return null;
+	try {
+		const text = fs$1.readFileSync(fileName, "utf8");
+		const start = offsetAtRangePosition$1(text, range.startLine, range.startChar);
+		const end = offsetAtRangePosition$1(text, range.endLine, range.endChar);
+		return text.slice(start, end);
+	} catch {
+		return null;
+	}
+}
+function sourceUriToFileName(uri) {
+	if (uri.startsWith("file://")) return fileURLToPath(uri);
+	if (/^[a-z][a-z\d+.-]*:/i.test(uri)) return null;
+	return uri;
+}
+function applySourceRangeReplacements(text, replacements) {
+	let updated = text;
+	for (const replacement of replacements) {
+		const start = offsetAtRangePosition$1(updated, replacement.range.startLine, replacement.range.startChar);
+		const end = offsetAtRangePosition$1(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$1(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/graphToCode.ts
+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);
+	if (!machineConfigNode) return [];
+	const parsedPatches = parseGraphPatches(options.patches);
+	const prevGraph = parseGraph(options.prevGraph);
+	const nextGraph = parseGraph(options.nextGraph);
+	if (!parsedPatches || !prevGraph || !nextGraph || parsedPatches.length === 0) {
+		if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+		return [createReplacement(document, sourceFile, machineConfigNode, machineConfig)];
+	}
+	const semanticSplit = await tryCreateSemanticPatchSplitForDocuments(document, sourceFile, machineConfigNode, parsedPatches, prevGraph, nextGraph, options.sourceLocations, options.openTextDocument);
+	if (semanticSplit && semanticSplit.remainingPatches.length === 0) return semanticSplit.replacements.sort(compareReplacementRangesDescending);
+	const activePatches = semanticSplit?.remainingPatches ?? parsedPatches;
+	const activeSourceLocations = semanticSplit?.sourceLocations ?? options.sourceLocations;
+	let semanticReplacements = semanticSplit?.replacements ?? [];
+	const implementationSplit = tryCreateImplementationPatchSplit(document, sourceFile, activePatches, nextGraph);
+	if (implementationSplit && implementationSplit.remainingPatches.length === 0) return [...semanticReplacements, ...implementationSplit.replacements].sort(compareReplacementRangesDescending);
+	if (implementationSplit) semanticReplacements = [...semanticReplacements, ...implementationSplit.replacements];
+	const patchesAfterImplementationSplit = implementationSplit?.remainingPatches ?? activePatches;
+	const stateMembershipSplit = await tryCreateStateMembershipPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patchesAfterImplementationSplit, prevGraph, nextGraph, activeSourceLocations, options.openTextDocument);
+	if (stateMembershipSplit) {
+		if (stateMembershipSplit.remainingPatches.length === 0) return [...semanticReplacements, ...stateMembershipSplit.replacements].sort(compareReplacementRangesDescending);
+		const remainingPlan = deriveReplacementPlan(stateMembershipSplit.remainingPatches, prevGraph, nextGraph);
+		if (remainingPlan.type === "root") {
+			if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+			return [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 replacements.sort(compareReplacementRangesDescending);
+	}
+	const plan = deriveReplacementPlan(patchesAfterImplementationSplit, prevGraph, nextGraph);
+	if (plan.type === "root") {
+		if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
+		return [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 replacements.sort(compareReplacementRangesDescending);
+}
+function fallbackRootReplacement(document, sourceFile, machineConfigNode, machineConfig, sourceLocations) {
+	if (wouldDeModularizeRootReplacement(sourceLocations)) return [];
+	return [createReplacement(document, sourceFile, machineConfigNode, machineConfig)];
+}
+function tryCreateImplementationPatchSplit(document, sourceFile, patches, nextGraph) {
+	const replacements = [];
+	const remainingPatches = [];
+	for (const patch of patches) {
+		if (!isImplementationPatch(patch)) {
+			remainingPatches.push(patch);
+			continue;
+		}
+		const patchReplacements = createImplementationPatchReplacements(document, sourceFile, patch, nextGraph);
+		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) {
+	const implementationRoot = findSetupObjectLiteral(sourceFile) ?? findCreateMachineImplementationObjectLiteral(sourceFile);
+	if (!implementationRoot) return null;
+	const categoryName = implementationSourceTypeToCategoryName(patch.sourceType);
+	const categoryObject = getObjectLiteralProperty(implementationRoot, categoryName);
+	if (patch.op === "createImplementation") return createImplementationCreateReplacements(document, sourceFile, implementationRoot, categoryName, getGraphImplementation(nextGraph, patch.sourceType, patch.implementation.id) ?? patch.implementation);
+	if (!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 createImplementationCreateReplacements(document, sourceFile, implementationRoot, categoryName, implementation) {
+	const implementationCode = implementation.code?.body;
+	if (!implementation.id || !implementationCode) return null;
+	const categoryObject = getObjectLiteralProperty(implementationRoot, categoryName);
+	if (!categoryObject) {
+		const text = objectPropertyTextForInsertion(implementationRoot, `${propertyNameTextForSource(categoryName)}: {\n${getIndentForNewObjectProperty(sourceFile, implementationRoot)}${propertyNameTextForSource(implementation.id)}: ${implementationCode},\n${getIndentForObjectClose(sourceFile, implementationRoot)}}`);
+		return [createOffsetReplacement(document, implementationRoot.properties.end, implementationRoot.properties.end, text)];
+	}
+	const text = objectPropertyTextForInsertion(categoryObject, `${propertyNameTextForSource(implementation.id)}: ${implementationCode}`);
+	return [createOffsetReplacement(document, categoryObject.properties.end, categoryObject.properties.end, text)];
+}
+function objectPropertyTextForInsertion(objectLiteral, propertyText) {
+	return `${objectLiteral.properties.length > 0 ? "," : ""}${getLineBreak(objectLiteral.getSourceFile())}${getIndentForNewObjectProperty(objectLiteral.getSourceFile(), objectLiteral)}${propertyText}`;
+}
+function getLineBreak(sourceFile) {
+	return sourceFile.text.includes("\r\n") ? "\r\n" : "\n";
+}
+function 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";
+	}
+}
+async function tryCreateStateMembershipPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
+	const split = splitStateMembershipPatches(patches, prevGraph, nextGraph, sourceLocations);
+	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) {
+	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 remainingPatchesWithSurvivingOwners = remainingPatches.filter((patch) => {
+		const owner = resolvePatchOwner(patch, prevGraph, nextGraph);
+		return owner.type !== "covered" && !isPatchOwnerCoveredByDeletedPaths(owner, deletedPaths);
+	});
+	const split = coalesceMembershipChangesWithRemainingPatches([...changesByParent.values()], remainingPatchesWithSurvivingOwners, prevGraph, nextGraph, sourceLocations);
+	return split.changes.length > 0 ? split : null;
+}
+function isPatchOwnerCoveredByDeletedPaths(owner, deletedPaths) {
+	if (owner.type !== "state" || deletedPaths.length === 0) return false;
+	return deletedPaths.some((deletedPath) => isPathEqualOrDescendant(owner.path, deletedPath));
+}
+function coalesceMembershipChangesWithRemainingPatches(changes, remainingPatches, prevGraph, nextGraph, sourceLocations) {
+	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)) {
+			activeRemainingPatches.push(...change.patches);
+			continue;
+		}
+		activeChanges.push(change);
+	}
+	return {
+		changes: activeChanges,
+		remainingPatches: activeRemainingPatches
+	};
+}
+function shouldCoalesceMembershipChangeWithRemainingPlan(change, remainingPlan, sourceLocations) {
+	if (change.parentPath.length === 0 && wouldDeModularizeRootReplacement(sourceLocations)) return false;
+	if (remainingPlan.type === "root") return true;
+	return remainingPlan.paths.some((path) => isPathEqualOrDescendant(path, change.parentPath) || isPathEqualOrDescendant(change.parentPath, path));
+}
+function isPathEqualOrDescendant(path, candidateParentPath) {
+	return candidateParentPath.every((segment, index) => path[index] === segment);
+}
+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);
+		if (!target) return null;
+		const changeReplacements = createStateMembershipReplacementsForTarget(target.document, target.sourceFile, target.node, machineConfig, change);
+		if (!changeReplacements) return null;
+		replacements.push(...changeReplacements);
+	}
+	return replacements.sort(compareReplacementRangesDescending);
+}
+function createStateMembershipReplacementsForTarget(document, sourceFile, parentObject, machineConfig, change) {
+	const statesObject = 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);
+}
+async function getStateMembershipParentTargetForDocuments(document, sourceFile, machineConfigNode, sourceLocations, parentPath, openTextDocument) {
+	if (parentPath.length === 0) return {
+		document,
+		sourceFile,
+		node: machineConfigNode
+	};
+	const mappedTarget = await getMappedStateReplacementTarget(document, sourceFile, sourceLocations, parentPath, openTextDocument);
+	if (mappedTarget) return mappedTarget;
+	const node = getStateObjectLiteralByPath(machineConfigNode, parentPath);
+	return node ? {
+		document,
+		sourceFile,
+		node
+	} : null;
+}
+function createObjectLiteralPropertiesInsertion(document, sourceFile, objectLiteral, entries) {
+	const formatting = getFormattingContext(document, sourceFile, objectLiteral);
+	const lineSeparator = formatting.newLineKind === ts$1.NewLineKind.CarriageReturnLineFeed ? "\r\n" : "\n";
+	const propertyTexts = entries.map((entry) => printObjectLiteralProperty(entry.key, entry.config, sourceFile, formatting));
+	const existingProperties = objectLiteral.properties;
+	const closeBraceOffset = objectLiteral.getEnd() - 1;
+	const startOffset = existingProperties.length === 0 ? closeBraceOffset : existingProperties[existingProperties.length - 1].getEnd();
+	const start = document.positionAt(startOffset);
+	const end = document.positionAt(closeBraceOffset);
+	const prefix = existingProperties.length === 0 ? lineSeparator : `,${lineSeparator}`;
+	const suffix = `${lineSeparator}${formatting.baseIndent}`;
+	return {
+		uri: getDocumentUri(document),
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		newText: `${prefix}${propertyTexts.join(`,${lineSeparator}`)}${suffix}`
+	};
+}
+function createObjectLiteralPropertyDeletion(document, sourceFile, objectLiteral, property) {
+	const range = getObjectLiteralPropertyDeletionRange(sourceFile, objectLiteral, property);
+	const start = document.positionAt(range.start);
+	const end = document.positionAt(range.end);
+	return {
+		uri: getDocumentUri(document),
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		newText: ""
+	};
+}
+function getObjectLiteralPropertyDeletionRange(sourceFile, objectLiteral, property) {
+	const properties = [...objectLiteral.properties];
+	const propertyIndex = properties.indexOf(property);
+	const propertyStart = property.getFullStart();
+	const propertyEnd = property.getEnd();
+	if (properties.length === 1) return {
+		start: propertyStart,
+		end: propertyEnd
+	};
+	if (propertyIndex === properties.length - 1) {
+		const previousProperty = properties[propertyIndex - 1];
+		const commaOffset = sourceFile.text.lastIndexOf(",", propertyStart - 1);
+		return {
+			start: commaOffset >= previousProperty.getEnd() && commaOffset < propertyStart ? commaOffset : propertyStart,
+			end: propertyEnd
+		};
+	}
+	const nextProperty = properties[propertyIndex + 1];
+	const commaOffset = sourceFile.text.indexOf(",", propertyEnd);
+	return {
+		start: propertyStart,
+		end: commaOffset >= propertyEnd && commaOffset < nextProperty.getFullStart() ? commaOffset + 1 : propertyEnd
+	};
+}
+function findObjectLiteralProperty(objectLiteral, propertyName) {
+	for (const property of objectLiteral.properties) {
+		if (ts$1.isShorthandPropertyAssignment(property) && property.name.text === propertyName) return property;
+		if (ts$1.isPropertyAssignment(property)) {
+			if (getPropertyNameText(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(property.name);
+	return null;
+}
+function printObjectLiteralProperty(key, value, sourceFile, formatting) {
+	const objectText = printExpression(valueToExpression({ [key]: value }), sourceFile, formatting);
+	const lineSeparator = formatting.newLineKind === ts$1.NewLineKind.CarriageReturnLineFeed ? "\r\n" : "\n";
+	const lines = objectText.split(/\r?\n/);
+	if (lines.length <= 2) return objectText.replace(/^\{\s*/, "").replace(/\s*\}$/, "");
+	return lines.slice(1, -1).join(lineSeparator);
+}
+function wouldDeModularizeRootReplacement(sourceLocations) {
+	return sourceLocations?.states.some((location) => location.kind !== "inline") ?? false;
+}
+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 getScriptKind(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 createSourceFile(document, sourceText) {
+	return ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind(document.fileName));
+}
+function findMachineConfigObjectLiteral(sourceFile) {
+	let found = null;
+	const visit = (node) => {
+		if (found) return;
+		if (ts$1.isCallExpression(node)) {
+			const expression = node.expression;
+			if (ts$1.isIdentifier(expression) && expression.text === "createMachine" || ts$1.isPropertyAccessExpression(expression) && expression.name.text === "createMachine") {
+				const [firstArgument] = node.arguments;
+				const objectLiteral = firstArgument && unwrapObjectLiteralExpression(firstArgument);
+				if (objectLiteral) {
+					found = objectLiteral;
+					return;
+				}
+			}
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+}
+function findSetupObjectLiteral(sourceFile) {
+	let found = null;
+	const visit = (node) => {
+		if (found) return;
+		if (ts$1.isCallExpression(node) && isSetupCallExpression(node)) {
+			const [firstArgument] = node.arguments;
+			if (firstArgument && ts$1.isExpression(firstArgument)) {
+				found = unwrapObjectLiteralExpression(firstArgument);
+				if (found) return;
+			}
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+}
+function findCreateMachineImplementationObjectLiteral(sourceFile) {
+	let found = null;
+	const visit = (node) => {
+		if (found) return;
+		if (ts$1.isCallExpression(node) && isCreateMachineCallExpression(node)) {
+			const secondArgument = node.arguments[1];
+			if (secondArgument && ts$1.isExpression(secondArgument)) {
+				found = unwrapObjectLiteralExpression(secondArgument);
+				if (found) return;
+			}
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+}
+function isCreateMachineCallExpression(node) {
+	const expression = node.expression;
+	return ts$1.isIdentifier(expression) && expression.text === "createMachine" || ts$1.isPropertyAccessExpression(expression) && expression.name.text === "createMachine";
+}
+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) {
+	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 ts$1.isObjectLiteralExpression(current) ? current : null;
+}
+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 = [];
+	for (const patch of patches) {
+		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 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 getMappedRootObjectLiteral(document, sourceFile, sourceLocations) {
+	if (!sourceLocations?.root || !isSourceLocationForDocument(sourceLocations.root.uri, document)) return null;
+	return findObjectLiteralByRange(sourceFile, sourceLocations.root.range);
+}
+async function getMappedStateReplacementTarget(rootDocument, rootSourceFile, sourceLocations, path, openTextDocument) {
+	if (!sourceLocations) return null;
+	const location = sourceLocations.states.find((item) => arePathsEqual(item.path, path));
+	if (!location) return null;
+	const targetDocument = isSourceLocationForDocument(location.uri, rootDocument) ? rootDocument : await openDocumentBySourceUri(location.uri, openTextDocument);
+	if (!targetDocument) return null;
+	const targetSourceFile = isSourceLocationForDocument(location.uri, rootDocument) ? rootSourceFile : createSourceFile(targetDocument, targetDocument.getText());
+	const node = findObjectLiteralByRange(targetSourceFile, location.range);
+	if (!node) return null;
+	return {
+		document: targetDocument,
+		sourceFile: targetSourceFile,
+		node
+	};
+}
+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(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.isObjectLiteralExpression(node) && node.getStart(sourceFile) === start && node.getEnd() === end) {
+			found = node;
+			return;
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+}
+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(property.name) !== propertyName) continue;
+		return unwrapObjectLiteralExpression(property.initializer) ?? null;
+	}
+	return null;
+}
+function getPropertyNameText(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 getDocumentUri(document) {
+	return (typeof document.uri === "string" ? document.uri : document.uri?.toString()) ?? document.fileName;
+}
+async function tryCreateSemanticPatchSplitForDocuments(document, sourceFile, machineConfigNode, patches, prevGraph, nextGraph, sourceLocations, openTextDocument) {
+	const split = getSemanticStateRenamePatchSplit(patches, prevGraph, nextGraph);
+	if (!split) return null;
+	const { rename } = split;
+	const parentTarget = await getStateMembershipParentTargetForDocuments(document, sourceFile, machineConfigNode, sourceLocations, rename.parentPath, openTextDocument);
+	if (!parentTarget) return null;
+	const targetLiterals = await collectMappedTargetStringLiterals(document, sourceFile, machineConfigNode, sourceLocations, openTextDocument);
+	const replacements = createStateKeyRenameReplacementsForTarget(parentTarget.document, parentTarget.sourceFile, parentTarget.node, rename, sourceLocations, targetLiterals);
+	if (!replacements) return null;
+	return {
+		replacements: replacements.sort(compareReplacementRangesDescending),
+		remainingPatches: split.remainingPatches,
+		sourceLocations: createRenamedSourceLocations(sourceLocations, rename)
+	};
+}
+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
+	};
+}
+function getSemanticStateRenamePatchSplit(patches, prevGraph, nextGraph) {
+	let rename = null;
+	const remainingPatches = [];
+	for (const patch of patches) {
+		const patchRename = getSemanticStateRenameFromPatch(patch, prevGraph, nextGraph);
+		if (patchRename) {
+			if (rename) return null;
+			rename = patchRename;
+			continue;
+		}
+		remainingPatches.push(patch);
+	}
+	return rename ? {
+		rename,
+		remainingPatches
+	} : null;
+}
+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)]
+			};
+		})
+	};
+}
+function createStateKeyRenameReplacementsForTarget(document, sourceFile, parentObject, rename, sourceLocations, targetLiterals) {
+	const statesObject = 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(parentObject, "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(parentObject, rename.parentPath).map((path) => path.join("."))]);
+	for (const target of targetLiterals) {
+		if (!referencesRenamedSibling(target.node.text, rename.oldKey)) continue;
+		const sourceKey = target.sourcePath.join(".");
+		if (!(target.sourcePath.length === rename.parentPath.length || arePathsEqual(target.sourcePath.slice(0, -1), rename.parentPath)) || !supportedScope.has(sourceKey)) return null;
+		const replacement = createStringLiteralReplacement(target.document, target.sourceFile, target.node, renameSiblingReference(target.node.text, rename.oldKey, rename.newKey));
+		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 visitStateObject = (stateObject, sourcePath) => {
+		for (const propertyName of [
+			"always",
+			"after",
+			"on",
+			"onDone"
+		]) {
+			const property = getPropertyAssignment(stateObject, propertyName);
+			if (!property) continue;
+			collectTargetStringLiteralsFromExpression(property.initializer, sourcePath, literals);
+		}
+		const statesObject = getObjectLiteralProperty(stateObject, "states");
+		if (!statesObject) return;
+		for (const property of statesObject.properties) {
+			if (!ts$1.isPropertyAssignment(property)) continue;
+			const key = getPropertyNameText(property.name);
+			const childState = unwrapObjectLiteralExpression(property.initializer);
+			if (!key || !childState) continue;
+			visitStateObject(childState, [...sourcePath, key]);
+		}
+	};
+	visitStateObject(machineConfigNode, []);
+	return literals;
+}
+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)));
+	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);
+		for (const target of stateLiterals) {
+			const key = getTargetLiteralReplacementKey(targetDocument, targetSourceFile, target.node);
+			if (seen.has(key)) continue;
+			seen.add(key);
+			literals.push({
+				...target,
+				document: targetDocument,
+				sourceFile: targetSourceFile
+			});
+		}
+	}
+	return literals;
+}
+function getTargetLiteralReplacementKey(document, sourceFile, node) {
+	return `${getDocumentUri(document)}:${node.getStart(sourceFile)}:${node.getEnd()}`;
+}
+function collectTargetStringLiteralsFromStateObject(stateObject, sourcePath, literals) {
+	for (const propertyName of [
+		"always",
+		"after",
+		"on",
+		"onDone"
+	]) {
+		const property = getPropertyAssignment(stateObject, propertyName);
+		if (!property) continue;
+		collectTargetStringLiteralsFromExpression(property.initializer, sourcePath, literals);
+	}
+	const statesObject = getObjectLiteralProperty(stateObject, "states");
+	if (!statesObject) return;
+	for (const property of statesObject.properties) {
+		if (!ts$1.isPropertyAssignment(property)) continue;
+		const key = getPropertyNameText(property.name);
+		const childState = unwrapObjectLiteralExpression(property.initializer);
+		if (!key || !childState) continue;
+		collectTargetStringLiteralsFromStateObject(childState, [...sourcePath, key], literals);
+	}
+}
+function collectTargetStringLiteralsFromExpression(expression, sourcePath, literals) {
+	if (ts$1.isStringLiteralLike(expression)) {
+		literals.push({
+			sourcePath,
+			node: expression
+		});
+		return;
+	}
+	if (ts$1.isArrayLiteralExpression(expression)) {
+		for (const element of expression.elements) if (ts$1.isExpression(element)) collectTargetStringLiteralsFromExpression(element, sourcePath, literals);
+		return;
+	}
+	if (!ts$1.isObjectLiteralExpression(expression)) return;
+	const targetProperty = getPropertyAssignment(expression, "target");
+	if (targetProperty) {
+		collectTargetStringLiteralsFromExpression(targetProperty.initializer, sourcePath, literals);
+		return;
+	}
+	for (const property of expression.properties) {
+		if (!ts$1.isPropertyAssignment(property)) continue;
+		collectTargetStringLiteralsFromExpression(property.initializer, sourcePath, literals);
+	}
+}
+function referencesRenamedSibling(value, oldKey) {
+	return value === oldKey || value.startsWith(`${oldKey}.`);
+}
+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 printExpression(expression, sourceFile, formatting) {
+	return reindentPrintedExpression(ts$1.createPrinter({ newLine: formatting.newLineKind }).printNode(ts$1.EmitHint.Expression, expression, sourceFile), formatting);
+}
+function reindentPrintedExpression(printed, formatting) {
+	const lineSeparator = formatting.newLineKind === ts$1.NewLineKind.CarriageReturnLineFeed ? "\r\n" : "\n";
+	const lines = printed.split(/\r?\n/);
+	if (lines.length <= 1) return printed;
+	return lines.map((line, index) => {
+		if (index === 0) return line;
+		if (line.trim() === "") return "";
+		const leadingSpaces = line.match(/^ */)?.[0].length ?? 0;
+		const indentLevel = Math.floor(leadingSpaces / 4);
+		return `${formatting.baseIndent}${formatting.indentUnit.repeat(indentLevel)}${line.slice(leadingSpaces)}`;
+	}).join(lineSeparator);
+}
+function getFormattingContext(document, sourceFile, node) {
+	const sourceText = sourceFile.text;
+	const lineStart = getLineStartOffset(sourceText, node.getStart(sourceFile));
+	const lineIndent = sourceText.slice(lineStart).match(/^[ \t]*/)?.[0] ?? "";
+	const editorIndentUnit = getEditorIndentUnit(document);
+	const inferredIndentUnit = inferIndentUnitFromNode(sourceText, node, sourceFile, lineIndent) ?? inferIndentUnitFromSource(sourceText);
+	return {
+		baseIndent: lineIndent,
+		indentUnit: editorIndentUnit ?? inferredIndentUnit ?? "    ",
+		newLineKind: sourceText.includes("\r\n") ? ts$1.NewLineKind.CarriageReturnLineFeed : ts$1.NewLineKind.LineFeed
+	};
+}
+function 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 inlineExpression = inlineExpressionDirectiveToExpression(value);
+	if (inlineExpression) return inlineExpression;
+	if (value === null) return ts$1.factory.createNull();
+	if (typeof value === "string") return ts$1.factory.createStringLiteral(value);
+	if (typeof value === "number") {
+		if (value < 0) return ts$1.factory.createPrefixUnaryExpression(ts$1.SyntaxKind.MinusToken, ts$1.factory.createNumericLiteral(Math.abs(value)));
+		return ts$1.factory.createNumericLiteral(value);
+	}
+	if (typeof value === "boolean") return value ? ts$1.factory.createTrue() : ts$1.factory.createFalse();
+	if (Array.isArray(value)) {
+		const existingArray = existingExpression && ts$1.isArrayLiteralExpression(existingExpression) ? existingExpression : void 0;
+		const elements = value.map((item, index) => valueToExpression(item, existingArray && ts$1.isExpression(existingArray.elements[index]) ? existingArray.elements[index] : void 0));
+		if (existingArray) {
+			const updatedArray = ts$1.factory.createArrayLiteralExpression(elements, true);
+			ts$1.setOriginalNode(updatedArray, existingArray);
+			ts$1.setTextRange(updatedArray, existingArray);
+			return updatedArray;
+		}
+		return ts$1.factory.createArrayLiteralExpression(elements, true);
+	}
+	if (isMachineConfig(value)) {
+		const existingObject = existingExpression && ts$1.isObjectLiteralExpression(existingExpression) ? existingExpression : void 0;
+		const properties = Object.entries(value).filter(([, propertyValue]) => propertyValue !== void 0).map(([key, propertyValue]) => {
+			const existingProperty = existingObject ? getPropertyAssignment(existingObject, key) : null;
+			const nextInitializer = getPreservedPropertyInitializer(key, propertyValue, existingProperty?.initializer) ?? valueToExpression(propertyValue, existingProperty?.initializer);
+			if (existingProperty) return ts$1.factory.updatePropertyAssignment(existingProperty, existingProperty.name, nextInitializer);
+			return ts$1.factory.createPropertyAssignment(toPropertyName(key), nextInitializer);
+		});
+		if (existingObject) {
+			const updatedObject = ts$1.factory.createObjectLiteralExpression(properties, true);
+			ts$1.setOriginalNode(updatedObject, existingObject);
+			ts$1.setTextRange(updatedObject, existingObject);
+			return updatedObject;
+		}
+		return ts$1.factory.createObjectLiteralExpression(properties, true);
+	}
+	return ts$1.factory.createIdentifier("undefined");
+}
+function inlineExpressionDirectiveToExpression(value) {
+	if (!isInlineExpressionDirective(value)) return null;
+	return ts$1.factory.createIdentifier(value.expr);
+}
+function isInlineExpressionDirective(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const directive = value;
+	return directive["@type"] === "code" && typeof directive.expr === "string";
+}
+function getPreservedPropertyInitializer(propertyName, nextValue, existingInitializer) {
+	if (propertyName !== "description" || typeof nextValue !== "string" || !existingInitializer) return null;
+	if (ts$1.isStringLiteralLike(existingInitializer)) return existingInitializer.text === nextValue ? existingInitializer : null;
+	return existingInitializer;
+}
+function getPropertyAssignment(objectLiteral, propertyName) {
+	for (const property of objectLiteral.properties) {
+		if (!ts$1.isPropertyAssignment(property)) continue;
+		if (getPropertyNameText(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",
+	parseSourceToMachine(text, document) {
+		return parseSourceToMachine(text, document);
+	},
+	collectSourceLocations(text, document) {
+		return collectXStateSourceLocations(text, document);
+	},
+	async applyMachineToDocument(machineConfig, document, options) {
+		return applyMachineToSourceDocuments(options?.preserveStatelyMetadata === false ? stripStatelyMetadata(machineConfig) : machineConfig, document, options);
+	}
+};
+function createSerializedExportAdapter(format) {
+	return {
+		id: format,
+		format,
+		parseSourceToMachine(text) {
+			return text;
+		},
+		async applyMachineToDocument(_machineConfig, document, options) {
+			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");
+const xgraphAdapter = createSerializedExportAdapter("xgraph");
+const mermaidAdapter = createSerializedExportAdapter("mermaid");
+const aslJsonAdapter = createSerializedExportAdapter("asl-json");
+const aslYamlAdapter = createSerializedExportAdapter("asl-yaml");
+const reduxAdapter = createSerializedExportAdapter("redux");
+const zustandAdapter = createSerializedExportAdapter("zustand");
+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 getSyncAdapter(document, text = "") {
+	const { fileName } = document;
+	const resolvedText = text || document.getText?.() || "";
+	if (isJavaScriptOrTypeScriptFile(fileName)) {
+		if (looksLikeReduxToolkit(resolvedText)) return reduxAdapter;
+		if (looksLikeZustand(resolvedText)) return zustandAdapter;
+		return xstateAdapter;
+	}
+	if (hasAslExtension(fileName) || looksLikeAmazonStatesLanguage(resolvedText)) {
+		if (isYamlFile(fileName)) return aslYamlAdapter;
+		return aslJsonAdapter;
+	}
+	if (isMermaidFile(fileName) || looksLikeMermaid(resolvedText)) return mermaidAdapter;
+	if (isJsonFile(fileName) && looksLikeXGraphJson(resolvedText)) return xgraphAdapter;
+	if (isJsonFile(fileName) && looksLikeXStateJson(resolvedText)) return xstateJsonAdapter;
+	throw new Error(`Unsupported document for Stately sync: ${fileName}`);
+}
+function parseDocumentToMachine(document) {
+	const text = document.getText();
+	const adapter = getSyncAdapter(document, text);
+	return {
+		adapter,
+		format: adapter.format,
+		machine: adapter.parseSourceToMachine(text, document),
+		sourceLocations: adapter.collectSourceLocations?.(text, document)
+	};
+}
+
+//#endregion
+//#region src/sync.ts
+const execFileAsync = promisify(execFile);
+const LOCAL_EXTRACTION_TIMEOUT_MS = 5e3;
+const MAX_CAPTURED_LOCAL_MACHINES = 100;
+function createLocalCapturePlugin() {
+	return {
+		name: "statelyai-xstate-capture",
+		setup(build) {
+			build.onResolve({ filter: /^xstate(?:\/.*)?$/ }, (args) => ({
+				path: args.path,
+				namespace: "statelyai-xstate-capture"
+			}));
+			build.onLoad({
+				filter: /^xstate(?:\/.*)?$/,
+				namespace: "statelyai-xstate-capture"
+			}, async (args) => {
+				const xstateModule = await import(args.path);
+				return {
+					contents: `
+const __xstate = globalThis.__statelyaiXState;
+const __captured = globalThis.__capturedMachines ?? (globalThis.__capturedMachines = []);
+const __maxCaptured = ${MAX_CAPTURED_LOCAL_MACHINES};
+
+function __capture(machine, type) {
+  if (__captured.length >= __maxCaptured || !machine?.config) {
+    return machine;
+  }
+
+  try {
+    __captured.push(JSON.stringify({
+      config: machine.config,
+      _type: type,
+    }));
+  } catch {}
+
+  return machine;
+}
+
+${Object.keys(xstateModule).filter((key) => key !== "createMachine" && key !== "setup").filter((key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)).sort().map((key) => `export const ${key} = __xstate.${key};`).join("\n")}
+export const createMachine = (...args) => __capture(__xstate.createMachine(...args), 'createMachine');
+export const setup = (...args) => {
+  const setupResult = __xstate.setup(...args);
+  return {
+    ...setupResult,
+    createMachine: (...machineArgs) =>
+      __capture(setupResult.createMachine(...machineArgs), 'setup.createMachine'),
+  };
+};
+            `,
+					loader: "js"
+				};
+			});
+		}
+	};
+}
+function getEsbuildLoader(sourcePath) {
+	switch (path.extname(sourcePath).toLowerCase()) {
+		case ".tsx": return "tsx";
+		case ".jsx": return "jsx";
+		case ".js":
+		case ".mjs":
+		case ".cjs": return "js";
+		default: return "ts";
+	}
+}
+async function extractMachinesFromLocalSource(sourcePath, contents) {
+	try {
+		const parsed = parseDocumentToMachine(createTextDocument(sourcePath, contents));
+		if (parsed.format !== "xstate" || typeof parsed.machine !== "string") return {
+			machines: [],
+			error: `Unsupported local source format: ${parsed.format}`
+		};
+		const bundledCode = (await esbuild.build({
+			stdin: {
+				contents: parsed.machine,
+				sourcefile: sourcePath,
+				loader: getEsbuildLoader(sourcePath),
+				resolveDir: path.dirname(sourcePath)
+			},
+			absWorkingDir: path.dirname(sourcePath),
+			bundle: true,
+			write: false,
+			format: "iife",
+			target: "es2020",
+			platform: "neutral",
+			logLevel: "silent",
+			plugins: [createLocalCapturePlugin()]
+		})).outputFiles[0]?.text;
+		if (!bundledCode) return {
+			machines: [],
+			error: "Failed to bundle source for local machine extraction."
+		};
+		const sandbox = {
+			__statelyaiXState: await import("xstate"),
+			__capturedMachines: [],
+			console: {
+				log: () => {},
+				error: () => {},
+				warn: () => {},
+				info: () => {},
+				debug: () => {}
+			},
+			setTimeout: () => 0,
+			clearTimeout: () => {},
+			setInterval: () => 0,
+			clearInterval: () => {},
+			queueMicrotask: () => {}
+		};
+		const context = vm.createContext(sandbox);
+		new vm.Script(bundledCode, { filename: sourcePath }).runInContext(context, { timeout: LOCAL_EXTRACTION_TIMEOUT_MS });
+		const captured = sandbox.__capturedMachines;
+		if (!Array.isArray(captured)) return { machines: [] };
+		return { machines: captured.map((entry) => typeof entry === "string" ? JSON.parse(entry) : entry).filter((entry) => typeof entry === "object" && entry !== null && "config" in entry) };
+	} catch (error) {
+		return {
+			machines: [],
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+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 && attachments.length > 0 ? `Local machine extraction failed: ${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) {
+			const updatedMachine = await client.machines.update({
+				id: attachment.pragma.id,
+				definition: toStudioMachine(fromXStateConfig(extractedMachine.config))
+			});
+			updated.push({
+				machineIndex,
+				machine: updatedMachine
+			});
+			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) {
+	const filePath = path.resolve(options.cwd ?? process.cwd(), locator);
+	const contents = await fs.readFile(filePath, "utf8");
+	const extension = path.extname(filePath).toLowerCase();
+	if (extension === ".ts" || extension === ".tsx" || extension === ".js" || extension === ".jsx") {
+		const config = (await (options.client ?? createStatelyClient({
+			apiKey: options.apiKey,
+			baseUrl: options.baseUrl,
+			fetch: options.fetch
+		})).code.extractMachines(contents)).machines[0]?.config;
+		if (!config) throw new Error(`No machines extracted from ${filePath}`);
+		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 source = graphToXStateTS({
+				...graph,
+				id: resolveLocalXStateMachineId(graph)
+			});
+			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}`);
+		}
+	}
+}
+async function resolveRemoteMachine(machineId, baseUrl, kind, locator, options) {
+	const machineResponse = await (options.client ?? createStatelyClient({
+		apiKey: options.apiKey,
+		baseUrl,
+		fetch: options.fetch
+	})).machines.get(machineId);
+	return {
+		kind,
+		locator,
+		format: "digraph",
+		graph: fromStudioMachine(machineResponse && typeof machineResponse === "object" && "definition" in machineResponse && machineResponse.definition ? machineResponse.definition : machineResponse),
+		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 = getDiff(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;
+	if (await fileExists(outputPath)) try {
+		targetFormat = (await resolveLocalFile(options.target, options)).format;
+	} catch (error) {
+		if (!fallbackFormat) throw error;
+	}
+	if (!targetFormat) throw new Error(`Could not infer a writable target format from ${outputPath}. Use an existing digraph/graph file or a .digraph.json/.graph.json target.`);
+	const serialized = serializeGraph(source.graph, targetFormat, {
+		remoteMachineId: source.remoteMachineId,
+		targetPath: outputPath
+	});
+	await fs.writeFile(outputPath, serialized, "utf8");
+	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) {
+	async function withResolvedProjectVersionId(project, explicitProjectVersionId) {
+		if (project.projectVersionId) return project;
+		if (explicitProjectVersionId) return {
+			...project,
+			projectVersionId: explicitProjectVersionId
+		};
+		const matchedProject = (await client.projects.list()).find((candidate) => {
+			return candidate.projectId === project.projectId || candidate.id != null && project.id != null && candidate.id === project.id;
+		});
+		if (matchedProject?.projectVersionId) return {
+			...project,
+			projectVersionId: matchedProject.projectVersionId
+		};
+		return project;
+	}
+	const explicitProject = options.project;
+	if (explicitProject?.projectVersionId) return withResolvedProjectVersionId(await client.projects.get(explicitProject.projectVersionId), explicitProject.projectVersionId);
+	if (explicitProject?.projectId) return withResolvedProjectVersionId(await client.projects.get(explicitProject.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 withResolvedProjectVersionId(await 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 client.machines.update({
+		id: existingMachineId,
+		definition: toStudioMachine(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 { pushSync as i, pullSync as n, pushLocalMachineLinks as r, planSync as t };