@statelyai/sdk 0.7.1 → 0.8.1

package/dist/sync.mjs

@@ -1,5 +1,1256 @@
-import "./studio.mjs";
-import "./graphToXStateTS-Gzh0ZqbN.mjs";
-import { i as pushSync, n as pullSync, r as pushLocalMachineLinks, t as planSync } from "./sync-DLkTmSyA.mjs";
+import { createStatelyClient } from "./studio.mjs";
+import { d as upsertStatelyPragma, l as findStatelyPragmaAttachments, t as graphToXStateTS, u as getStatelyPragma } from "./graphToXStateTS-moihsH_U.mjs";
+import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
+import * as ts$1 from "typescript";
+import ts 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 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 sourceUriToFileName(uriOrPath) {
+	if (uriOrPath.startsWith("file://")) return fileURLToPath(uriOrPath);
+	if (/^[a-z][a-z\d+.-]*:/i.test(uriOrPath)) throw new Error(`Unsupported non-file URI: ${uriOrPath}`);
+	return path$1.resolve(uriOrPath);
+}
+function fileNameToUri(fileName) {
+	return pathToFileURL(path$1.resolve(fileName)).toString();
+}
+function createFileSourceDocumentResolver() {
+	return {
+		read(uri) {
+			return readFileSnapshot(sourceUriToFileName(uri));
+		},
+		resolveImport(fromDocument, specifier) {
+			const importedFileName = resolveImportPath(fromDocument.fileName, specifier);
+			return importedFileName ? readFileSnapshot(importedFileName) : null;
+		}
+	};
+}
+function resolveImportPath(fromFileName, specifier) {
+	if (!specifier.startsWith(".")) return null;
+	const basePath = path$1.resolve(path$1.dirname(fromFileName), specifier);
+	return [
+		basePath,
+		`${basePath}.ts`,
+		`${basePath}.tsx`,
+		`${basePath}.js`,
+		`${basePath}.jsx`,
+		path$1.join(basePath, "index.ts"),
+		path$1.join(basePath, "index.tsx"),
+		path$1.join(basePath, "index.js"),
+		path$1.join(basePath, "index.jsx")
+	].find((candidate) => isReadableFile(candidate)) ?? null;
+}
+function isReadableFile(fileName) {
+	try {
+		return fs$1.statSync(fileName).isFile();
+	} catch {
+		return false;
+	}
+}
+function readFileSnapshot(fileName) {
+	try {
+		return {
+			fileName,
+			uri: fileNameToUri(fileName),
+			text: fs$1.readFileSync(fileName, "utf8")
+		};
+	} catch {
+		return null;
+	}
+}
+function getLineStarts(text) {
+	const lineStarts = [0];
+	for (let index = 0; index < text.length; index += 1) if (text.charCodeAt(index) === 10) lineStarts.push(index + 1);
+	return lineStarts;
+}
+
+//#endregion
+//#region ../editor-sync/src/internal/sourceLocations.ts
+const sourceFileUris = /* @__PURE__ */ new WeakMap();
+function collectXStateSourceLocations(sourceText, document, options = {}) {
+	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$1(document.fileName));
+	const uri = document.uri?.toString() ?? document.fileName;
+	sourceFileUris.set(sourceFile, uri);
+	const bindings = collectBindings(sourceFile, uri, document.fileName, options);
+	const staticValues = collectStaticValueBindings(sourceFile);
+	const root = findMachineConfigObjectLiteral(sourceFile, bindings);
+	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, options) {
+	const bindings = collectTopLevelBindings(sourceFile, uri);
+	addImportedBindings(bindings, sourceFile, uri, fileName, options);
+	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(declaration.initializer);
+			if (objectLiteral) {
+				bindings.set(declaration.name.text, {
+					kind: "objectReference",
+					node: objectLiteral,
+					sourceFile,
+					uri,
+					bindings
+				});
+				continue;
+			}
+			const stateConfig = unwrapCreateConfigArgument(declaration.initializer);
+			if (stateConfig) bindings.set(declaration.name.text, {
+				kind: "createStateConfig",
+				node: stateConfig,
+				sourceFile,
+				uri,
+				bindings
+			});
+		}
+	}
+	return bindings;
+}
+function addImportedBindings(bindings, sourceFile, uri, fileName, options) {
+	const resolver = options.resolver;
+	if (!resolver) return;
+	for (const statement of sourceFile.statements) {
+		if (!ts$1.isImportDeclaration(statement) || !ts$1.isStringLiteral(statement.moduleSpecifier)) continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (!namedBindings || !ts$1.isNamedImports(namedBindings)) continue;
+		const importedDocument = resolver.resolveImport({
+			fileName,
+			uri
+		}, statement.moduleSpecifier.text);
+		if (!importedDocument) continue;
+		const importedSourceFile = ts$1.createSourceFile(importedDocument.fileName, importedDocument.text, ts$1.ScriptTarget.Latest, true, getScriptKind$1(importedDocument.fileName));
+		sourceFileUris.set(importedSourceFile, importedDocument.uri);
+		const importedBindings = collectBindings(importedSourceFile, importedDocument.uri, importedDocument.fileName, options);
+		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(sourceFile, bindings) {
+	let found = null;
+	const visit = (node) => {
+		if (found) return;
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1(node.expression)) {
+			const [firstArgument] = node.arguments;
+			if (!firstArgument || !ts$1.isExpression(firstArgument)) return;
+			found = unwrapObjectLiteralExpression(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(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(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 getSourceFileUri(sourceFile) {
+	return sourceFileUris.get(sourceFile) ?? sourceFile.fileName;
+}
+function unwrapCreateConfigArgument(expression) {
+	const unwrapped = unwrapExpression$1(expression);
+	if (!ts$1.isCallExpression(unwrapped)) return null;
+	const callee = unwrapped.expression;
+	if (!ts$1.isPropertyAccessExpression(callee) || !isSetupCreateConfigName(callee.name.text)) return null;
+	const [firstArgument] = unwrapped.arguments;
+	if (!firstArgument || !ts$1.isExpression(firstArgument)) return null;
+	return unwrapObjectLiteralExpression(firstArgument);
+}
+function isSetupCreateConfigName(name) {
+	return /^create[A-Z_$][\w$]*Config$/.test(name);
+}
+function resolveIdentifierObject(expression, bindings) {
+	const unwrapped = unwrapExpression$1(expression);
+	if (!ts$1.isIdentifier(unwrapped)) return null;
+	const binding = bindings.get(unwrapped.text);
+	return binding?.kind === "objectReference" ? binding.node : null;
+}
+function getObjectLiteralProperty(objectLiteral, propertyName) {
+	for (const property of objectLiteral.properties) {
+		if (!ts$1.isPropertyAssignment(property)) continue;
+		if (getPropertyNameText$1(property.name) !== propertyName) continue;
+		return unwrapObjectLiteralExpression(property.initializer);
+	}
+	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$1(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$1(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$1(expression) {
+	return ts$1.isIdentifier(expression) && expression.text === "createMachine" || ts$1.isPropertyAccessExpression(expression) && expression.name.text === "createMachine";
+}
+function unwrapObjectLiteralExpression(expression) {
+	const unwrapped = unwrapExpression$1(expression);
+	return ts$1.isObjectLiteralExpression(unwrapped) ? unwrapped : null;
+}
+function unwrapExpression$1(expression) {
+	let current = expression;
+	for (;;) {
+		if (ts$1.isParenthesizedExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts$1.isAsExpression(current) || ts$1.isSatisfiesExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts$1.isTypeAssertionExpression(current) || 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, options = {}) {
+	const sourceLocations = collectXStateSourceLocations(text, document, options);
+	if (!sourceLocations) return text;
+	const staticValueReplacements = (sourceLocations.staticValues ?? []).map((location) => ({
+		range: location.range,
+		newText: JSON.stringify(location.value)
+	}));
+	const stateReplacements = sourceLocations.states.filter((location) => location.path.length === 1 && location.keyRange).flatMap((location) => {
+		const keyRange = location.keyRange;
+		const keyReplacement = location.keyReplacementText ? [{
+			range: keyRange,
+			newText: location.keyReplacementText
+		}] : [];
+		const stateText = readSourceRange(location.uri, location.range, options.resolver);
+		if (!stateText) return keyReplacement;
+		if (location.referenceRange && !areSourceRangesEqual(location.referenceRange, keyRange)) return [...keyReplacement, {
+			range: location.referenceRange,
+			newText: stateText
+		}];
+		if (!canHydrateShorthandState(text, keyRange)) return keyReplacement;
+		return [...keyReplacement, {
+			range: keyRange,
+			newText: `${location.path[0]}: ${stateText}`
+		}];
+	});
+	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(text, range.endLine, range.endChar);
+	return text.slice(end).match(/\S/)?.[0] !== ":";
+}
+function readSourceRange(uri, range, resolver) {
+	if (!resolver) return null;
+	const document = resolver.read(uri);
+	if (!document) return null;
+	const start = offsetAtRangePosition(document.text, range.startLine, range.startChar);
+	const end = offsetAtRangePosition(document.text, range.endLine, range.endChar);
+	return document.text.slice(start, end);
+}
+function applySourceRangeReplacements(text, replacements) {
+	let updated = text;
+	for (const replacement of replacements) {
+		const start = offsetAtRangePosition(updated, replacement.range.startLine, replacement.range.startChar);
+		const end = offsetAtRangePosition(updated, replacement.range.endLine, replacement.range.endChar);
+		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(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 src/sync.ts
+const execFileAsync = promisify(execFile);
+const MAX_CAPTURED_LOCAL_MACHINES = 100;
+async function extractMachinesFromLocalSource(sourcePath, contents) {
+	try {
+		return { machines: extractMachineConfigsFromAst(sourcePath, parseSourceToMachine(contents, createTextDocument(sourcePath, contents), { resolver: createFileSourceDocumentResolver() })) };
+	} catch (error) {
+		return {
+			machines: [],
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+function isInvalidLocalMachineDefinitionError(message) {
+	return /No initial state specified for compound state node/.test(message) || /Try adding \{\s*initial:\s*['"`]/.test(message);
+}
+function formatLocalMachineExtractionIssue(message) {
+	if (isInvalidLocalMachineDefinitionError(message)) return `Invalid local machine definition: ${message}`;
+	return `Could not extract a local machine from this file: ${message}`;
+}
+function extractMachineConfigsFromAst(fileName, sourceText) {
+	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(fileName));
+	const bindings = collectLocalBindings(sourceFile);
+	const machines = [];
+	const visit = (node) => {
+		if (machines.length >= MAX_CAPTURED_LOCAL_MACHINES) return;
+		if (!ts.isCallExpression(node) || !isCreateMachineExpression(node.expression)) {
+			ts.forEachChild(node, visit);
+			return;
+		}
+		const [firstArgument] = node.arguments;
+		if (!firstArgument || !ts.isExpression(firstArgument)) return;
+		const config = evaluateExpression(firstArgument, sourceFile, bindings, /* @__PURE__ */ new Set());
+		if (!config || typeof config !== "object" || Array.isArray(config)) return;
+		machines.push({
+			config,
+			_type: ts.isPropertyAccessExpression(unwrapExpression(node.expression)) ? "setup.createMachine" : "createMachine"
+		});
+	};
+	ts.forEachChild(sourceFile, visit);
+	return machines;
+}
+function collectLocalBindings(sourceFile) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts.isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) {
+				if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+				bindings.set(declaration.name.text, {
+					kind: "value",
+					expression: declaration.initializer
+				});
+			}
+			continue;
+		}
+		if (!ts.isEnumDeclaration(statement)) continue;
+		let nextNumericValue = 0;
+		for (const member of statement.members) {
+			const memberName = getPropertyNameText(member.name);
+			if (!memberName) continue;
+			const symbol = `${statement.name.text}.${memberName}`;
+			if (!member.initializer) {
+				bindings.set(symbol, {
+					kind: "enumMember",
+					value: nextNumericValue
+				});
+				nextNumericValue += 1;
+				continue;
+			}
+			const value = evaluateExpression(member.initializer, sourceFile, bindings, /* @__PURE__ */ new Set());
+			if (typeof value === "string" || typeof value === "number") {
+				bindings.set(symbol, {
+					kind: "enumMember",
+					value
+				});
+				if (typeof value === "number") nextNumericValue = value + 1;
+			}
+		}
+	}
+	return bindings;
+}
+function evaluateExpression(expression, sourceFile, bindings, seenBindings) {
+	const unwrapped = unwrapExpression(expression);
+	if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped)) return unwrapped.text;
+	if (ts.isNumericLiteral(unwrapped)) return Number(unwrapped.text);
+	if (unwrapped.kind === ts.SyntaxKind.TrueKeyword) return true;
+	if (unwrapped.kind === ts.SyntaxKind.FalseKeyword) return false;
+	if (unwrapped.kind === ts.SyntaxKind.NullKeyword) return null;
+	if (ts.isIdentifier(unwrapped)) {
+		if (unwrapped.text === "undefined") return;
+		const binding = bindings.get(unwrapped.text);
+		if (!binding || binding.kind !== "value" || seenBindings.has(unwrapped.text)) return unwrapped.getText(sourceFile);
+		const nextSeen = new Set(seenBindings);
+		nextSeen.add(unwrapped.text);
+		return evaluateExpression(binding.expression, sourceFile, bindings, nextSeen);
+	}
+	if (ts.isPropertyAccessExpression(unwrapped) && ts.isIdentifier(unwrapped.expression)) {
+		const binding = bindings.get(`${unwrapped.expression.text}.${unwrapped.name.text}`);
+		if (binding?.kind === "enumMember") return binding.value;
+		return unwrapped.getText(sourceFile);
+	}
+	if (ts.isArrayLiteralExpression(unwrapped)) return unwrapped.elements.map((element) => ts.isSpreadElement(element) ? evaluateExpression(element.expression, sourceFile, bindings, seenBindings) : evaluateExpression(element, sourceFile, bindings, seenBindings));
+	if (ts.isObjectLiteralExpression(unwrapped)) {
+		const result = {};
+		for (const property of unwrapped.properties) {
+			if (ts.isSpreadAssignment(property)) {
+				const spreadValue = evaluateExpression(property.expression, sourceFile, bindings, seenBindings);
+				if (spreadValue && typeof spreadValue === "object" && !Array.isArray(spreadValue)) Object.assign(result, spreadValue);
+				continue;
+			}
+			if (ts.isShorthandPropertyAssignment(property)) {
+				result[property.name.text] = evaluateExpression(property.name, sourceFile, bindings, seenBindings);
+				continue;
+			}
+			if (!ts.isPropertyAssignment(property)) continue;
+			const key = resolvePropertyNameValue(property.name, sourceFile, bindings, seenBindings);
+			if (key == null) continue;
+			result[String(key)] = evaluateExpression(property.initializer, sourceFile, bindings, seenBindings);
+		}
+		return result;
+	}
+	if (ts.isPrefixUnaryExpression(unwrapped)) {
+		const operand = evaluateExpression(unwrapped.operand, sourceFile, bindings, seenBindings);
+		if (typeof operand !== "number") return unwrapped.getText(sourceFile);
+		switch (unwrapped.operator) {
+			case ts.SyntaxKind.MinusToken: return -operand;
+			case ts.SyntaxKind.PlusToken: return operand;
+			default: return unwrapped.getText(sourceFile);
+		}
+	}
+	if (ts.isTemplateExpression(unwrapped)) {
+		let value = unwrapped.head.text;
+		for (const span of unwrapped.templateSpans) {
+			const expressionValue = evaluateExpression(span.expression, sourceFile, bindings, seenBindings);
+			value += String(expressionValue ?? "");
+			value += span.literal.text;
+		}
+		return value;
+	}
+	return unwrapped.getText(sourceFile);
+}
+function resolvePropertyNameValue(name, sourceFile, bindings, seenBindings) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+	if (!ts.isComputedPropertyName(name)) return null;
+	const value = evaluateExpression(name.expression, sourceFile, bindings, seenBindings);
+	if (typeof value === "string" || typeof value === "number") return value;
+	return name.getText(sourceFile);
+}
+function isCreateMachineExpression(expression) {
+	const unwrapped = unwrapExpression(expression);
+	return ts.isIdentifier(unwrapped) && unwrapped.text === "createMachine" || ts.isPropertyAccessExpression(unwrapped) && unwrapped.name.text === "createMachine";
+}
+function unwrapExpression(expression) {
+	let current = expression;
+	for (;;) {
+		if (ts.isParenthesizedExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts.isAsExpression(current) || ts.isSatisfiesExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts.isTypeAssertionExpression(current) || ts.isNonNullExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		return current;
+	}
+}
+function getPropertyNameText(name) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+	return null;
+}
+function getScriptKind(fileName) {
+	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (fileName.endsWith(".js")) return ts.ScriptKind.JS;
+	return ts.ScriptKind.TS;
+}
+function isUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+async function fileExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function parseGitHubRemote(remoteUrl) {
+	const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+	if (httpsMatch) {
+		const [, owner, repo] = httpsMatch;
+		if (!owner || !repo) return null;
+		return {
+			url: `https://github.com/${owner}/${repo}`,
+			owner,
+			repo
+		};
+	}
+	const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
+	if (sshMatch) {
+		const [, owner, repo] = sshMatch;
+		if (!owner || !repo) return null;
+		return {
+			url: `https://github.com/${owner}/${repo}`,
+			owner,
+			repo
+		};
+	}
+	return null;
+}
+async function inferConnectedRepo(filePath, cwd) {
+	const workingDir = cwd ?? path.dirname(filePath);
+	try {
+		const [{ stdout: repoRootStdout }, { stdout: remoteStdout }, { stdout: branchStdout }, { stdout: treeShaStdout }] = await Promise.all([
+			execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd: workingDir }),
+			execFileAsync("git", [
+				"remote",
+				"get-url",
+				"origin"
+			], { cwd: workingDir }),
+			execFileAsync("git", ["branch", "--show-current"], { cwd: workingDir }),
+			execFileAsync("git", ["rev-parse", "HEAD"], { cwd: workingDir })
+		]);
+		const repoRoot = repoRootStdout.trim();
+		const remote = parseGitHubRemote(remoteStdout.trim());
+		const branch = branchStdout.trim();
+		const treeSha = treeShaStdout.trim();
+		if (!remote || !branch || !treeSha) return;
+		const relativePath = path.relative(repoRoot, filePath).replace(/\\/g, "/");
+		const relativeDir = path.dirname(relativePath).replace(/\\/g, "/");
+		const selectedPaths = relativePath && relativePath !== "." ? [relativePath] : [];
+		return {
+			...remote,
+			branch,
+			treeSha,
+			autoSync: false,
+			pathForNewFiles: relativeDir && relativeDir !== "." ? relativeDir : "src/stately-studio",
+			selectedPaths
+		};
+	} catch {
+		return;
+	}
+}
+function normalizeActions(value) {
+	if (value == null) return [];
+	return (Array.isArray(value) ? value : [value]).map((item) => {
+		if (typeof item === "string") return { type: item };
+		if (typeof item === "object" && item !== null && "type" in item) {
+			const type = item.type;
+			const params = "params" in item && typeof item.params === "object" && item.params ? item.params : void 0;
+			return {
+				type,
+				...params ? { params } : {}
+			};
+		}
+		return { type: String(item) };
+	});
+}
+function normalizeTags(value) {
+	if (!value) return [];
+	if (Array.isArray(value)) return value.map((tag) => String(tag));
+	return [String(value)];
+}
+function normalizeInvoke(value) {
+	if (!value) return [];
+	return (Array.isArray(value) ? value : [value]).map((invoke, index) => ({
+		src: invoke.src,
+		id: invoke.id ?? `invoke[${index}]`,
+		...invoke.input ? { input: invoke.input } : {}
+	}));
+}
+function resolveTargetId(sourceParentPath, target) {
+	if (!target) return;
+	if (target.startsWith("#")) {
+		const stripped = target.slice(1);
+		const machineIndex = stripped.indexOf(".");
+		if (machineIndex >= 0) return `(machine).${stripped.slice(machineIndex + 1)}`;
+		return `(machine).${stripped}`;
+	}
+	if (target.startsWith("(machine)")) return target;
+	if (target.includes(".")) return `(machine).${target}`;
+	return `${sourceParentPath}.${target}`;
+}
+function appendTransitionEdges(edges, sourceId, sourceParentPath, eventType, transition, edgeCounts) {
+	const transitions = Array.isArray(transition) ? transition : [transition];
+	for (const item of transitions) {
+		const normalized = typeof item === "string" ? { target: item } : item;
+		const targetId = resolveTargetId(sourceParentPath, Array.isArray(normalized.target) ? normalized.target[0] : normalized.target);
+		const groupKey = `${sourceId}:${eventType}`;
+		const index = edgeCounts.get(groupKey) ?? 0;
+		edgeCounts.set(groupKey, index + 1);
+		edges.push({
+			type: "edge",
+			id: `${sourceId}#${eventType}[${index}]`,
+			sourceId,
+			targetId: targetId ?? sourceId,
+			label: eventType,
+			data: {
+				eventType,
+				transitionType: normalized.reenter === true ? "reenter" : normalized.internal === true || !targetId ? "targetless" : "normal",
+				...normalized.guard ? { guard: typeof normalized.guard === "string" ? { type: normalized.guard } : {
+					type: normalized.guard.type,
+					...normalized.guard.params ? { params: normalized.guard.params } : {}
+				} } : {},
+				actions: normalizeActions(normalized.actions),
+				...normalized.description ? { description: normalized.description } : {}
+			}
+		});
+	}
+}
+function fromXStateConfig(config) {
+	const nodes = [];
+	const edges = [];
+	const edgeCounts = /* @__PURE__ */ new Map();
+	function visitNode(key, nodeConfig, parentId, parentPath) {
+		const nodeId = parentPath ? `${parentPath}.${key}` : "(machine)";
+		const currentPath = parentPath ? nodeId : "(machine)";
+		const initialId = nodeConfig.initial ? `${currentPath}.${nodeConfig.initial}` : void 0;
+		nodes.push({
+			type: "node",
+			id: nodeId,
+			parentId,
+			label: key,
+			...initialId ? { initialNodeId: initialId } : {},
+			data: {
+				key,
+				...nodeConfig.type ? { type: nodeConfig.type } : {},
+				...nodeConfig.history ? { history: nodeConfig.history } : {},
+				...initialId ? { initialId } : {},
+				entry: normalizeActions(nodeConfig.entry),
+				exit: normalizeActions(nodeConfig.exit),
+				invokes: normalizeInvoke(nodeConfig.invoke),
+				tags: normalizeTags(nodeConfig.tags),
+				...nodeConfig.description ? { description: nodeConfig.description } : {}
+			}
+		});
+		for (const [eventType, transition] of Object.entries(nodeConfig.on ?? {})) appendTransitionEdges(edges, nodeId, parentPath ?? "(machine)", eventType, transition, edgeCounts);
+		if (nodeConfig.always) appendTransitionEdges(edges, nodeId, parentPath ?? "(machine)", "", nodeConfig.always, edgeCounts);
+		for (const [childKey, childConfig] of Object.entries(nodeConfig.states ?? {})) visitNode(childKey, childConfig, nodeId, currentPath);
+	}
+	visitNode("(machine)", config, null, null);
+	return {
+		id: config.id ?? "machine",
+		nodes,
+		edges,
+		data: {}
+	};
+}
+async function pushLocalMachineLinks(options) {
+	const client = options.client ?? createStatelyClient({
+		apiKey: options.apiKey,
+		baseUrl: options.baseUrl,
+		fetch: options.fetch
+	});
+	const sourcePath = path.resolve(options.cwd ?? process.cwd(), options.source);
+	const project = await resolvePushProject(client, sourcePath, options);
+	if (!project.projectVersionId) throw new Error("Resolved project is missing projectVersionId.");
+	const contents = await fs.readFile(sourcePath, "utf8");
+	const attachments = findStatelyPragmaAttachments(contents, sourcePath);
+	const extracted = await extractMachinesFromLocalSource(sourcePath, contents);
+	if (attachments.length === 0 || extracted.machines.length === 0) return {
+		sourcePath,
+		project,
+		created: [],
+		updated: [],
+		skipped: [{
+			machineIndex: 0,
+			reason: extracted.error != null ? formatLocalMachineExtractionIssue(extracted.error) : "No local machines were discovered in this file."
+		}]
+	};
+	if (attachments.length !== extracted.machines.length) return {
+		sourcePath,
+		project,
+		created: [],
+		updated: [],
+		skipped: [{
+			machineIndex: 0,
+			reason: "The local machine extractor did not align with the source attachments for this file."
+		}]
+	};
+	let nextContents = contents;
+	let outputPath;
+	const created = [];
+	const updated = [];
+	const skipped = [];
+	for (const [machineIndex, attachment] of attachments.entries()) {
+		const extractedMachine = extracted.machines[machineIndex];
+		if (!extractedMachine?.config) {
+			skipped.push({
+				machineIndex,
+				reason: "No extracted machine config was available for this source."
+			});
+			continue;
+		}
+		if (attachment.pragma?.id) {
+			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 targetLanguage = inferXStateTargetLanguage(options.targetPath);
+			const source = graphToXStateTS({
+				...graph,
+				id: resolveLocalXStateMachineId(graph)
+			}, { targetLanguage });
+			if (!options.remoteMachineId) return source;
+			return upsertStatelyPragma(source, options.remoteMachineId, options.targetPath ? { fileName: options.targetPath } : {});
+		}
+		default: {
+			const exhaustive = format;
+			throw new Error(`Unsupported sync output format: ${exhaustive}`);
+		}
+	}
+}
+function inferXStateTargetLanguage(targetPath) {
+	if (!targetPath) return "typescript";
+	return /\.(?:c|m)?jsx?$/i.test(targetPath) ? "javascript" : "typescript";
+}
+async function resolveRemoteMachine(machineId, baseUrl, kind, locator, options) {
+	const 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 { planSync, pullSync, pushLocalMachineLinks, pushSync };