@statelyai/sdk 0.29.0 → 0.31.0

package/dist/relay.d.mts

@@ -1,4 +1,4 @@
-import { ProtocolMessage } from "./protocol.mjs";
+import { dt as ProtocolMessage } from "./protocol-DOt1Vz-5.mjs";
 
 //#region src/relay.d.ts
 type InspectionRelayRole = 'producer' | 'viewer';

package/dist/statelyPragma-D46lczJR.mjs

@@ -0,0 +1,102 @@
+import ts from "typescript";
+
+//#region src/statelyPragma.ts
+function findStatelyPragmaAttachments(sourceText, fileName = "machine.ts") {
+	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(fileName));
+	const attachments = [];
+	const visit = (node) => {
+		if (ts.isCallExpression(node) && isCreateMachineExpression(node.expression)) {
+			const attachNode = findAttachNode(node);
+			if (attachNode) attachments.push({
+				machineStart: getMachineExpressionStart(node.expression, sourceFile),
+				attachStart: attachNode.getStart(sourceFile),
+				pragma: findAttachedStatelyPragma(sourceText, attachNode)
+			});
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return attachments;
+}
+function getStatelyPragma(sourceText, fileName = "machine.ts", machineIndex = 0) {
+	return findStatelyPragmaAttachments(sourceText, fileName)[machineIndex]?.pragma;
+}
+function upsertStatelyPragma(sourceText, id, options = {}) {
+	const attachment = findStatelyPragmaAttachments(sourceText, options.fileName ?? "machine.ts")[options.machineIndex ?? 0];
+	if (!attachment) return sourceText;
+	const lineEnding = options.lineEnding ?? detectLineEnding(sourceText);
+	const canonicalComment = `// @statelyai id=${id}`;
+	if (attachment.pragma) return sourceText.slice(0, attachment.pragma.start) + canonicalComment + sourceText.slice(attachment.pragma.end);
+	const insertText = `${getIndentationAtOffset(sourceText, attachment.attachStart)}${canonicalComment}${lineEnding}`;
+	return sourceText.slice(0, attachment.attachStart) + insertText + sourceText.slice(attachment.attachStart);
+}
+function findAttachedStatelyPragma(sourceText, node) {
+	const comments = ts.getLeadingCommentRanges(sourceText, node.getFullStart()) ?? [];
+	for (let index = comments.length - 1; index >= 0; index -= 1) {
+		const comment = comments[index];
+		const parsed = parseStatelyPragma(sourceText, comment.pos, comment.end);
+		if (parsed) return parsed;
+	}
+}
+function parseStatelyPragma(sourceText, start, end) {
+	const match = normalizeCommentContent(sourceText.slice(start, end)).match(/^@statelyai(?:\s+(.*))?$/s);
+	if (!match) return;
+	const fields = parseFields(match[1] ?? "");
+	return {
+		tag: "@statelyai",
+		id: fields.id,
+		fields,
+		start,
+		end
+	};
+}
+function normalizeCommentContent(rawComment) {
+	if (rawComment.startsWith("//")) return rawComment.slice(2).trim();
+	if (rawComment.startsWith("/*")) return rawComment.slice(2, rawComment.endsWith("*/") ? -2 : void 0).split(/\r?\n/).map((line) => line.replace(/^\s*\*\s?/, "")).join(" ").trim();
+	return rawComment.trim();
+}
+function parseFields(input) {
+	const fields = {};
+	for (const token of input.split(/\s+/)) {
+		if (!token) continue;
+		const equalsIndex = token.indexOf("=");
+		if (equalsIndex <= 0) continue;
+		const key = token.slice(0, equalsIndex);
+		const value = token.slice(equalsIndex + 1);
+		if (!key || !value) continue;
+		fields[key] = value;
+	}
+	return fields;
+}
+function findAttachNode(node) {
+	let current = node;
+	while (current?.parent) {
+		if (ts.isVariableStatement(current.parent) || ts.isExpressionStatement(current.parent) || ts.isExportAssignment(current.parent)) return current.parent;
+		current = current.parent;
+	}
+	return current;
+}
+function isCreateMachineExpression(expression) {
+	const isMachineFactoryName = (name) => name === "createMachine" || name === "createMachineFromConfig";
+	return ts.isIdentifier(expression) && isMachineFactoryName(expression.text) || ts.isPropertyAccessExpression(expression) && isMachineFactoryName(expression.name.text);
+}
+function getMachineExpressionStart(expression, sourceFile) {
+	if (ts.isPropertyAccessExpression(expression)) return expression.name.getStart(sourceFile);
+	return expression.getStart(sourceFile);
+}
+function getIndentationAtOffset(sourceText, offset) {
+	const lineStart = sourceText.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
+	return sourceText.slice(lineStart, offset).match(/^[ \t]*/)?.[0] ?? "";
+}
+function detectLineEnding(sourceText) {
+	return sourceText.includes("\r\n") ? "\r\n" : "\n";
+}
+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;
+}
+
+//#endregion
+export { getStatelyPragma as n, upsertStatelyPragma as r, findStatelyPragmaAttachments as t };

