@statelyai/sdk 0.14.1 → 0.15.0

package/dist/studio.d.mts

@@ -1,125 +1,2 @@
-import { n as StatelyCredential, t as StatelyAuthMode } from "./auth-DmPZiERd.mjs";
-
-//#region src/studio.d.ts
-interface StudioClientOptions {
-  baseUrl?: string;
-  credential?: StatelyCredential;
-  /** @deprecated Use credential: { type: 'api_key', token }. */
-  apiKey?: string;
-  authMode?: StatelyAuthMode;
-  fetch?: typeof fetch;
-}
-interface VerifyApiKeyResponse {
-  valid: boolean;
-}
-type ProjectVisibility = 'Public' | 'Private' | 'Unlisted';
-type RepoType = 'GITHUB';
-interface ConnectedRepo {
-  id?: string;
-  type?: RepoType;
-  url: string;
-  owner: string;
-  repo: string;
-  branch: string;
-  treeSha: string;
-  autoSync?: boolean;
-  pathForNewFiles?: string;
-  selectedPaths?: string[];
-  lastSyncedAt?: string;
-}
-interface ProjectMachine {
-  machineId: string;
-  name: string;
-}
-interface ProjectData {
-  projectId: string;
-  machines: ProjectMachine[];
-  id?: string;
-  name?: string;
-  description?: string | null;
-  keywords?: string[];
-  visibility?: ProjectVisibility;
-  projectVersionId?: string;
-  connectedRepo?: ConnectedRepo | null;
-}
-interface ExtractedMachine {
-  id?: string;
-  config: Record<string, unknown>;
-  setupConfig?: Record<string, unknown>;
-  implementations?: Record<string, unknown>;
-  _type: 'setup.createMachine' | 'createMachine';
-}
-interface ExtractMachinesResponse {
-  machines: ExtractedMachine[];
-  error?: string;
-}
-interface GetMachineOptions {
-  version?: string;
-}
-interface CreateProjectInput {
-  name: string;
-  visibility: ProjectVisibility;
-  description?: string;
-  keywords?: string[];
-  repo?: ConnectedRepo;
-}
-interface EnsureProjectInput extends CreateProjectInput {
-  matchConnectedRepo?: boolean;
-}
-type XStateVersion = 4 | 5;
-type CreateMachineTemplate = 'blank' | 'starter';
-interface CreateMachineFromDefinitionInput<TDefinition = Record<string, unknown>> {
-  projectVersionId: string;
-  definition: TDefinition;
-  xstateVersion?: XStateVersion;
-}
-interface CreateMachineFromTemplateInput {
-  projectVersionId: string;
-  name: string;
-  template: CreateMachineTemplate;
-  xstateVersion?: XStateVersion;
-}
-type CreateMachineInput<TDefinition = Record<string, unknown>> = CreateMachineFromDefinitionInput<TDefinition> | CreateMachineFromTemplateInput;
-interface UpdateMachineInput<TDefinition = Record<string, unknown>> {
-  id: string;
-  name?: string;
-  definition?: TDefinition;
-}
-interface StudioMachineRecord<TDefinition = Record<string, unknown>> {
-  id: string;
-  name: string;
-  definition: TDefinition;
-  projectVersionId?: string;
-  [key: string]: unknown;
-}
-declare class StudioApiError extends Error {
-  readonly status: number;
-  constructor(message: string, status: number);
-}
-interface StudioClient {
-  auth: {
-    verify(credential?: StatelyCredential | string): Promise<VerifyApiKeyResponse>;
-  };
-  projects: {
-    list(): Promise<ProjectData[]>;
-    create(input: CreateProjectInput): Promise<ProjectData>;
-    ensure(input: EnsureProjectInput): Promise<ProjectData>;
-    get(projectId: string): Promise<ProjectData>;
-  };
-  machines: {
-    create<TMachine = Record<string, unknown>>(input: CreateMachineInput<TMachine>): Promise<StudioMachineRecord<TMachine>>;
-    createMany<TMachine = Record<string, unknown>>(input: CreateMachineInput<TMachine>): Promise<Array<StudioMachineRecord<TMachine>>>;
-    update<TMachine = Record<string, unknown>>(input: UpdateMachineInput<TMachine>): Promise<StudioMachineRecord<TMachine>>;
-    get<TMachine = Record<string, unknown>>(machineId: string, options?: GetMachineOptions): Promise<TMachine>;
-  };
-  code: {
-    extractMachines(code: string, options?: {
-      credential?: StatelyCredential | null; /** @deprecated Use credential. */
-      apiKey?: string | null;
-      authMode?: StatelyAuthMode;
-    }): Promise<ExtractMachinesResponse>;
-  };
-}
-declare function createStatelyClient(options?: StudioClientOptions): StudioClient;
-//#endregion
-export { ConnectedRepo, CreateMachineFromDefinitionInput, CreateMachineFromTemplateInput, CreateMachineInput, CreateMachineTemplate, CreateProjectInput, EnsureProjectInput, ExtractMachinesResponse, ExtractedMachine, GetMachineOptions, ProjectData, ProjectMachine, ProjectVisibility, RepoType, StudioApiError, StudioClient, StudioClientOptions, StudioMachineRecord, UpdateMachineInput, VerifyApiKeyResponse, XStateVersion, createStatelyClient };
+import { A as Machine, C as StudioMachineRecord, D as VerifyApiKeyResponse, E as UpdateProjectInput, F as ProjectVisibility, I as VerifyResult, L as XStateVersion, M as Project, N as ProjectMachineSummary, O as createStatelyClient, P as ProjectSummary, R as ResourceErrorCode, S as StudioClientOptions, T as UpdateMachineInput, _ as ProjectMachine, a as CreateMachineTemplate, b as StudioApiErrorOptions, c as EnsureProjectInput, d as ExtractedMachine, f as GetMachineOptions, g as ProjectData, h as LegacyUpdateMachineInput, i as CreateMachineInput, j as MachineVersion, k as ExtractedMachines, l as ExtractMachinesInput, m as LegacyProjectVisibility, n as CreateMachineFromDefinitionInput, o as CreateProjectInput, p as LegacyExtractMachinesOptions, r as CreateMachineFromTemplateInput, s as DEFAULT_STATELY_BASE_URL, t as ConnectedRepo, u as ExtractMachinesResponse, v as RepoType, w as StudioRequestOptions, x as StudioClient, y as StudioApiError } from "./studio-Da5pyxv6.mjs";
+export { ConnectedRepo, CreateMachineFromDefinitionInput, CreateMachineFromTemplateInput, CreateMachineInput, CreateMachineTemplate, CreateProjectInput, DEFAULT_STATELY_BASE_URL, EnsureProjectInput, ExtractMachinesInput, ExtractMachinesResponse, ExtractedMachine, ExtractedMachines, GetMachineOptions, LegacyExtractMachinesOptions, LegacyProjectVisibility, LegacyUpdateMachineInput, Machine, MachineVersion, Project, ProjectData, ProjectMachine, ProjectMachineSummary, ProjectSummary, ProjectVisibility, RepoType, ResourceErrorCode, StudioApiError, StudioApiErrorOptions, StudioClient, StudioClientOptions, StudioMachineRecord, StudioRequestOptions, UpdateMachineInput, UpdateProjectInput, VerifyApiKeyResponse, VerifyResult, XStateVersion, createStatelyClient };

