@statelyai/sdk 0.7.0 → 0.8.1

package/dist/sync.mjs

@@ -1,14 +1,772 @@
 import { createStatelyClient } from "./studio.mjs";
-import { d as upsertStatelyPragma, l as findStatelyPragmaAttachments, t as graphToXStateTS, u as getStatelyPragma } from "./graphToXStateTS-Gzh0ZqbN.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);
@@ -197,7 +955,7 @@ async function pushLocalMachineLinks(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 client.code.extractMachines(contents);
+	const extracted = await extractMachinesFromLocalSource(sourcePath, contents);
 	if (attachments.length === 0 || extracted.machines.length === 0) return {
 		sourcePath,
 		project,
@@ -205,7 +963,7 @@ async function pushLocalMachineLinks(options) {
 		updated: [],
 		skipped: [{
 			machineIndex: 0,
-			reason: "No local machines were discovered in this file."
+			reason: extracted.error != null ? formatLocalMachineExtractionIssue(extracted.error) : "No local machines were discovered in this file."
 		}]
 	};
 	if (attachments.length !== extracted.machines.length) return {
@@ -315,12 +1073,21 @@ function inferWritableTargetFormat(filePath) {
 	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);
+			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 } : {});
 		}
@@ -330,16 +1097,21 @@ function serializeGraph(graph, format, options = {}) {
 		}
 	}
 }
+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(await (options.client ?? createStatelyClient({
-			apiKey: options.apiKey,
-			baseUrl,
-			fetch: options.fetch
-		})).machines.get(machineId)),
+		graph: fromStudioMachine(machineResponse && typeof machineResponse === "object" && "definition" in machineResponse && machineResponse.definition ? machineResponse.definition : machineResponse),
 		remoteMachineId: machineId
 	};
 }
@@ -408,9 +1180,24 @@ function inferDefaultProjectName(sourcePath, repo) {
 	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 client.projects.get(explicitProject.projectVersionId);
-	if (explicitProject?.projectId) return client.projects.get(explicitProject.projectId);
+	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),
@@ -419,7 +1206,7 @@ async function resolvePushProject(client, sourcePath, options) {
 		...explicitProject?.keywords ? { keywords: explicitProject.keywords } : {},
 		...inferredRepo ? { repo: inferredRepo } : {}
 	};
-	return client.projects.ensure(projectInput);
+	return withResolvedProjectVersionId(await client.projects.ensure(projectInput));
 }
 async function pushSync(options) {
 	const client = options.client ?? createStatelyClient({