package/dist/{studio-QQRLjF5V.d.mts → studio-GZ6E_xns.d.mts}

@@ -1,5 +1,5 @@
-import { A as ZodOptional, D as ZodNullable, E as ZodLiteral, F as output, I as $loose, L as $strip, M as ZodString, N as ZodUnion, O as ZodNumber, P as ZodUnknown, T as ZodEnum, j as ZodRecord, k as ZodObject, w as ZodArray } from "./index-DNDfA-YC.mjs";
-import { n as StatelyCredential, t as StatelyAuthMode } from "./auth-BPyCCHYo.mjs";
+import { A as ZodObject, D as ZodLiteral, E as ZodEnum, F as ZodUnknown, I as output, L as $loose, M as ZodRecord, N as ZodString, O as ZodNullable, P as ZodUnion, R as $strip, T as ZodBoolean, j as ZodOptional, k as ZodNumber, w as ZodArray } from "./index-ZlKF1x_z.mjs";
+import { n as StatelyCredential, t as StatelyAuthMode } from "./auth-Dg7prjeL.mjs";
 
 //#region ../api-contract/dist/errors.d.mts
 /**
@@ -44,6 +44,17 @@ declare const verifyResultSchema: ZodObject<{
   }>;
 }, $strip>;
 type VerifyResult = output<typeof verifyResultSchema>;
+/**
+ * Entitlements for the authenticated caller.
+ *
+ * Internal contract: this is not published as an `/api/v1` operation. Editor
+ * feature gating resolves it server-side through the resource provider and
+ * hands the mapped result to the client (see
+ * `packages/editor/src/entitlements`).
+ *
+ * `entitlements` is an open set of provider-defined strings; unknown values are
+ * ignored rather than rejected.
+ */
 declare const projectSummarySchema: ZodObject<{
   projectId: ZodString;
   projectVersionId: ZodString;
@@ -58,6 +69,16 @@ declare const projectSummarySchema: ZodObject<{
   updatedAt: ZodString;
 }, $strip>;
 type ProjectSummary = output<typeof projectSummarySchema>;
+/**
+ * `name` and `updatedAt` are optional: some upstream project envelopes only
+ * return machine ids. Providers that can supply them cheaply should.
+ */
+declare const projectMachineSummarySchema: ZodObject<{
+  machineId: ZodString;
+  name: ZodOptional<ZodString>;
+  updatedAt: ZodOptional<ZodString>;
+}, $strip>;
+type ProjectMachineSummary = output<typeof projectMachineSummarySchema>;
 declare const projectSchema: ZodObject<{
   projectId: ZodString;
   projectVersionId: ZodString;
@@ -73,18 +94,19 @@ declare const projectSchema: ZodObject<{
   rootMachineId: ZodNullable<ZodString>;
   machines: ZodArray<ZodObject<{
     machineId: ZodString;
+    name: ZodOptional<ZodString>;
+    updatedAt: ZodOptional<ZodString>;
   }, $strip>>;
+  permissions: ZodObject<{
+    canEdit: ZodBoolean;
+  }, $strip>;
+  allowedVisibility: ZodOptional<ZodArray<ZodEnum<{
+    public: "public";
+    unlisted: "unlisted";
+    private: "private";
+  }>>>;
 }, $strip>;
 type Project = output<typeof projectSchema>;
-/**
- * `name` is optional: the Registry project envelope only returns machine ids.
- * Providers that can supply names cheaply should.
- */
-declare const projectMachineSummarySchema: ZodObject<{
-  machineId: ZodString;
-  name: ZodOptional<ZodString>;
-}, $strip>;
-type ProjectMachineSummary = output<typeof projectMachineSummarySchema>;
 declare const machineSchema: ZodObject<{
   machineId: ZodString;
   name: ZodString;
@@ -159,6 +181,7 @@ declare const machineVersionSchema: ZodObject<{
   updatedAt: ZodString;
 }, $strip>;
 type MachineVersion = output<typeof machineVersionSchema>;
+/** Version-history row without the definition payload. */
 declare const extractedMachinesSchema: ZodObject<{
   machines: ZodArray<ZodObject<{
     config: ZodRecord<ZodString, ZodUnknown>;

package/dist/{studio-DpCW5V4a.mjs → studio-rSI54Ese.mjs}

@@ -127,6 +127,24 @@ const verifyResultSchema = object({
 	valid: literal(true),
 	tokenScope: _enum(["user", "project"])
 });
+/**
+* Entitlements for the authenticated caller.
+*
+* Internal contract: this is not published as an `/api/v1` operation. Editor
+* feature gating resolves it server-side through the resource provider and
+* hands the mapped result to the client (see
+* `packages/editor/src/entitlements`).
+*
+* `entitlements` is an open set of provider-defined strings; unknown values are
+* ignored rather than rejected.
+*/
+const entitlementsResultSchema = object({
+	subscription: object({
+		tier: string(),
+		status: string()
+	}).nullable(),
+	entitlements: array(string())
+});
 const projectSummarySchema = object({
 	projectId: string(),
 	projectVersionId: string(),
@@ -136,17 +154,20 @@ const projectSummarySchema = object({
 	createdAt: string(),
 	updatedAt: string()
 });
-const projectSchema = projectSummarySchema.extend({
-	rootMachineId: string().nullable(),
-	machines: array(object({ machineId: string() }))
-});
 /**
-* `name` is optional: the Registry project envelope only returns machine ids.
-* Providers that can supply names cheaply should.
+* `name` and `updatedAt` are optional: some upstream project envelopes only
+* return machine ids. Providers that can supply them cheaply should.
 */
 const projectMachineSummarySchema = object({
 	machineId: string(),
-	name: string().optional()
+	name: string().optional(),
+	updatedAt: string().optional()
+});
+const projectSchema = projectSummarySchema.extend({
+	rootMachineId: string().nullable(),
+	machines: array(projectMachineSummarySchema),
+	permissions: object({ canEdit: boolean() }),
+	allowedVisibility: array(projectVisibilitySchema).optional()
 });
 const machineSchema = object({
 	machineId: string(),
@@ -167,6 +188,67 @@ const machineVersionSchema = object({
 	createdAt: string(),
 	updatedAt: string()
 });
+/** Version-history row without the definition payload. */
+const machineVersionSummarySchema = object({
+	machineVersionId: string(),
+	machineId: string(),
+	versionNumber: number(),
+	name: string().nullable(),
+	status: string(),
+	parentVersionId: string().nullable(),
+	createdAt: string(),
+	updatedAt: string()
+});
+/** Result of converting a machine's stored definition to XGraph in place. */
+const machinesConvertResultSchema = object({
+	machine: machineSchema,
+	created: boolean(),
+	version: object({
+		machineVersionId: string(),
+		versionNumber: number(),
+		name: string().nullable()
+	})
+});
+/**
+* A project the caller may fork a machine into, with the version ids a fork
+* can target. `projectVersionIds` is ordered as the provider reports it.
+*/
+const projectDestinationProjectSchema = object({
+	projectId: string(),
+	name: string(),
+	visibility: projectVisibilitySchema,
+	projectVersionIds: array(string())
+});
+/**
+* Fork destinations grouped by owner. The caller's personal projects are one
+* owner alongside each team; `ownerId` is opaque and provider-defined.
+*/
+const projectDestinationSchema = object({
+	ownerId: string(),
+	name: string(),
+	projects: array(projectDestinationProjectSchema)
+});
+/** Result of forking a machine into a new or existing project version. */
+const machinesForkResultSchema = object({
+	machine: machineSchema,
+	projectVersionId: string(),
+	projectId: string()
+});
+/**
+* The version holding a machine's pre-conversion (legacy editor) definition.
+* `versionId` is `null` when the machine has no such version, which is the
+* signal that the legacy editor cannot be re-entered for it.
+*/
+const machineLegacyVersionSchema = object({ versionId: string().nullable() });
+/** Result of restoring a machine's legacy-editor definition. */
+const machinesRestoreLegacyResultSchema = object({
+	machine: machineSchema,
+	version: object({
+		machineVersionId: string(),
+		versionNumber: number(),
+		name: string().nullable()
+	})
+});
 const extractedMachinesSchema = object({ machines: array(object({
 	config: record(string(), unknown()),
 	machineIndex: number().int().nonnegative().optional()
@@ -190,6 +272,40 @@ const machinesUpdateRequestSchema = object({
 	name: string().min(1).optional(),
 	definition: unknown().optional()
 }).refine((value) => value.name !== void 0 || value.definition !== void 0, { message: "At least one of `name` or `definition` is required." });
+/**
+* `status` is canonical lowercase; providers map it to their own casing.
+* Omitting `definition` snapshots the machine's current definition.
+*/
+const machineVersionsCreateRequestSchema = object({
+	name: string().min(1).optional(),
+	definition: unknown().optional(),
+	status: _enum(["committed", "auto"]).optional(),
+	parentVersionId: string().min(1).optional()
+});
+const machinesConvertRequestSchema = object({
+	definition: xgraphSchema,
+	expectedUpdatedAt: string().min(1),
+	keepOriginalVersion: boolean().optional()
+});
+/**
+* Fork a machine into exactly one target: an existing project version, or a
+* new project to create for it. Both, or neither, is a client bug.
+*/
+const machinesForkRequestSchema = object({
+	targetProjectVersionId: string().min(1).optional(),
+	targetProject: object({
+		name: string().min(1),
+		visibility: projectVisibilitySchema,
+		teamId: string().min(1).optional()
+	}).optional(),
+	machineName: string().min(1).optional(),
+	xstateVersion: xstateVersionSchema.optional()
+}).refine((value) => value.targetProjectVersionId === void 0 !== (value.targetProject === void 0), { message: "Exactly one of `targetProjectVersionId` or `targetProject` is required." });
+const machinesRestoreLegacyRequestSchema = object({
+	versionId: string().min(1).optional(),
+	expectedUpdatedAt: string().min(1),
+	reason: string().optional()
+});
 const codeExtractMachinesRequestSchema = object({
 	code: string().min(1),
 	xstateVersion: xstateVersionSchema.optional()
@@ -201,10 +317,17 @@ const projectsCreateResponseSchema = projectSchema;
 const projectsUpdateResponseSchema = projectSchema;
 const projectsDeleteResponseSchema = object({ projectId: string() });
 const projectsListMachinesResponseSchema = array(projectMachineSummarySchema);
+const projectsDestinationsResponseSchema = array(projectDestinationSchema);
 const machinesCreateResponseSchema = machineSchema;
 const machinesGetResponseSchema = machineSchema;
 const machinesUpdateResponseSchema = machineSchema;
 const machinesGetVersionResponseSchema = machineVersionSchema;
+const machineVersionsListResponseSchema = array(machineVersionSummarySchema);
+const machineVersionsCreateResponseSchema = machineVersionSchema;
+const machinesConvertDefinitionResponseSchema = machinesConvertResultSchema;
+const machinesForkResponseSchema = machinesForkResultSchema;
+const machinesGetLegacyVersionResponseSchema = machineLegacyVersionSchema;
+const machinesRestoreLegacyResponseSchema = machinesRestoreLegacyResultSchema;
 const codeExtractMachinesResponseSchema = extractedMachinesSchema;
 /**
 * Request/response schema pairs keyed by resource capability name. Kept here
@@ -225,6 +348,7 @@ const resourceOperationSchemas = {
 	},
 	"projects.delete": { response: projectsDeleteResponseSchema },
 	"projects.listMachines": { response: projectsListMachinesResponseSchema },
+	"projects.destinations": { response: projectsDestinationsResponseSchema },
 	"machines.create": {
 		request: machinesCreateRequestSchema,
 		response: machinesCreateResponseSchema
@@ -234,6 +358,24 @@ const resourceOperationSchemas = {
 	"machines.update": {
 		request: machinesUpdateRequestSchema,
 		response: machinesUpdateResponseSchema
+	},
+	"machines.versions.list": { response: machineVersionsListResponseSchema },
+	"machines.versions.create": {
+		request: machineVersionsCreateRequestSchema,
+		response: machineVersionsCreateResponseSchema
+	},
+	"machines.convertDefinition": {
+		request: machinesConvertRequestSchema,
+		response: machinesConvertDefinitionResponseSchema
+	},
+	"machines.fork": {
+		request: machinesForkRequestSchema,
+		response: machinesForkResponseSchema
+	},
+	"machines.getLegacyVersion": { response: machinesGetLegacyVersionResponseSchema },
+	"machines.restoreLegacy": {
+		request: machinesRestoreLegacyRequestSchema,
+		response: machinesRestoreLegacyResponseSchema
 	}
 };
 /** Provider-independent operations implemented by this repository. */

package/dist/studio.d.mts

@@ -1,2 +1,2 @@
-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-QQRLjF5V.mjs";
+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-GZ6E_xns.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,4 +1,4 @@
 import "./openapi-BTDjYWXd.mjs";
-import { n as StudioApiError, r as createStatelyClient, t as DEFAULT_STATELY_BASE_URL } from "./studio-DpCW5V4a.mjs";
+import { n as StudioApiError, r as createStatelyClient, t as DEFAULT_STATELY_BASE_URL } from "./studio-rSI54Ese.mjs";
 
 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-5X1Ilppq.mjs";
-import { C as StudioMachineRecord, L as XStateVersion, g as ProjectData, o as CreateProjectInput, x as StudioClient } from "./studio-QQRLjF5V.mjs";
+import { b as DigraphConfig, i as StatelyGraph } from "./graph-CehpcL7P.mjs";
+import { C as StudioMachineRecord, L as XStateVersion, g as ProjectData, o as CreateProjectInput, x as StudioClient } from "./studio-GZ6E_xns.mjs";
 import { GraphDiff } from "@statelyai/graph";
 
 //#region src/sync.d.ts

package/dist/sync.mjs

@@ -1,6 +1,7 @@
 import "./openapi-BTDjYWXd.mjs";
-import { r as createStatelyClient } from "./studio-DpCW5V4a.mjs";
-import { b as serializeJS, c as detectXStateSourceProfile, f as graphChangeToPatchesResult, h as graphToXStateTS, i as INLINE_EXPRESSION_DIRECTIVE_FIELDS, l as diffGraphsSemantically, n as getStatelyPragma, o as alignCompareGraphIds, p as graphToMachineConfig, r as upsertStatelyPragma, t as findStatelyPragmaAttachments, v as normalizeMachineProfile, x as xstateSourceToConfig } from "./statelyPragma-Cg1KzBZr.mjs";
+import { r as createStatelyClient } from "./studio-rSI54Ese.mjs";
+import { a as detectXStateSourceProfile, c as extractXStateMachineConfigEntries, d as graphToMachineConfig, g as normalizeMachineProfile, o as diffGraphsSemantically, p as graphToXStateTS, r as alignCompareGraphIds, t as INLINE_EXPRESSION_DIRECTIVE_FIELDS, u as graphChangeToPatchesResult, v as serializeJS } from "./dist-BQEaIgBI.mjs";
+import { n as getStatelyPragma, r as upsertStatelyPragma, t as findStatelyPragmaAttachments } from "./statelyPragma-D46lczJR.mjs";
 import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
@@ -580,9 +581,10 @@ function resolveIdentifierObject(expression, bindings) {
 }
 function resolveObjectLiteralProperty(objectLiteral, propertyName, bindings) {
 	for (const property of objectLiteral.properties) {
-		if (!ts$1.isPropertyAssignment(property)) continue;
+		if (!ts$1.isPropertyAssignment(property) && !ts$1.isShorthandPropertyAssignment(property)) continue;
 		if (getPropertyNameText$2(property.name) !== propertyName) continue;
-		const inlineObject = unwrapObjectLiteralExpression$1(property.initializer);
+		const initializer = ts$1.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
+		const inlineObject = unwrapObjectLiteralExpression$1(initializer);
 		if (inlineObject) return {
 			object: inlineObject,
 			kind: "inline",
@@ -591,15 +593,15 @@ function resolveObjectLiteralProperty(objectLiteral, propertyName, bindings) {
 			uri: getSourceFileUri(property.getSourceFile()),
 			bindings
 		};
-		if (ts$1.isIdentifier(property.initializer)) {
-			const binding = bindings.get(property.initializer.text);
+		if (ts$1.isIdentifier(initializer)) {
+			const binding = bindings.get(initializer.text);
 			if (binding?.kind !== "objectReference") return null;
 			return {
 				object: binding.node,
 				kind: binding.kind,
-				symbol: property.initializer.text,
+				symbol: initializer.text,
 				keyRange: toSourceRange$1(property.getSourceFile(), property.name),
-				referenceRange: toSourceRange$1(property.getSourceFile(), property.initializer),
+				referenceRange: toSourceRange$1(property.getSourceFile(), initializer),
 				sourceFile: binding.sourceFile,
 				uri: binding.uri,
 				bindings: binding.bindings
@@ -809,7 +811,7 @@ function parseSourceToMachine(text, document, options = {}) {
 		const statesText = readHydratedStatesObject(sourceLocations.statesObject.uri, sourceLocations.statesObject.range, sourceLocations.states, options.resolver);
 		return statesText ? [{
 			range: sourceLocations.statesObject.referenceRange,
-			newText: statesText
+			newText: areSourceRangesEqual(sourceLocations.statesObject.referenceRange, sourceLocations.statesObject.keyRange) ? `states: ${statesText}` : statesText
 		}] : [];
 	})() : [];
 	const importReplacements = collectHydratedImportReplacements(text, document, new Set([...sourceLocations.states.filter((location) => location.path.length === 1 && location.referenceRange).map((location) => location.symbol).filter((symbol) => typeof symbol === "string"), ...sourceLocations.statesObject?.symbol ? [sourceLocations.statesObject.symbol] : []]));
@@ -819,11 +821,15 @@ function parseSourceToMachine(text, document, options = {}) {
 		...statesObjectReplacements,
 		...importReplacements
 	].filter(removeOverlappingRanges).sort(compareSourceRangesDescending));
-	if (sourceLocations.profile === "xstate-v6-alpha") {
+	if (sourceLocations.profile === "xstate-v6-alpha" || options.machineIndex !== void 0) {
 		const importedTransitionSources = collectImportedXStateTransitionSources(text, document, options);
+		const parseText = importedTransitionSources.length ? `${hydratedText}\n${importedTransitionSources.join("\n")}` : hydratedText;
+		const selectedMachineIndex = options.machineIndex ?? 0;
+		const config = extractXStateMachineConfigEntries(parseText, { profile: sourceLocations.profile }).find((entry) => entry.machineIndex === selectedMachineIndex)?.config;
+		if (!config) throw new Error(`No machine at index ${selectedMachineIndex} was found in ${document.fileName}.`);
 		return `import { createMachine } from "xstate";
 
-export const machine = createMachine(${serializeJS(xstateSourceToConfig(importedTransitionSources.length ? `${hydratedText}\n${importedTransitionSources.join("\n")}` : hydratedText, { profile: "xstate-v6-alpha" }), 0)});
+export const machine = createMachine(${serializeJS(config, 0)});
 `;
 	}
 	return hydratedText;
@@ -1091,12 +1097,13 @@ function offsetAtRangePosition$1(sourceText, line, character) {
 function applyMachineToSource(machineConfig, document, options = {}) {
 	if (!isMachineConfig(machineConfig)) return [];
 	const sourceFile = createSourceFile(document, document.getText());
-	const machineConfigNode = findMachineConfigObjectLiteral(sourceFile, options.machineIndex);
+	const machineConfigNode = getMappedRootObjectLiteral(document, sourceFile, options.sourceLocations) ?? findMachineConfigObjectLiteral(sourceFile, options.machineIndex);
 	if (!machineConfigNode) return [];
+	if (options.sourceUpdateStrategy === "rewrite") return addCodeImportReplacements(document, sourceFile, machineConfig, [createRewriteReplacement(document, sourceFile, machineConfigNode, machineConfig)]).sort(compareReplacementRangesDescending);
 	const parsedPatches = parseGraphPatches(options.patches);
 	const prevGraph = parseGraph(options.prevGraph);
 	const nextGraph = parseGraph(options.nextGraph);
-	const rootNode = getMappedRootObjectLiteral(document, sourceFile, options.sourceLocations) ?? machineConfigNode;
+	const rootNode = machineConfigNode;
 	if (!parsedPatches || !prevGraph || !nextGraph || parsedPatches.length === 0) {
 		if (wouldDeModularizeRootReplacement(options.sourceLocations)) return [];
 		return [createReplacement(document, sourceFile, rootNode, machineConfig)];
@@ -1170,6 +1177,7 @@ async function applyMachineToSourceDocuments(machineConfig, document, options =
 	const sourceFile = createSourceFile(document, document.getText());
 	const machineConfigNode = getMappedRootObjectLiteral(document, sourceFile, options.sourceLocations) ?? findMachineConfigObjectLiteral(sourceFile, options.machineIndex);
 	if (!machineConfigNode) return [];
+	if (options.sourceUpdateStrategy === "rewrite") return addCodeImportReplacements(document, sourceFile, machineConfig, [createRewriteReplacement(document, sourceFile, machineConfigNode, machineConfig)]).sort(compareReplacementRangesDescending);
 	const parsedPatches = parseGraphPatches(options.patches);
 	const prevGraph = parseGraph(options.prevGraph);
 	const nextGraph = parseGraph(options.nextGraph);
@@ -1318,8 +1326,8 @@ async function createTransitionReplacementForDocuments(document, sourceFile, mac
 	if (transitionSource && transitionTarget.previousEventType === transitionTarget.eventType) return [createPropertyValueReplacement(targetDocument, targetSourceFile, transitionSource.eventProperty, nextTransitionValue)];
 	if (transitionSource) return [createPropertyAssignmentReplacement(targetDocument, targetSourceFile, transitionSource.eventProperty, transitionTarget.eventType, nextTransitionValue)];
 	const onObject = getObjectLiteralProperty(stateObject, "on");
-	if (onObject) return [createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, onObject, transitionTarget.eventType, nextTransitionValue)];
-	return [createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, stateObject, "on", { [transitionTarget.eventType]: nextTransitionValue })];
+	if (onObject) return createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, onObject, transitionTarget.eventType, nextTransitionValue);
+	return createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, stateObject, "on", { [transitionTarget.eventType]: nextTransitionValue });
 }
 async function createStatePropertiesReplacementForDocuments(document, sourceFile, machineConfigNode, machineConfig, path, propertyNames, sourceLocations, openTextDocument) {
 	const nextStateConfig = getStateConfigByPath(machineConfig, path);
@@ -1484,8 +1492,30 @@ function createPropertyAssignmentReplacement(document, sourceFile, property, key
 	return createOffsetReplacement(document, property.getStart(sourceFile), property.getEnd(), text);
 }
 function createObjectLiteralPropertyInsertion(document, sourceFile, objectLiteral, key, nextValue) {
-	const text = objectPropertyTextForInsertion(objectLiteral, printObjectLiteralProperty(key, nextValue, sourceFile, getFormattingContext(document, sourceFile, objectLiteral)));
-	return createOffsetReplacement(document, objectLiteral.properties.end, objectLiteral.properties.end, text);
+	const propertyText = objectPropertyTextForInsertion(objectLiteral, printObjectLiteralProperty(key, nextValue, sourceFile, getFormattingContext(document, sourceFile, objectLiteral)));
+	return createObjectPropertyInsertionReplacements(document, objectLiteral, getObjectLiteralPropertyInsertionOffset(sourceFile, objectLiteral), propertyText);
+}
+function getObjectLiteralPropertyInsertionOffset(sourceFile, objectLiteral) {
+	const propertiesEnd = objectLiteral.properties.end;
+	const objectEnd = objectLiteral.getEnd() - 1;
+	const trailingTrivia = sourceFile.text.slice(propertiesEnd, objectEnd);
+	const commentMatch = /^[ \t]*(\/\/|\/\*)/.exec(trailingTrivia);
+	if (!commentMatch) return propertiesEnd;
+	const commentStart = propertiesEnd + commentMatch.index + commentMatch[0].length - 2;
+	if (commentMatch[1] === "//") {
+		const lineFeed = sourceFile.text.indexOf("\n", commentStart);
+		const lineEnd = lineFeed === -1 ? objectEnd : Math.min(lineFeed, objectEnd);
+		return lineEnd > commentStart && sourceFile.text.charCodeAt(lineEnd - 1) === 13 ? lineEnd - 1 : lineEnd;
+	}
+	const commentEnd = sourceFile.text.indexOf("*/", commentStart + 2);
+	return commentEnd === -1 ? propertiesEnd : Math.min(commentEnd + 2, objectEnd);
+}
+function createObjectPropertyInsertionReplacements(document, objectLiteral, insertionOffset, propertyText) {
+	const propertiesEnd = objectLiteral.properties.end;
+	const needsComma = objectLiteral.properties.length > 0 && !objectLiteral.properties.hasTrailingComma;
+	const replacements = [createOffsetReplacement(document, insertionOffset, insertionOffset, `${needsComma && insertionOffset === propertiesEnd ? "," : ""}${propertyText}`)];
+	if (needsComma && insertionOffset !== propertiesEnd) replacements.push(createOffsetReplacement(document, propertiesEnd, propertiesEnd, ","));
+	return replacements;
 }
 function getArrayElementDeletionRange(sourceFile, arrayLiteral, element) {
 	const elements = [...arrayLiteral.elements];
@@ -1582,14 +1612,16 @@ function createImplementationCreateReplacements(document, sourceFile, implementa
 	if (!implementation.id || !implementationCode) return null;
 	const categoryObject = getObjectLiteralProperty(implementationRoot, categoryName);
 	if (!categoryObject) {
-		const text = objectPropertyTextForInsertion(implementationRoot, `${propertyNameTextForSource(categoryName)}: {\n${getIndentForNewObjectProperty(sourceFile, implementationRoot)}${propertyNameTextForSource(implementation.id)}: ${implementationCode},\n${getIndentForObjectClose(sourceFile, implementationRoot)}}`);
-		return [createOffsetReplacement(document, implementationRoot.properties.end, implementationRoot.properties.end, text)];
+		const propertyText = objectPropertyTextForInsertion(implementationRoot, `${propertyNameTextForSource(categoryName)}: {\n${getIndentForNewObjectProperty(sourceFile, implementationRoot)}${propertyNameTextForSource(implementation.id)}: ${implementationCode},\n${getIndentForObjectClose(sourceFile, implementationRoot)}}`);
+		return createObjectPropertyInsertionReplacements(document, implementationRoot, getObjectLiteralPropertyInsertionOffset(sourceFile, implementationRoot), propertyText);
 	}
-	const text = objectPropertyTextForInsertion(categoryObject, `${propertyNameTextForSource(implementation.id)}: ${implementationCode}`);
-	return [createOffsetReplacement(document, categoryObject.properties.end, categoryObject.properties.end, text)];
+	const propertyText = objectPropertyTextForInsertion(categoryObject, `${propertyNameTextForSource(implementation.id)}: ${implementationCode}`);
+	return createObjectPropertyInsertionReplacements(document, categoryObject, getObjectLiteralPropertyInsertionOffset(sourceFile, categoryObject), propertyText);
 }
 function objectPropertyTextForInsertion(objectLiteral, propertyText) {
-	return `${objectLiteral.properties.length > 0 ? "," : ""}${getLineBreak(objectLiteral.getSourceFile())}${getIndentForNewObjectProperty(objectLiteral.getSourceFile(), objectLiteral)}${propertyText}`;
+	const lineBreak = getLineBreak(objectLiteral.getSourceFile());
+	const indent = getIndentForNewObjectProperty(objectLiteral.getSourceFile(), objectLiteral);
+	return `${lineBreak}${indent}${propertyText.startsWith(indent) ? propertyText.slice(indent.length) : propertyText}`;
 }
 function getLineBreak(sourceFile) {
 	return sourceFile.text.includes("\r\n") ? "\r\n" : "\n";
@@ -1885,7 +1917,7 @@ function getObjectLiteralPropertyDeletionRange(sourceFile, objectLiteral, proper
 	const propertyEnd = property.getEnd();
 	if (properties.length === 1) return {
 		start: propertyStart,
-		end: propertyEnd
+		end: objectLiteral.properties.hasTrailingComma ? objectLiteral.properties.end : propertyEnd
 	};
 	if (propertyIndex === properties.length - 1) {
 		const previousProperty = properties[propertyIndex - 1];
@@ -2253,6 +2285,21 @@ function createReplacement(document, sourceFile, node, value) {
 		newText: printExpression(valueToExpression(value, node), sourceFile, formatting)
 	};
 }
+function createRewriteReplacement(document, sourceFile, node, value) {
+	const start = document.positionAt(node.getStart(sourceFile));
+	const end = document.positionAt(node.getEnd());
+	const formatting = getFormattingContext(document, sourceFile, node);
+	return {
+		uri: getDocumentUri(document),
+		range: {
+			startLine: start.line,
+			startChar: start.character,
+			endLine: end.line,
+			endChar: end.character
+		},
+		newText: printExpression(valueToExpression(value), sourceFile, formatting)
+	};
+}
 function addCodeImportReplacements(document, sourceFile, machineConfig, replacements) {
 	const importReplacements = createCodeImportReplacements(document, sourceFile, collectCodeImports(machineConfig));
 	return [...replacements, ...importReplacements];
@@ -3164,11 +3211,12 @@ const xstateAdapter = {
 		return collectXStateSourceLocations(text, document, options);
 	},
 	async applyMachineToDocument(machineConfig, document, options) {
-		const rootSourceLocation = collectXStateSourceLocations(document.getText(), document, { machineIndex: options?.machineIndex })?.root ?? options?.sourceLocations?.root;
+		const detectedSourceLocations = collectXStateSourceLocations(document.getText(), document, { machineIndex: options?.machineIndex });
+		const rootSourceLocation = options?.sourceLocations?.root ?? detectedSourceLocations?.root;
 		const sanitizedMachineConfig = options?.preserveStatelyMetadata === false ? stripStatelyMetadata(machineConfig) : machineConfig;
 		if (!options?.patches?.length) return [];
 		const replacements = await applyMachineToSourceDocuments(sanitizedMachineConfig, document, options);
-		if (replacements.some(containsXStateExpressionPlaceholder) || replacements.some((replacement) => isImplicitRootReplacement(replacement, rootSourceLocation))) return [];
+		if (replacements.some(containsXStateExpressionPlaceholder) || options?.sourceUpdateStrategy !== "rewrite" && replacements.some((replacement) => isImplicitRootReplacement(replacement, rootSourceLocation))) return [];
 		return replacements;
 	}
 };
@@ -3502,7 +3550,7 @@ async function extractMachinesFromLocalSource(sourcePath, contents, machineIndex
 		return { machines: extractMachineConfigsFromAst(sourcePath, parseSourceToMachine(contents, createTextDocument(sourcePath, contents), {
 			machineIndex,
 			resolver: createFileSourceDocumentResolver()
-		}), machineIndex) };
+		}), machineIndex === void 0 ? void 0 : 0) };
 	} catch (error) {
 		return {
 			machines: [],