package/dist/studio.mjs

@@ -1,172 +1,3 @@
-import { createAuthorizationHeader, getCredentialToken } from "./auth.mjs";
+import { n as StudioApiError, r as createStatelyClient, t as DEFAULT_STATELY_BASE_URL } from "./studio-txdyJHD7.mjs";
 
-//#region src/studio.ts
-var StudioApiError = class extends Error {
-	status;
-	constructor(message, status) {
-		super(message);
-		this.name = "StudioApiError";
-		this.status = status;
-	}
-};
-function getFetch(fetchImpl) {
-	const resolvedFetch = fetchImpl ?? globalThis.fetch;
-	if (!resolvedFetch) throw new Error("No fetch implementation available. Pass one via createStatelyClient({ fetch }).");
-	return resolvedFetch;
-}
-function joinApiUrl(baseUrl, path) {
-	return `${baseUrl.replace(/\/+$/, "")}/registry/api/v1${path}`;
-}
-async function parseJson(response) {
-	if (!response.headers.get("content-type")?.includes("application/json")) return null;
-	return response.json().catch(() => null);
-}
-function getErrorMessage(data, status) {
-	if (typeof data === "object" && data !== null) {
-		if ("error" in data && typeof data.error === "string") return data.error;
-		if ("error" in data) {
-			const error = data.error;
-			if (typeof error === "object" && error !== null && "json" in error) {
-				const errorJson = error.json;
-				if (typeof errorJson === "object" && errorJson !== null && "message" in errorJson && typeof errorJson.message === "string") return errorJson.message;
-			}
-		}
-	}
-	if (Array.isArray(data)) for (const item of data) {
-		const message = getErrorMessage(item, status);
-		if (message !== `HTTP ${status}`) return message;
-	}
-	return `HTTP ${status}`;
-}
-function unwrapResponseData(data) {
-	if (typeof data === "object" && data !== null && "data" in data) return data.data;
-	return data;
-}
-function normalizeProjectMachine(machine) {
-	if (typeof machine !== "object" || machine === null) return null;
-	const candidate = machine;
-	const machineId = typeof candidate.machineId === "string" ? candidate.machineId : typeof candidate.id === "string" ? candidate.id : void 0;
-	if (!machineId) return null;
-	return {
-		machineId,
-		name: typeof candidate.name === "string" && candidate.name.trim().length > 0 ? candidate.name : typeof candidate.key === "string" && candidate.key.trim().length > 0 ? candidate.key : machineId
-	};
-}
-function normalizeProjectData(project) {
-	const machines = Array.isArray(project.machines) ? project.machines.map((machine) => normalizeProjectMachine(machine)).filter((machine) => machine != null) : [];
-	if (project.projectVersionId) return {
-		...project,
-		machines
-	};
-	if (project.projectId && project.id) return {
-		...project,
-		machines,
-		projectVersionId: project.id
-	};
-	return {
-		...project,
-		machines
-	};
-}
-function normalizeRepoUrl(url) {
-	if (!url) return;
-	return url.replace(/\.git$/i, "").replace(/\/+$/, "");
-}
-function connectedReposMatch(left, right) {
-	if (!left || !right) return false;
-	const normalizedLeft = normalizeRepoUrl(left.url);
-	const normalizedRight = normalizeRepoUrl(right.url);
-	return normalizedLeft != null && normalizedRight != null && normalizedLeft === normalizedRight && left.branch === right.branch || left.owner === right.owner && left.repo === right.repo && left.branch === right.branch;
-}
-function createStatelyClient(options = {}) {
-	const baseUrl = options.baseUrl ?? "https://stately.ai";
-	const fetchImpl = getFetch(options.fetch);
-	const defaultCredential = options.credential ?? (options.apiKey ? {
-		type: "api_key",
-		token: options.apiKey
-	} : void 0);
-	const defaultAuthMode = options.authMode ?? "auto";
-	async function request(path, init = {}, credentialOverride, authModeOverride) {
-		const headers = new Headers(init.headers);
-		const authMode = authModeOverride ?? defaultAuthMode;
-		const credential = credentialOverride ?? defaultCredential;
-		if (authMode !== "none") {
-			const token = getCredentialToken(credential);
-			if (authMode === "bearer" && (!token || !credential)) throw new StudioApiError("No Stately credential configured. Pass createStatelyClient({ credential }) or use authMode: \"auto\" to let the server decide whether authentication is required.", 401);
-			if (token && credential) headers.set("Authorization", createAuthorizationHeader(credential));
-		}
-		const response = await fetchImpl(joinApiUrl(baseUrl, path), {
-			...init,
-			headers
-		});
-		const data = await parseJson(response);
-		if (!response.ok) throw new StudioApiError(getErrorMessage(data, response.status), response.status);
-		return unwrapResponseData(data);
-	}
-	return {
-		auth: { verify(credential) {
-			return request("/verify", { method: "GET" }, credential);
-		} },
-		projects: {
-			list() {
-				return request("/projects", { method: "GET" }).then((projects) => projects.map(normalizeProjectData));
-			},
-			create(input) {
-				return request("/projects/create", {
-					method: "POST",
-					headers: { "Content-Type": "application/json" },
-					body: JSON.stringify(input)
-				}).then(normalizeProjectData);
-			},
-			async ensure(input) {
-				if (input.repo && input.matchConnectedRepo !== false) {
-					const existingProject = (await this.list()).find((project) => connectedReposMatch(project.connectedRepo, input.repo));
-					if (existingProject) return existingProject;
-				}
-				return this.create(input);
-			},
-			get(projectId) {
-				return request(`/projects/${encodeURIComponent(projectId)}`, { method: "GET" }).then(normalizeProjectData);
-			}
-		},
-		machines: {
-			async create(input) {
-				return request("/machines/create", {
-					method: "POST",
-					headers: { "Content-Type": "application/json" },
-					body: JSON.stringify(input)
-				});
-			},
-			async createMany(input) {
-				return [await this.create(input)];
-			},
-			update(input) {
-				return request(`/machines/${encodeURIComponent(input.id)}`, {
-					method: "PATCH",
-					headers: { "Content-Type": "application/json" },
-					body: JSON.stringify(input)
-				});
-			},
-			get(machineId, getOptions = {}) {
-				const search = new URLSearchParams();
-				if (getOptions.version) search.set("version", getOptions.version);
-				const suffix = search.size > 0 ? `?${search.toString()}` : "";
-				return request(`/machines/${encodeURIComponent(machineId)}${suffix}`, { method: "GET" });
-			}
-		},
-		code: { extractMachines(code, extractOptions = {}) {
-			const credential = extractOptions.credential ?? (extractOptions.apiKey ? {
-				type: "api_key",
-				token: extractOptions.apiKey
-			} : void 0);
-			return request("/code", {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({ code })
-			}, credential, extractOptions.authMode);
-		} }
-	};
-}
-
-//#endregion
-export { StudioApiError, createStatelyClient };
+export { DEFAULT_STATELY_BASE_URL, StudioApiError, createStatelyClient };

package/dist/sync.d.mts

@@ -1,5 +1,5 @@
-import { b as DigraphConfig, i as StatelyGraph } from "./graph-R0sbxnZ7.mjs";
-import { CreateProjectInput, ProjectData, StudioClient, StudioMachineRecord, XStateVersion } from "./studio.mjs";
+import { b as DigraphConfig, i as StatelyGraph } from "./graph-DuOeLGvh.mjs";
+import { C as StudioMachineRecord, L as XStateVersion, g as ProjectData, o as CreateProjectInput, x as StudioClient } from "./studio-Da5pyxv6.mjs";
 import { GraphDiff } from "@statelyai/graph";
 
 //#region src/sync.d.ts

package/dist/sync.mjs

@@ -1,5 +1,5 @@
-import { createStatelyClient } from "./studio.mjs";
-import { d as xstateSourceToConfig, f as findStatelyPragmaAttachments, i as detectXStateSourceProfile, m as upsertStatelyPragma, p as getStatelyPragma, s as graphToXStateTS, t as INLINE_EXPRESSION_DIRECTIVE_FIELDS, u as serializeJS } from "./dist-C8jVuuHf.mjs";
+import { r as createStatelyClient } from "./studio-txdyJHD7.mjs";
+import { i as INLINE_EXPRESSION_DIRECTIVE_FIELDS, m as xstateSourceToConfig, n as getStatelyPragma, p as serializeJS, r as upsertStatelyPragma, s as detectXStateSourceProfile, t as findStatelyPragmaAttachments, u as graphToXStateTS } from "./statelyPragma-Bm9O4XV6.mjs";
 import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
@@ -65,9 +65,35 @@ function createFileSourceDocumentResolver() {
 		resolveImport(fromDocument, specifier) {
 			const importedFileName = resolveImportPath(fromDocument.fileName, specifier);
 			return importedFileName ? readFileSnapshot(importedFileName) : null;
+		},
+		resolvePackageJson(fromDocument, packageName) {
+			let directory = path$1.dirname(path$1.resolve(fromDocument.fileName));
+			while (true) {
+				const packageJson = readFileSnapshot(path$1.join(directory, "package.json"));
+				if (packageJson && packageJsonDeclares(packageJson.text, packageName)) return packageJson;
+				const parent = path$1.dirname(directory);
+				if (parent === directory) return null;
+				directory = parent;
+			}
 		}
 	};
 }
+function packageJsonDeclares(text, packageName) {
+	try {
+		const manifest = JSON.parse(text);
+		return [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies",
+			"optionalDependencies"
+		].some((field) => {
+			const dependencies = manifest[field];
+			return Boolean(dependencies && typeof dependencies === "object" && Object.prototype.hasOwnProperty.call(dependencies, packageName));
+		});
+	} catch {
+		return false;
+	}
+}
 function resolveImportPath(fromFileName, specifier) {
 	if (!specifier.startsWith(".")) return null;
 	const basePath = path$1.resolve(path$1.dirname(fromFileName), specifier);
@@ -121,20 +147,116 @@ function collectXStateSourceLocations(sourceText, document, options = {}) {
 	const states = [];
 	const statesObjectLocations = [];
 	collectStateLocations(root, [], states, statesObjectLocations, bindings, staticValues, root);
+	const packageProfile = detectXStatePackageProfile(options.resolver?.resolvePackageJson?.({
+		fileName: document.fileName,
+		uri
+	}, "xstate"));
 	const rootProfile = detectXStateSourceProfile(sourceText);
 	const referencedStateSymbols = new Set([...states, ...statesObjectLocations].map((state) => state.symbol).filter((symbol) => typeof symbol === "string"));
+	const resolvedTransitionFunctions = collectResolvedTransitionFunctions(root, bindings);
+	const inferredProfile = rootProfile === "xstate-v6-alpha" || resolvedTransitionFunctions.size > 0 || [...referencedStateSymbols].some((symbol) => detectXStateSourceProfile(bindings.get(symbol)?.sourceFile.text ?? "") === "xstate-v6-alpha") ? "xstate-v6-alpha" : rootProfile;
 	return {
 		version: 1,
-		profile: rootProfile === "xstate-v6-alpha" || [...referencedStateSymbols].some((symbol) => detectXStateSourceProfile(bindings.get(symbol)?.sourceFile.text ?? "") === "xstate-v6-alpha") ? "xstate-v6-alpha" : rootProfile,
+		profile: packageProfile ?? inferredProfile,
 		root: {
 			uri,
 			range: toSourceRange$1(sourceFile, root)
 		},
 		statesObject: statesObjectLocations[0],
 		states,
-		staticValues: collectStaticValueReferences(sourceFile, uri, root, staticValues)
+		staticValues: collectStaticValueReferences(sourceFile, uri, root, staticValues),
+		transitionFunctions: [...resolvedTransitionFunctions].flatMap(([symbol, resolved]) => resolved.binding.uri === uri ? [] : [{
+			symbol,
+			uri: resolved.binding.uri,
+			range: toSourceRange$1(resolved.binding.sourceFile, resolved.binding.node),
+			sourcePaths: resolved.sourcePaths
+		}])
 	};
 }
+function detectXStatePackageProfile(packageJson) {
+	if (!packageJson) return void 0;
+	let manifest;
+	try {
+		manifest = JSON.parse(packageJson.text);
+	} catch {
+		return;
+	}
+	const dependencyFields = [
+		"dependencies",
+		"devDependencies",
+		"peerDependencies",
+		"optionalDependencies"
+	];
+	let range;
+	for (const field of dependencyFields) {
+		const dependencies = manifest[field];
+		if (!dependencies || typeof dependencies !== "object") continue;
+		const value = dependencies.xstate;
+		if (typeof value === "string") {
+			range = value;
+			break;
+		}
+	}
+	if (!range) return void 0;
+	const clauseProfiles = range.replace(/^(?:workspace:|npm:xstate@)/, "").split("||").map((clause) => detectXStateRangeClauseProfile(clause.trim()));
+	const profiles = new Set(clauseProfiles);
+	if (profiles.size !== 1 || profiles.has(void 0)) return void 0;
+	return clauseProfiles[0];
+}
+function detectXStateRangeClauseProfile(clause) {
+	const normalizedClause = clause.replace(/([<>]=?)\s+/g, "$1");
+	let lowerRequiresV6 = false;
+	let upperRequiresV5 = false;
+	let directProfile;
+	for (const match of normalizedClause.matchAll(/(?:^|\s)([<>]=?|[~^])?v?(\d+)(?:\.(\d+|x|\*))?(?:\.(\d+|x|\*))?(?:-[0-9A-Za-z.-]+)?(?=\s|$)/g)) {
+		const operator = match[1] ?? "";
+		const major = Number(match[2]);
+		const minor = parseRangePart(match[3]);
+		const patch = parseRangePart(match[4]);
+		if (operator === ">" || operator === ">=") {
+			if (major >= 6) lowerRequiresV6 = true;
+			continue;
+		}
+		if (operator === "<") {
+			if (major < 6 || major === 6 && (minor ?? 0) === 0 && (patch ?? 0) === 0) upperRequiresV5 = true;
+			continue;
+		}
+		if (operator === "<=") {
+			if (major < 6) upperRequiresV5 = true;
+			continue;
+		}
+		const profile = major >= 6 ? "xstate-v6-alpha" : "xstate-v5";
+		if (directProfile && directProfile !== profile) return void 0;
+		directProfile = profile;
+	}
+	if (lowerRequiresV6 && upperRequiresV5) return void 0;
+	if (lowerRequiresV6) return "xstate-v6-alpha";
+	if (upperRequiresV5) return "xstate-v5";
+	return directProfile;
+}
+function parseRangePart(value) {
+	return value && /^\d+$/.test(value) ? Number(value) : void 0;
+}
+function collectImportedXStateTransitionSources(sourceText, document, options = {}) {
+	if (!options.resolver) return [];
+	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
+	const uri = document.uri?.toString() ?? document.fileName;
+	sourceFileUris.set(sourceFile, uri);
+	const bindings = collectBindings(sourceFile, uri, document.fileName, options);
+	const root = findMachineConfigObjectLiteral(sourceFile, bindings);
+	if (!root) return [];
+	return [...collectResolvedTransitionFunctions(root, bindings)].flatMap(([localName, resolved]) => {
+		const { binding } = resolved;
+		if (binding.uri === uri) return [];
+		if (ts$1.isFunctionDeclaration(binding.node)) {
+			const name = binding.node.name;
+			if (!name) return [];
+			const suffix = binding.node.getText(binding.sourceFile).slice(name.getEnd() - binding.node.getStart(binding.sourceFile));
+			return [`${binding.node.modifiers?.some((modifier) => modifier.kind === ts$1.SyntaxKind.AsyncKeyword) ? "async " : ""}function ${localName}${suffix}`];
+		}
+		return [`const ${localName} = ${binding.node.getText(binding.sourceFile)};`];
+	});
+}
 function collectStaticValueBindings(sourceFile) {
 	const bindings = /* @__PURE__ */ new Map();
 	for (const statement of sourceFile.statements) {
@@ -180,9 +302,30 @@ function collectBindings(sourceFile, uri, fileName, options, cache = /* @__PURE_
 function collectTopLevelBindings(sourceFile, uri) {
 	const bindings = /* @__PURE__ */ new Map();
 	for (const statement of sourceFile.statements) {
+		if (ts$1.isFunctionDeclaration(statement) && statement.name) {
+			bindings.set(statement.name.text, {
+				kind: "transitionFunction",
+				node: statement,
+				sourceFile,
+				uri,
+				bindings
+			});
+			continue;
+		}
 		if (!ts$1.isVariableStatement(statement)) continue;
 		for (const declaration of statement.declarationList.declarations) {
 			if (!ts$1.isIdentifier(declaration.name) || !declaration.initializer) continue;
+			const initializer = unwrapExpression$1(declaration.initializer);
+			if (ts$1.isArrowFunction(initializer) || ts$1.isFunctionExpression(initializer)) {
+				bindings.set(declaration.name.text, {
+					kind: "transitionFunction",
+					node: initializer,
+					sourceFile,
+					uri,
+					bindings
+				});
+				continue;
+			}
 			const objectLiteral = unwrapObjectLiteralExpression(declaration.initializer);
 			if (objectLiteral) {
 				bindings.set(declaration.name.text, {
@@ -228,6 +371,62 @@ function addImportedBindings(bindings, sourceFile, uri, fileName, options, cache
 		}
 	}
 }
+function collectResolvedTransitionFunctions(root, bindings) {
+	const found = /* @__PURE__ */ new Map();
+	const visitExpression = (expression, sourcePath) => {
+		const current = unwrapExpression$1(expression);
+		if (ts$1.isIdentifier(current)) {
+			const binding = bindings.get(current.text);
+			if (binding?.kind === "transitionFunction") {
+				const resolved = found.get(current.text) ?? {
+					binding,
+					sourcePaths: []
+				};
+				if (!resolved.sourcePaths.some((existing) => existing.length === sourcePath.length && existing.every((segment, index) => segment === sourcePath[index]))) resolved.sourcePaths.push(sourcePath);
+				found.set(current.text, resolved);
+			}
+			return;
+		}
+		if (ts$1.isObjectLiteralExpression(current)) {
+			for (const property of current.properties) if (ts$1.isPropertyAssignment(property)) visitExpression(property.initializer, sourcePath);
+			else if (ts$1.isShorthandPropertyAssignment(property)) visitExpression(property.name, sourcePath);
+			else if (ts$1.isSpreadAssignment(property)) visitExpression(property.expression, sourcePath);
+			return;
+		}
+		if (ts$1.isArrayLiteralExpression(current)) {
+			for (const element of current.elements) if (ts$1.isExpression(element)) visitExpression(element, sourcePath);
+			return;
+		}
+		ts$1.forEachChild(current, (child) => {
+			if (ts$1.isExpression(child)) visitExpression(child, sourcePath);
+		});
+	};
+	const visitState = (state, sourcePath) => {
+		for (const propertyName of [
+			"on",
+			"after",
+			"always",
+			"onDone",
+			"onError",
+			"onSnapshot",
+			"onTimeout"
+		]) {
+			const property = state.properties.find((candidate) => ts$1.isPropertyAssignment(candidate) && getPropertyNameText$1(candidate.name) === propertyName);
+			if (property) visitExpression(property.initializer, sourcePath);
+		}
+		const states = state.properties.find((candidate) => ts$1.isPropertyAssignment(candidate) && getPropertyNameText$1(candidate.name) === "states");
+		const statesObject = states && unwrapObjectLiteralExpression(states.initializer);
+		if (!statesObject) return;
+		for (const property of statesObject.properties) {
+			if (!ts$1.isPropertyAssignment(property)) continue;
+			const child = unwrapObjectLiteralExpression(property.initializer);
+			const key = getPropertyNameText$1(property.name);
+			if (child && key) visitState(child, [...sourcePath, key]);
+		}
+	};
+	visitState(root, []);
+	return found;
+}
 function findMachineConfigObjectLiteral(sourceFile, bindings) {
 	let found = null;
 	const visit = (node) => {
@@ -276,7 +475,7 @@ function collectStateLocations(stateObject, parentPath, locations, statesObjectL
 function resolveStateProperty(property, bindings, staticValues, root) {
 	if (ts$1.isShorthandPropertyAssignment(property)) {
 		const binding = bindings.get(property.name.text);
-		if (!binding) return null;
+		if (!binding || binding.kind === "transitionFunction") return null;
 		return {
 			key: property.name.text,
 			kind: binding.kind,
@@ -306,7 +505,7 @@ function resolveStateProperty(property, bindings, staticValues, root) {
 	};
 	if (ts$1.isIdentifier(property.initializer)) {
 		const binding = bindings.get(property.initializer.text);
-		if (!binding) return null;
+		if (!binding || binding.kind === "transitionFunction") return null;
 		return {
 			key: resolvedKey.key,
 			kind: binding.kind,
@@ -584,10 +783,13 @@ function parseSourceToMachine(text, document, options = {}) {
 		...statesObjectReplacements,
 		...importReplacements
 	].filter(removeOverlappingRanges).sort(compareSourceRangesDescending));
-	if (sourceLocations.profile === "xstate-v6-alpha") return `import { createMachine } from "xstate";
+	if (sourceLocations.profile === "xstate-v6-alpha") {
+		const importedTransitionSources = collectImportedXStateTransitionSources(text, document, options);
+		return `import { createMachine } from "xstate";
 
-export const machine = createMachine(${serializeJS(xstateSourceToConfig(hydratedText, { profile: "xstate-v6-alpha" }), 0)});
+export const machine = createMachine(${serializeJS(xstateSourceToConfig(importedTransitionSources.length ? `${hydratedText}\n${importedTransitionSources.join("\n")}` : hydratedText, { profile: "xstate-v6-alpha" }), 0)});
 `;
+	}
 	return hydratedText;
 }
 function readHydratedStatesObject(uri, range, states, resolver) {
@@ -1254,16 +1456,16 @@ function inferXStateTargetLanguage(targetPath) {
 	return /\.(?:c|m)?jsx?$/i.test(targetPath) ? "javascript" : "typescript";
 }
 async function resolveRemoteMachine(machineId, baseUrl, kind, locator, options) {
-	const machineResponse = await (options.client ?? createStatelyClient({
+	const digraph = (await (options.client ?? createStatelyClient({
 		apiKey: options.apiKey,
 		baseUrl,
 		fetch: options.fetch
-	})).machines.get(machineId);
+	})).machines.get(machineId)).definition;
 	return {
 		kind,
 		locator,
 		format: "digraph",
-		graph: fromStudioMachine(machineResponse && typeof machineResponse === "object" && "definition" in machineResponse && machineResponse.definition ? machineResponse.definition : machineResponse),
+		graph: fromStudioMachine(digraph),
 		remoteMachineId: machineId
 	};
 }
@@ -1332,33 +1534,22 @@ 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 withResolvedProjectVersionId(await client.projects.get(explicitProject.projectVersionId), explicitProject.projectVersionId);
-	if (explicitProject?.projectId) return withResolvedProjectVersionId(await client.projects.get(explicitProject.projectId));
+	if (explicitProject?.projectId) return client.projects.get(explicitProject.projectId);
+	if (explicitProject?.projectVersionId) {
+		const matchedProject = (await client.projects.list()).find((candidate) => candidate.projectVersionId === explicitProject.projectVersionId);
+		if (!matchedProject) throw new Error(`No project found for projectVersionId "${explicitProject.projectVersionId}".`);
+		return client.projects.get(matchedProject.projectId);
+	}
 	const inferredRepo = explicitProject?.repo ?? await inferConnectedRepo(sourcePath, options.cwd);
 	const projectInput = {
 		name: explicitProject?.name ?? inferDefaultProjectName(sourcePath, inferredRepo),
-		visibility: explicitProject?.visibility ?? "Private",
+		visibility: explicitProject?.visibility ?? "private",
 		...explicitProject?.description ? { description: explicitProject.description } : {},
 		...explicitProject?.keywords ? { keywords: explicitProject.keywords } : {},
 		...inferredRepo ? { repo: inferredRepo } : {}
 	};
-	return withResolvedProjectVersionId(await client.projects.ensure(projectInput));
+	return client.projects.ensure(projectInput);
 }
 async function pushSync(options) {
 	const client = options.client ?? createStatelyClient({