statelyai 0.12.2 → 0.12.4

package/dist/{cli-DkgwcbvD.mjs → cli-_FAuSk1y.mjs}

@@ -6877,13 +6877,13 @@ function getDefaultPathId(graph, node) {
 	if (!node.parentId) return getRootEmittedId(graph, node) ?? "(machine)";
 	const parentNode = graph.nodes.find((candidate) => candidate.id === node.parentId);
 	if (!parentNode) return node.data.key;
-	return `${getResolvedNodeId(graph, parentNode)}.${node.data.key}`;
+	return `${getDefaultPathId(graph, parentNode)}.${node.data.key}`;
 }
 function getEmittedNodeId(graph, node) {
 	const authored = getAuthoredNodeId(node);
 	if (!node.parentId) return getRootEmittedId(graph, node);
 	if (!authored) return void 0;
-	return authored === getDefaultPathId(graph, node) ? void 0 : authored;
+	return authored;
 }
 function getResolvedNodeId(graph, node) {
 	return getEmittedNodeId(graph, node) ?? getDefaultPathId(graph, node);
@@ -6908,14 +6908,15 @@ function containsCodeExpression(value, seen = /* @__PURE__ */ new WeakSet()) {
 */
 const VALID_IDENT = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 var RawCode = class {
-	constructor(code, sourceValue, sourceSlice) {
+	constructor(code, sourceValue, sourceSlice, preserveWhitespace = false) {
 		this.code = code;
 		this.sourceValue = sourceValue;
 		this.sourceSlice = sourceSlice;
+		this.preserveWhitespace = preserveWhitespace;
 	}
 };
-function raw(code, sourceValue, sourceSlice) {
-	return new RawCode(code, sourceValue, sourceSlice);
+function raw(code, sourceValue, sourceSlice, preserveWhitespace = false) {
+	return new RawCode(code, sourceValue, sourceSlice, preserveWhitespace);
 }
 const SERIALIZED_SOURCE_ID = "__stately_source_id__";
 function serializeJS(value, indent = 0, step = 2) {
@@ -6963,6 +6964,7 @@ function serializeObject(obj, indent, step) {
 }
 function preservesAuthoredWhitespace(value) {
 	if (isCodeExpression(value)) return true;
+	if (value instanceof RawCode && value.preserveWhitespace) return true;
 	const sourceValue = value instanceof RawCode ? value.sourceValue : value;
 	return Boolean(sourceValue && typeof sourceValue === "object" && SERIALIZED_SOURCE_ID in sourceValue);
 }
@@ -7057,7 +7059,7 @@ function resolveTransitionTarget(graph, sourceNode, targetNode) {
 	const keys = [];
 	let current = targetNode;
 	while (current) {
-		keys.unshift(current.data.key);
+		keys.unshift(current.data.key.replace(/\\/g, "\\\\").replace(/\./g, "\\."));
 		if (current.parentId === baseId) {
 			if (isRootSource) return `.${keys.join(".")}`;
 			return keys.join(".");
@@ -7142,13 +7144,13 @@ function deepSimplify(config) {
 	if (config.states && typeof config.states === "object") for (const stateConfig of Object.values(config.states)) deepSimplify(stateConfig);
 	return config;
 }
-function buildMeta(meta, color) {
+function buildMeta(meta, color, showStatelyMeta = true) {
 	if (isCodeExpression(meta)) return meta;
 	const result = {};
 	if (meta) {
-		for (const [k, v] of Object.entries(meta)) if (v !== void 0 && v !== null) result[k] = v;
+		for (const [k, v] of Object.entries(meta)) if (v !== void 0 && v !== null && (showStatelyMeta || !k.startsWith("@statelyai"))) result[k] = v;
 	}
-	if (color) result["@statelyai.color"] = color;
+	if (color && showStatelyMeta) result["@statelyai.color"] = color;
 	return Object.keys(result).length > 0 ? result : void 0;
 }
 /** Format event param — supports { type: string } (new) and plain string (legacy) */
@@ -7444,8 +7446,11 @@ function tagToString(tag) {
 }
 function graphToMachineConfig(graph, options = {}) {
 	const v6 = isXStateV6Profile(graph.data.profile);
-	const { showDescriptions = true, showMeta = true, inlineGuardsAsTypeRef = false, keepChooseStructured = false } = options;
-	const serializeAction = (action) => serializeActionItem(action, keepChooseStructured);
+	const { showDescriptions = true, showMeta = true, showStatelyMeta = true, inlineGuardsAsTypeRef = false, keepChooseStructured = false, timerActionsAsTypeRef = false } = options;
+	const serializeAction = (action) => timerActionsAsTypeRef && ["xstate.raise", "xstate.cancel"].includes(action.type) ? {
+		type: action.type,
+		params: action.params
+	} : serializeActionItem(action, keepChooseStructured);
 	const config = {};
 	function getNodeConfig(node) {
 		const nodeConfig = node.parentId ? {} : config;
@@ -7458,7 +7463,15 @@ function graphToMachineConfig(graph, options = {}) {
 			"choice"
 		].includes(node.data.type) ? node.data.type : void 0;
 		const tags = node.data.tags;
-		const stateMeta = showMeta ? buildMeta(node.data.meta, node.data.color) : void 0;
+		const stateMeta = showMeta ? buildMeta({
+			...node.data.meta,
+			...node.data.assets?.length ? { "@statelyai.assets": node.data.assets.map(({ type, url, size }) => ({
+				type,
+				url,
+				...size ? { size } : {}
+			})) } : {},
+			...node.data.appearance ? { "@statelyai.appearance": node.data.appearance } : {}
+		}, node.data.color, showStatelyMeta) : void 0;
 		Object.assign(nodeConfig, {
 			id: resolvedNodeId,
 			type: nodeType === "normal" ? void 0 : nodeType ?? void 0,
@@ -7490,6 +7503,8 @@ function graphToMachineConfig(graph, options = {}) {
 		const edges = graph.edges.filter((edge) => edge.sourceId === node.id && !edge.data.temp);
 		if (edges.length > 0) {
 			const on = {};
+			const transitionOrder = /* @__PURE__ */ new Map();
+			const scxmlTransitions = [];
 			const after = {};
 			const alwaysArr = [];
 			const choiceArr = [];
@@ -7505,7 +7520,15 @@ function graphToMachineConfig(graph, options = {}) {
 					return additionalTarget ? [resolveTransitionTarget(graph, node, additionalTarget)] : [];
 				})].filter(Boolean);
 				const type = edge.data.eventType ?? "";
-				const transitionMeta = showMeta ? buildMeta(edge.data.meta, edge.data.color) : void 0;
+				const transitionMeta = showMeta ? buildMeta({
+					...edge.data.meta,
+					...edge.data.assets?.length ? { "@statelyai.assets": edge.data.assets.map(({ type, url, size }) => ({
+						type,
+						url,
+						...size ? { size } : {}
+					})) } : {},
+					...edge.data.appearance ? { "@statelyai.appearance": edge.data.appearance } : {}
+				}, edge.data.color, showStatelyMeta) : void 0;
 				const transitionObject = {
 					...edge.data.matches ? { matches: edge.data.matches } : void 0,
 					target: edge.data.transitionType === "targetless" ? void 0 : resolvedTargets.length > 1 ? resolvedTargets : `${resolvedTarget}`,
@@ -7514,9 +7537,10 @@ function graphToMachineConfig(graph, options = {}) {
 					...edge.data.context !== void 0 ? { context: edge.data.context } : void 0,
 					...edge.data.input !== void 0 ? { input: edge.data.input } : void 0,
 					actions: edge.data.actions?.length ? edge.data.actions.map(serializeAction) : void 0,
-					description: edge.data.description ?? void 0,
+					description: showDescriptions ? edge.data.description ?? void 0 : void 0,
 					...transitionMeta ? { meta: transitionMeta } : void 0
 				};
+				transitionOrder.set(transitionObject, transitionOrder.size);
 				const pushOn = (key) => {
 					if (!on[key]) on[key] = [];
 					on[key].push(transitionObject);
@@ -7559,7 +7583,11 @@ function graphToMachineConfig(graph, options = {}) {
 					const delayKey = getDelayKeyFromEventType(type, edge.sourceId);
 					if (!after[delayKey]) after[delayKey] = [];
 					after[delayKey].push(transitionObject);
-				} else if (type === "*") pushOn("*");
+				} else if (edge.data.meta?.["@statelyai.scxml.eventDescriptor"]) scxmlTransitions.push({
+					descriptor: type,
+					transition: transitionObject
+				});
+				else if (type === "*") pushOn("*");
 				else if (type.startsWith("xstate.done.state")) {
 					if (!onDone[type]) onDone[type] = [];
 					onDone[type].push(transitionObject);
@@ -7570,6 +7598,16 @@ function graphToMachineConfig(graph, options = {}) {
 					else pushOn(type);
 				} else pushOn(type);
 			}
+			const descriptorBase = (descriptor) => descriptor.replace(/\.\*$/, "");
+			const scxmlKeys = new Set([...Object.keys(on), ...scxmlTransitions.flatMap(({ descriptor }) => descriptor === "*" ? ["*"] : descriptorBase(descriptor) ? [descriptorBase(descriptor), `${descriptorBase(descriptor)}.*`] : [])]);
+			for (const key of scxmlKeys) {
+				const base = descriptorBase(key);
+				const matching = scxmlTransitions.filter(({ descriptor }) => {
+					const prefix = descriptorBase(descriptor);
+					return descriptor === "*" || base === prefix || base.startsWith(`${prefix}.`);
+				}).map(({ transition }) => transition);
+				on[key] = [...new Set([...on[key] ?? [], ...matching])].sort((a, b) => (transitionOrder.get(a) ?? 0) - (transitionOrder.get(b) ?? 0));
+			}
 			if (Object.keys(on).length > 0) nodeConfig.on = singleOrArrayRecord(on);
 			if (Object.keys(after).length > 0) nodeConfig.after = singleOrArrayRecord(after);
 			if (alwaysArr.length > 0) nodeConfig.always = singleOrArray(alwaysArr);
@@ -8541,6 +8579,10 @@ function transitionFromValue(value, actions) {
 	}
 	if (!value || typeof value !== "object" || Array.isArray(value)) return actions.length ? { actions } : null;
 	const record = { ...value };
+	if ((Array.isArray(record.target) ? record.target : [record.target]).some(isCodeExpression)) record.meta = {
+		...record.meta,
+		[XSTATE_V6_UNRESOLVED_TARGET_META]: true
+	};
 	if (actions.length) record.actions = mergeActions(Array.isArray(record.actions) ? record.actions : record.actions ? [record.actions] : void 0, actions);
 	return record;
 }
@@ -8864,7 +8906,7 @@ function omitIdentityTransitionContext(transition, identity) {
 function normalizeFunctionTransition(fn, bindings, depth) {
 	if (fn.body && ts.isBlock(fn.body) && hasUnsafeVariableInitializer(fn.body)) return fallbackFunctionTransition(fn);
 	const branches = ts.isArrowFunction(fn) && !ts.isBlock(fn.body) ? expressionBranches(fn.body, bindings, depth + 1) : fn.body && ts.isBlock(fn.body) ? statementBranches(fn.body.statements, bindings, enqueueParamName(fn)) : [];
-	if (branches.some((branch) => branch.unknown)) return fallbackFunctionTransition(fn);
+	if (branches.some((branch) => branch.unknown || isCodeExpression(branch.result))) return fallbackFunctionTransition(fn);
 	const contextIdentity = transitionContextIdentity(fn);
 	const transitions = branches.map((branch) => {
 		let result = branch.result;
@@ -9300,6 +9342,7 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 			if (builtIn) return builtIn;
 			return inlineAction(node);
 		}
+		if (context.v6 && context.transitionValue) return inlineCodeExpression(resolvedExpressionText(node, bindings));
 		const callee = node.expression.getText();
 		const type = callee.includes(".") ? callee.split(".").pop() : callee;
 		return { type: type === "assign" ? "xstate.assign" : type };
@@ -10107,8 +10150,9 @@ function mapV6MachineConfig(value, context = {}) {
 			result[key] = mapV6StatesMap(item);
 			continue;
 		}
-		if (key === "choice") {
-			result[key] = buildV6TransitionFunction(Array.isArray(item) ? item : [item]) ?? mapV6MachineConfig(item, { transitionValue: true });
+		if (key === "choice" && value.type === "choice") {
+			const choices = Array.isArray(item) ? item : [item];
+			result[key] = choices.length === 1 && opaqueTransitionSource(choices[0]) !== void 0 ? toV6TransitionValue(item) : buildV6TransitionFunction(choices.map(withoutOpaqueTransitionMeta), true) ?? toV6TransitionValue(item);
 			continue;
 		}
 		if (key === "entry" || key === "exit" || key === "actions") {
@@ -10140,10 +10184,44 @@ function mapV6TransitionMap(value) {
 	for (const [key, item] of Object.entries(value)) result[key] = mapV6MachineConfig(item, { transitionValue: true });
 	return result;
 }
+/**
+* The authored source of a transition function the importer could not
+* analyze. It projects to one opaque edge, so the source is still exactly what
+* the edge represents.
+*/
+function opaqueTransitionSource(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const transition = value;
+	const meta = transition.meta;
+	const fnSource = meta?.[XSTATE_V6_FN_SOURCE_META];
+	const hasGraphEdits = Object.entries(transition).some(([key, field]) => key !== "meta" && field !== void 0);
+	return meta?.[XSTATE_V6_FN_TRANSITION_META] === true && typeof fnSource === "string" && !hasGraphEdits ? fnSource : void 0;
+}
+function withoutOpaqueTransitionMeta(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	const transition = value;
+	const meta = transition.meta;
+	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return value;
+	const { [XSTATE_V6_FN_TRANSITION_META]: _fnTransition, [XSTATE_V6_FN_SOURCE_META]: _fnSource, ...publicMeta } = meta;
+	if (_fnTransition === void 0 && _fnSource === void 0) return value;
+	return {
+		...transition,
+		meta: Object.keys(publicMeta).length > 0 ? publicMeta : void 0
+	};
+}
 function toV6TransitionValue(value) {
-	if (Array.isArray(value)) return buildV6TransitionFunction(value) ?? value.map((item) => toV6TransitionValue(item));
+	const opaqueSource = opaqueTransitionSource(value);
+	if (opaqueSource !== void 0) return raw(opaqueSource, value, void 0, true);
+	if (Array.isArray(value)) {
+		if (value.length === 1) {
+			const onlyOpaqueSource = opaqueTransitionSource(value[0]);
+			if (onlyOpaqueSource !== void 0) return raw(onlyOpaqueSource, value[0], void 0, true);
+		}
+		const transitions = value.map(withoutOpaqueTransitionMeta);
+		return buildV6TransitionFunction(transitions) ?? transitions.map((item) => toV6TransitionValue(item));
+	}
 	if (!value || typeof value !== "object") return value;
-	const transition = value;
+	const transition = withoutOpaqueTransitionMeta(value);
 	if (transition.matches !== void 0) return buildV6TransitionFunction([transition]) ?? mapV6MachineConfig(transition);
 	if (transition.guard) return buildV6TransitionFunction([transition]) ?? mapV6MachineConfig(transition);
 	if (transition.description || transition.input !== void 0 && !containsCodeExpression(transition.input)) return mapV6MachineConfig(transition);
@@ -10294,11 +10372,11 @@ function mergeV6FirstParam(authoredFirstParam, inferred) {
 		prelude: []
 	};
 }
-function buildV6TransitionFunction(transitions) {
+function buildV6TransitionFunction(transitions, choice = false) {
 	const transitionObjects = transitions.every((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)) ? transitions : void 0;
 	if (!transitionObjects?.length) return;
 	const descriptions = transitionObjects.map((transition) => typeof transition.description === "string" ? transition.description : void 0);
-	const hasBranchDescriptions = transitionObjects.some((transition) => Object.prototype.hasOwnProperty.call(transition.meta ?? {}, XSTATE_V6_BRANCH_DESCRIPTION_META)) || descriptions.some((description) => description !== descriptions[0]);
+	const hasBranchDescriptions = choice && descriptions.some((description) => description !== void 0) || transitionObjects.some((transition) => Object.prototype.hasOwnProperty.call(transition.meta ?? {}, XSTATE_V6_BRANCH_DESCRIPTION_META)) || descriptions.some((description) => description !== descriptions[0]);
 	const branches = [];
 	let authoredFirstParam;
 	const commonDescription = descriptions[0];
@@ -10334,7 +10412,7 @@ function buildV6TransitionFunction(transitions) {
 		});
 	}
 	if (branches.length === 0) return;
-	if (branches.slice(0, -1).some((branch) => branch.condition === "true")) return;
+	if (!choice && branches.slice(0, -1).some((branch) => branch.condition === "true")) return;
 	const generated = branches.flatMap((branch) => [branch.condition, ...branch.body]).join("\n");
 	let renderedBranches = branches;
 	let merged = mergeV6FirstParam(authoredFirstParam, inferV6ArgBindings(generated));
@@ -10347,7 +10425,7 @@ function buildV6TransitionFunction(transitions) {
 	}
 	if (!merged) return;
 	const lines = merged.prelude.map((statement) => indentV6Code(statement, 2));
-	for (const branch of renderedBranches) if (branch.condition === "true") lines.push(...branch.body.map((line) => indentV6Code(line, 2)));
+	for (const [index, branch] of renderedBranches.entries()) if (branch.condition === "true" && index === renderedBranches.length - 1) lines.push(...branch.body.map((line) => indentV6Code(line, 2)));
 	else {
 		lines.push(indentV6Code(`if (${branch.condition}) {`, 2));
 		lines.push(...branch.body.map((line) => indentV6Code(line, 4)));
@@ -10937,6 +11015,51 @@ function isCompleteFunctionExpression(code) {
 	if (!expression) return false;
 	return ts.isFunctionExpression(expression) || ts.isArrowFunction(expression);
 }
+function isMachineCode(value) {
+	return !!value && typeof value === "object" && typeof value["@code"] === "string" && typeof value["@lang"] === "string";
+}
+function hasMachineCode(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isMachineCode(value)) return true;
+	if (!value || typeof value !== "object" || seen.has(value)) return false;
+	seen.add(value);
+	return Object.values(value).some((child) => hasMachineCode(child, seen));
+}
+function parse$2(source) {
+	return ts.createSourceFile("inspection.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+}
+function expressionSource(source) {
+	if (!parse$2(`const value = (${source});`).parseDiagnostics.length) return source;
+	const methodFile = parse$2(`const value = {${source}};`);
+	const statement = methodFile.statements[0];
+	if (!methodFile.parseDiagnostics.length && statement && ts.isVariableStatement(statement)) {
+		const initializer = statement.declarationList.declarations[0]?.initializer;
+		const method = initializer && ts.isObjectLiteralExpression(initializer) ? initializer.properties[0] : void 0;
+		if (method && ts.isMethodDeclaration(method) && method.body) return `${method.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ? "async " : ""}function${method.asteriskToken ? "*" : ""}(${method.parameters.map((param) => param.getText(methodFile)).join(", ")}) ${method.body.getText(methodFile)}`;
+	}
+	return "() => __stately_inspection_unknown__()";
+}
+/** Project runtime MachineJSON code through the same static parser as authored v6 source. */
+function projectMachineJSON(config) {
+	if (!hasMachineCode(config)) return config;
+	function expressions(value) {
+		if (isMachineCode(value)) return raw(["ts", "js"].includes(value["@lang"]) ? expressionSource(value["@code"]) : "() => __stately_inspection_unknown__()");
+		if (Array.isArray(value)) return value.map(expressions);
+		if (!value || typeof value !== "object") return value;
+		return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, expressions(item)]));
+	}
+	const projected = xstateSourceToConfig(`createMachine(${serializeJS(expressions(config))});`, { profile: "xstate-v6-alpha" });
+	function restoreSchemas(original, parsed) {
+		if (!original || !parsed || typeof original !== "object" || typeof parsed !== "object") return;
+		const source = original;
+		const result = parsed;
+		if (Object.hasOwn(source, "schemas")) result.schemas = source.schemas;
+		const states = source.states;
+		const parsedStates = result.states;
+		for (const key of Object.keys(states ?? {})) restoreSchemas(states[key], parsedStates?.[key]);
+	}
+	restoreSchemas(config, projected);
+	return projected;
+}
 /**
 * A compound state node with no usable `initial` cannot be simulated (XState
 * throws "No initial state specified for compound state node"). This walks a
@@ -11056,6 +11179,7 @@ function actorImplementationItems(value) {
 	}));
 }
 function machineConfigToGraph(config, options = {}) {
+	if (isXStateV6Profile(options.profile)) config = projectMachineJSON(config);
 	const rootState = config;
 	const rootConfig = config;
 	const rootKey = String(rootState.id ?? "machine");
@@ -13027,31 +13151,9 @@ var ParseErrorCode;
 function modify(text, path, value, options) {
 	return setProperty(text, path, value, options);
 }
-/**
-* Applies edits to an input string.
-* @param text The input text
-* @param edits Edit operations following the format described in {@linkcode EditResult}.
-* @returns The text with the applied edits.
-* @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
-*/
-function applyEdits(text, edits) {
-	let sortedEdits = edits.slice(0).sort((a, b) => {
-		const diff = a.offset - b.offset;
-		if (diff === 0) return a.length - b.length;
-		return diff;
-	});
-	let lastModifiedOffset = text.length;
-	for (let i = sortedEdits.length - 1; i >= 0; i--) {
-		let e = sortedEdits[i];
-		if (e.offset + e.length <= lastModifiedOffset) text = applyEdit(text, e);
-		else throw new Error("Overlapping edit");
-		lastModifiedOffset = e.offset;
-	}
-	return text;
-}
 
 //#endregion
-//#region ../editor-sync/dist/adapters-gXgLug6Z.mjs
+//#region ../editor-sync/dist/adapters-Dt77BFUa.mjs
 const sourceFileUris = /* @__PURE__ */ new WeakMap();
 function collectXStateSourceLocations(sourceText, document, options = {}) {
 	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(document.fileName));
@@ -13237,11 +13339,21 @@ function addImportedStaticValueBindings(bindings, sourceFile, uri, fileName, opt
 		}, statement.moduleSpecifier.text);
 		if (!importedDocument) continue;
 		for (const element of namedBindings.elements) {
-			const binding = resolveExportedStaticValue(importedDocument, element.propertyName?.text ?? element.name.text, resolver, /* @__PURE__ */ new Set());
-			if (binding) bindings.set(element.name.text, {
-				...binding,
-				symbol: element.name.text
-			});
+			const importedName = element.propertyName?.text ?? element.name.text;
+			const members = new Set([""]);
+			const visit = (node) => {
+				if (ts$1.isPropertyAccessExpression(node) && ts$1.isIdentifier(node.expression) && node.expression.text === element.name.text) members.add(`.${node.name.text}`);
+				ts$1.forEachChild(node, visit);
+			};
+			visit(sourceFile);
+			for (const member of members) {
+				const binding = resolveExportedStaticValue(importedDocument, `${importedName}${member}`, resolver, /* @__PURE__ */ new Set());
+				const symbol = `${element.name.text}${member}`;
+				if (binding) bindings.set(symbol, {
+					...binding,
+					symbol
+				});
+			}
 		}
 	}
 }
@@ -13254,15 +13366,21 @@ function resolveExportedStaticValue(document, exportName, resolver, visited) {
 		sourceFileUris.set(sourceFile, document.uri);
 		const localBindings = collectStaticValueBindings(sourceFile);
 		const localBinding = localBindings.get(exportName);
-		if (localBinding && sourceFile.statements.some((statement) => ts$1.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts$1.SyntaxKind.ExportKeyword) && statement.declarationList.declarations.some((declaration) => ts$1.isIdentifier(declaration.name) && declaration.name.text === exportName))) return localBinding;
+		const [exportedSymbol] = exportName.split(".");
+		const memberSuffix = exportName.slice(exportedSymbol.length);
+		if (localBinding && sourceFile.statements.some((statement) => {
+			if (!ts$1.isVariableStatement(statement) && !ts$1.isEnumDeclaration(statement)) return false;
+			if (!statement.modifiers?.some((modifier) => modifier.kind === ts$1.SyntaxKind.ExportKeyword)) return false;
+			return ts$1.isEnumDeclaration(statement) ? statement.name.text === exportedSymbol : statement.declarationList.declarations.some((declaration) => ts$1.isIdentifier(declaration.name) && declaration.name.text === exportName);
+		})) return localBinding;
 		const exports = sourceFile.statements.filter(ts$1.isExportDeclaration);
 		for (const statement of exports) {
 			if (!statement.exportClause || !ts$1.isNamedExports(statement.exportClause)) continue;
 			const specifier = statement.moduleSpecifier && ts$1.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : null;
 			const exportedDocument = specifier?.startsWith(".") ? resolver.resolveImport(document, specifier) : null;
 			for (const element of statement.exportClause.elements) {
-				if (element.name.text !== exportName) continue;
-				const localName = element.propertyName?.text ?? element.name.text;
+				if (element.name.text !== exportedSymbol) continue;
+				const localName = `${element.propertyName?.text ?? element.name.text}${memberSuffix}`;
 				if (exportedDocument) {
 					const binding = resolveExportedStaticValue(exportedDocument, localName, resolver, visited);
 					return binding && {
@@ -13298,15 +13416,17 @@ function resolveExportedStaticValue(document, exportName, resolver, visited) {
 	}
 }
 function resolveImportedStaticValue(sourceFile, document, localName, resolver, visited) {
+	const [localSymbol] = localName.split(".");
+	const memberSuffix = localName.slice(localSymbol.length);
 	for (const statement of sourceFile.statements) {
 		if (!ts$1.isImportDeclaration(statement) || !ts$1.isStringLiteral(statement.moduleSpecifier) || !statement.moduleSpecifier.text.startsWith(".")) continue;
 		const namedBindings = statement.importClause?.namedBindings;
 		if (!namedBindings || !ts$1.isNamedImports(namedBindings)) continue;
-		const imported = namedBindings.elements.find((element) => element.name.text === localName);
+		const imported = namedBindings.elements.find((element) => element.name.text === localSymbol);
 		if (!imported) continue;
 		const importedDocument = resolver.resolveImport(document, statement.moduleSpecifier.text);
 		if (!importedDocument) return null;
-		return resolveExportedStaticValue(importedDocument, imported.propertyName?.text ?? imported.name.text, resolver, visited);
+		return resolveExportedStaticValue(importedDocument, `${imported.propertyName?.text ?? imported.name.text}${memberSuffix}`, resolver, visited);
 	}
 	return null;
 }
@@ -14195,8 +14315,9 @@ async function applyMachineToSourceDocuments(machineConfig, document, options =
 	let semanticReplacements = semanticSplit?.replacements ?? [];
 	if (activePatches.length === 0) return finalize(semanticReplacements);
 	const transitionSplit = await tryCreateTransitionPatchSplitForDocuments(document, sourceFile, machineConfigNode, machineConfig, activePatches, prevGraph, nextGraph, activeSourceLocations, options.openTextDocument);
-	if (transitionSplit && transitionSplit.remainingPatches.length === 0) return finalize([...semanticReplacements, ...transitionSplit.replacements]);
-	if (transitionSplit) semanticReplacements = [...semanticReplacements, ...transitionSplit.replacements];
+	const transitionReplacements = transitionSplit ? combineSemanticAndTransitionReplacements(semanticReplacements, transitionSplit.replacements) : semanticReplacements;
+	if (transitionSplit && transitionSplit.remainingPatches.length === 0) return finalize(transitionReplacements);
+	if (transitionSplit) semanticReplacements = transitionReplacements;
 	const implementationSplit = tryCreateImplementationPatchSplit(document, sourceFile, transitionSplit?.remainingPatches ?? activePatches, nextGraph, options.machineIndex);
 	if (implementationSplit && implementationSplit.remainingPatches.length === 0) return finalize([...semanticReplacements, ...implementationSplit.replacements]);
 	if (implementationSplit) semanticReplacements = [...semanticReplacements, ...implementationSplit.replacements];
@@ -14673,7 +14794,17 @@ 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);
+	if (onObject) {
+		const nextOn = getStateConfigByPath(machineConfig, transitionTarget.sourcePath)?.on;
+		if (isMachineConfig(nextOn) && !onObject.properties.some((property) => {
+			const key = property.name && getPropertyNameText$2(property.name);
+			return !key || nextOn[key] !== void 0;
+		})) return [createObjectLiteralPropertiesInsertion(targetDocument, targetSourceFile, onObject, [{
+			key: transitionTarget.eventType,
+			config: nextTransitionValue
+		}], false)];
+		return createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, onObject, transitionTarget.eventType, nextTransitionValue);
+	}
 	return createObjectLiteralPropertyInsertion(targetDocument, targetSourceFile, stateObject, "on", { [transitionTarget.eventType]: nextTransitionValue });
 }
 async function createV6BranchActionNameReplacementForDocuments(document, sourceFile, machineConfigNode, patch, transitionTarget, prevGraph, nextGraph, sourceLocations, openTextDocument) {
@@ -14820,7 +14951,10 @@ async function createStatePropertiesReplacementForDocuments(document, sourceFile
 						config: nextSlotValue
 					});
 				}
-				if (insertedSlots.length > 0) replacements.push(createObjectLiteralPropertiesInsertion(targetDocument, targetSourceFile, existingMap, insertedSlots));
+				if (insertedSlots.length > 0) replacements.push(createObjectLiteralPropertiesInsertion(targetDocument, targetSourceFile, existingMap, insertedSlots, existingMap.properties.some((property) => {
+					const key = property.name && getPropertyNameText$2(property.name);
+					return !key || !affectedSlots.has(key) || nextValue[key] !== void 0;
+				})));
 				continue;
 			}
 		}
@@ -15499,7 +15633,7 @@ function createStateMembershipInitialReplacements(document, sourceFile, parentOb
 		config: nextInitial
 	}])];
 }
-function createObjectLiteralPropertiesInsertion(document, sourceFile, objectLiteral, entries) {
+function createObjectLiteralPropertiesInsertion(document, sourceFile, objectLiteral, entries, hasRetainedProperties = objectLiteral.properties.length > 0) {
 	const formatting = getFormattingContext(document, sourceFile, objectLiteral);
 	const lineSeparator = formatting.newLineKind === ts$1.NewLineKind.CarriageReturnLineFeed ? "\r\n" : "\n";
 	const propertyTexts = entries.map((entry) => printObjectLiteralProperty(entry.key, entry.config, sourceFile, formatting));
@@ -15508,7 +15642,7 @@ function createObjectLiteralPropertiesInsertion(document, sourceFile, objectLite
 	const startOffset = existingProperties.length === 0 ? closeBraceOffset : existingProperties[existingProperties.length - 1].getEnd();
 	const start = document.positionAt(startOffset);
 	const end = document.positionAt(closeBraceOffset);
-	const prefix = existingProperties.length === 0 ? lineSeparator : `,${lineSeparator}`;
+	const prefix = hasRetainedProperties ? `,${lineSeparator}` : lineSeparator;
 	const suffix = `${lineSeparator}${formatting.baseIndent}`;
 	return {
 		uri: getDocumentUri(document),
@@ -16219,8 +16353,8 @@ function createStateKeyRenameReplacementsForTarget(document, sourceFile, parentO
 	}
 	const supportedScope = new Set([rename.parentPath.join("."), ...getDirectChildStatePaths(nodeKind === "statesObject" ? initialOwnerObject : parentObject, rename.parentPath).map((path) => path.join("."))]);
 	for (const target of targetLiterals) {
-		if (!referencesRenamedState(target.node.text, rename)) continue;
-		if (!referencesRenamedAbsoluteState(target.node.text, rename)) {
+		if (!referencesRenamedState(target.value, rename)) continue;
+		if (!referencesRenamedAbsoluteState(target.value, rename)) {
 			const initialSourcePaths = target.initialSourcePaths ?? [];
 			if (initialSourcePaths.length > 0) {
 				if (!target.sourcePaths.every((sourcePath) => arePathsEqual(sourcePath, rename.parentPath))) {
@@ -16232,7 +16366,7 @@ function createStateKeyRenameReplacementsForTarget(document, sourceFile, parentO
 				if (!(sourcePath.length === rename.parentPath.length || arePathsEqual(sourcePath.slice(0, -1), rename.parentPath)) || !supportedScope.has(sourceKey)) return null;
 			}
 		}
-		const replacement = createStringLiteralReplacement(target.document, target.sourceFile, target.node, renameStateReference(target.node.text, rename));
+		const replacement = createStringLiteralReplacement(target.document, target.sourceFile, target.node, renameStateReference(target.value, rename));
 		replacements.push(replacement);
 	}
 	return replacements;
@@ -16367,21 +16501,25 @@ function getDirectChildStatePaths(stateObject, parentPath) {
 		return [[...parentPath, key]];
 	});
 }
-function collectTargetStringLiterals(machineConfigNode) {
+function collectTargetStringLiterals(machineConfigNode, sourceLocations, documentUri) {
 	const literals = [];
-	const bindings = collectTopLevelExpressionBindings(machineConfigNode.getSourceFile());
+	const bindings = collectTopLevelExpressionBindings(machineConfigNode.getSourceFile(), sourceLocations, documentUri);
 	const visitStateObject = (stateObject, sourcePath) => {
 		collectInitialTargetStringLiterals(stateObject, sourcePath, literals, bindings);
 		for (const propertyName of [
 			"always",
 			"after",
 			"on",
-			"onDone"
+			"onDone",
+			"onError",
+			"onTimeout",
+			"choice"
 		]) {
 			const property = getPropertyAssignment(stateObject, propertyName);
 			if (!property) continue;
 			collectTargetStringLiteralsFromExpression(property.initializer, sourcePath, literals, bindings);
 		}
+		collectInvokeTargetStringLiterals(stateObject, sourcePath, literals, bindings);
 		const statesObject = getObjectLiteralProperty(stateObject, "states");
 		if (!statesObject) return;
 		for (const property of statesObject.properties) {
@@ -16402,11 +16540,11 @@ function collectInitialTargetStringLiterals(stateObject, sourcePath, literals, b
 	if (ts$1.isObjectLiteralExpression(initializer)) {
 		const initialLiterals = [];
 		collectTargetStringLiteralsFromExpression(initializer, sourcePath, initialLiterals, bindings);
-		for (const literal of initialLiterals) for (const literalSourcePath of literal.sourcePaths) addTargetLiteral(literals, literal.node, literalSourcePath, true);
+		for (const literal of initialLiterals) for (const literalSourcePath of literal.sourcePaths) addTargetLiteral(literals, literal.node, literalSourcePath, true, literal.value);
 	}
 }
 async function collectMappedTargetStringLiterals(rootDocument, rootSourceFile, machineConfigNode, sourceLocations, openTextDocument) {
-	const literals = collectTargetStringLiterals(machineConfigNode).map((target) => ({
+	const literals = collectTargetStringLiterals(machineConfigNode, sourceLocations, getDocumentUri(rootDocument)).map((target) => ({
 		...target,
 		document: rootDocument,
 		sourceFile: rootSourceFile
@@ -16421,7 +16559,7 @@ async function collectMappedTargetStringLiterals(rootDocument, rootSourceFile, m
 		const stateObject = findObjectLiteralByRange(targetSourceFile, location.range);
 		if (!stateObject) continue;
 		const stateLiterals = [];
-		collectTargetStringLiteralsFromStateObject(stateObject, location.path, stateLiterals, collectTopLevelExpressionBindings(targetSourceFile));
+		collectTargetStringLiteralsFromStateObject(stateObject, location.path, stateLiterals, collectTopLevelExpressionBindings(targetSourceFile, sourceLocations, getDocumentUri(targetDocument)));
 		for (const target of stateLiterals) {
 			const key = getTargetLiteralReplacementKey(targetDocument, targetSourceFile, target.node);
 			if (seen.has(key)) {
@@ -16472,7 +16610,7 @@ async function collectMappedTargetStringLiterals(rootDocument, rootSourceFile, m
 			}
 		}
 		const functionLiterals = [];
-		const bindings = collectTopLevelExpressionBindings(targetSourceFile);
+		const bindings = collectTopLevelExpressionBindings(targetSourceFile, sourceLocations, getDocumentUri(targetDocument));
 		for (const sourcePath of location.sourcePaths) collectTargetStringLiteralsFromFunction(fn, sourcePath, functionLiterals, bindings, new Set([location.symbol]));
 		for (const target of functionLiterals) {
 			const key = getTargetLiteralReplacementKey(targetDocument, targetSourceFile, target.node);
@@ -16558,7 +16696,10 @@ function collectTransitionCallArgumentLiterals(machineConfigNode, symbol, target
 			"always",
 			"after",
 			"on",
-			"onDone"
+			"onDone",
+			"onError",
+			"onTimeout",
+			"choice"
 		]) {
 			const property = getPropertyAssignment(stateObject, propertyName);
 			if (property) visitExpression(property.initializer, sourcePath);
@@ -16584,12 +16725,16 @@ function collectTargetStringLiteralsFromStateObject(stateObject, sourcePath, lit
 		"always",
 		"after",
 		"on",
-		"onDone"
+		"onDone",
+		"onError",
+		"onTimeout",
+		"choice"
 	]) {
 		const property = getPropertyAssignment(stateObject, propertyName);
 		if (!property) continue;
 		collectTargetStringLiteralsFromExpression(property.initializer, sourcePath, literals, bindings);
 	}
+	collectInvokeTargetStringLiterals(stateObject, sourcePath, literals, bindings);
 	const statesObject = getObjectLiteralProperty(stateObject, "states");
 	if (!statesObject) return;
 	for (const property of statesObject.properties) {
@@ -16600,8 +16745,35 @@ function collectTargetStringLiteralsFromStateObject(stateObject, sourcePath, lit
 		collectTargetStringLiteralsFromStateObject(childState, [...sourcePath, key], literals, bindings);
 	}
 }
+function collectInvokeTargetStringLiterals(stateObject, sourcePath, literals, bindings) {
+	const invoke = getPropertyAssignment(stateObject, "invoke");
+	if (!invoke) return;
+	const visit = (expression, seen = /* @__PURE__ */ new Set()) => {
+		const current = unwrapExpression$2(expression);
+		if (ts$1.isIdentifier(current)) {
+			const binding = bindings.get(current.text);
+			if (binding && ts$1.isExpression(binding) && !seen.has(current.text)) visit(binding, new Set([...seen, current.text]));
+		} else if (ts$1.isArrayLiteralExpression(current)) {
+			for (const item of current.elements) if (ts$1.isExpression(item)) visit(item, seen);
+		} else if (ts$1.isObjectLiteralExpression(current)) for (const name of [
+			"onDone",
+			"onError",
+			"onSnapshot",
+			"onTimeout"
+		]) {
+			const property = getPropertyAssignment(current, name);
+			if (property) collectTargetStringLiteralsFromExpression(property.initializer, sourcePath, literals, bindings);
+		}
+	};
+	visit(invoke.initializer);
+}
 function collectTargetStringLiteralsFromExpression(expression, sourcePath, literals, bindings, seenBindings = /* @__PURE__ */ new Set()) {
 	const current = unwrapExpression$2(expression);
+	const staticTarget = bindings.staticTargets?.get(`${current.getStart()}:${current.getEnd()}`);
+	if (staticTarget !== void 0 && (ts$1.isIdentifier(current) || ts$1.isPropertyAccessExpression(current))) {
+		addTargetLiteral(literals, current, sourcePath, false, staticTarget);
+		return;
+	}
 	if (ts$1.isStringLiteralLike(current)) {
 		addTargetLiteral(literals, current, sourcePath);
 		return;
@@ -16624,6 +16796,7 @@ function collectTargetStringLiteralsFromExpression(expression, sourcePath, liter
 		const binding = bindings.get(current.expression.text);
 		if (binding && isTransitionFunctionBinding(binding)) {
 			const scopedBindings = new Map(bindings);
+			scopedBindings.staticTargets = bindings.staticTargets;
 			for (const [index, parameter] of binding.parameters.entries()) {
 				if (!ts$1.isIdentifier(parameter.name)) continue;
 				const argument = current.arguments[index];
@@ -16686,8 +16859,9 @@ function collectTargetStringLiteralsFromFunction(fn, sourcePath, literals, bindi
 	}
 	collectTargetStringLiteralsFromExpression(fn.body, sourcePath, literals, bindings, seenBindings);
 }
-function collectTopLevelExpressionBindings(sourceFile) {
+function collectTopLevelExpressionBindings(sourceFile, sourceLocations, documentUri) {
 	const bindings = /* @__PURE__ */ new Map();
+	bindings.staticTargets = new Map((sourceLocations?.staticValues ?? []).filter((location) => location.definitionUri && location.uri === documentUri).map((location) => [`${offsetAtRangePosition(sourceFile.text, location.range.startLine, location.range.startChar)}:${offsetAtRangePosition(sourceFile.text, location.range.endLine, location.range.endChar)}`, location.value]));
 	for (const statement of sourceFile.statements) {
 		if (ts$1.isFunctionDeclaration(statement) && statement.name) {
 			bindings.set(statement.name.text, statement);
@@ -16698,7 +16872,7 @@ function collectTopLevelExpressionBindings(sourceFile) {
 	}
 	return bindings;
 }
-function addTargetLiteral(literals, node, sourcePath, isInitialTarget = false) {
+function addTargetLiteral(literals, node, sourcePath, isInitialTarget = false, value = node.text) {
 	const existing = literals.find((literal) => literal.node.getStart() === node.getStart() && literal.node.getEnd() === node.getEnd());
 	if (existing) {
 		mergeTargetSourcePaths(existing, [sourcePath]);
@@ -16707,6 +16881,7 @@ function addTargetLiteral(literals, node, sourcePath, isInitialTarget = false) {
 	}
 	literals.push({
 		node,
+		value,
 		sourcePaths: [sourcePath],
 		...isInitialTarget ? { initialSourcePaths: [sourcePath] } : {}
 	});
@@ -16877,6 +17052,10 @@ function compareReplacementRangesDescending(a, b) {
 function normalizeOverlappingReplacements(replacements) {
 	return planTextReplacements(replacements);
 }
+function combineSemanticAndTransitionReplacements(semantic, transitions) {
+	const compare = (leftLine, leftChar, rightLine, rightChar) => leftLine - rightLine || leftChar - rightChar;
+	return [...semantic.filter((focused) => !transitions.some((owner) => owner.uri === focused.uri && compare(focused.range.startLine, focused.range.startChar, owner.range.startLine, owner.range.startChar) > 0 && compare(focused.range.endLine, focused.range.endChar, owner.range.endLine, owner.range.endChar) <= 0)), ...transitions];
+}
 function appendWholeStateReplacement(replacements, wholeState) {
 	const compare = (leftLine, leftChar, rightLine, rightChar) => leftLine - rightLine || leftChar - rightChar;
 	for (let index = replacements.length - 1; index >= 0; index--) {
@@ -17065,6 +17244,138 @@ function stripPresentationPatches(patches) {
 		return [sourcePatch];
 	});
 }
+const tokenKind = {
+	comma: 5,
+	lineComment: 12,
+	blockComment: 13,
+	lineBreak: 14,
+	eof: 17
+};
+/** Move authored values and same-line comments together, retaining array trivia. */
+function reorderedActionArray(text, array, order, inserted = /* @__PURE__ */ new Map()) {
+	const items = array.children ?? [];
+	if (!items.length || order.some((index, position) => index < 0 ? !inserted.has(position) : !items[index])) return null;
+	const prefixes = [text.slice(array.offset + 1, items[0].offset)];
+	const comments = [];
+	let closing = "";
+	let trailingComma = false;
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index];
+		const end = items[index + 1]?.offset ?? array.offset + array.length - 1;
+		const gap = text.slice(item.offset + item.length, end);
+		const scanner = createScanner(gap, false);
+		let comma = -1;
+		let commentEnd = 0;
+		let onSameLine = true;
+		for (let token = scanner.scan(); token !== tokenKind.eof; token = scanner.scan()) {
+			if (token === tokenKind.comma && comma < 0) comma = scanner.getTokenOffset();
+			if (token === tokenKind.lineBreak) onSameLine = false;
+			if (onSameLine && (token === tokenKind.lineComment || token === tokenKind.blockComment)) {
+				commentEnd = scanner.getTokenOffset() + scanner.getTokenLength();
+				if (scanner.getTokenValue().includes("\n")) onSameLine = false;
+			}
+		}
+		const withoutComma = (value, offset) => comma >= offset && comma < offset + value.length ? value.slice(0, comma - offset) + value.slice(comma - offset + 1) : value;
+		comments.push(withoutComma(gap.slice(0, commentEnd), 0));
+		const remainder = withoutComma(gap.slice(commentEnd), commentEnd);
+		if (index < items.length - 1) prefixes.push(remainder);
+		else {
+			closing = remainder;
+			trailingComma = comma >= 0;
+		}
+	}
+	const defaultPrefix = prefixes[0].match(/\r?\n[ \t]*$/)?.[0] ?? prefixes.find((prefix) => /^\s*$/.test(prefix)) ?? "";
+	let interior = "";
+	for (let index = 0; index < order.length; index++) {
+		const oldIndex = order[index];
+		const item = items[oldIndex];
+		const ownPrefix = oldIndex > 0 ? prefixes[oldIndex] ?? defaultPrefix : defaultPrefix;
+		let prefix = index === 0 ? prefixes[0] : ownPrefix;
+		if (index === 0 && oldIndex > 0 && stripComments(ownPrefix) !== ownPrefix) prefix += ownPrefix.trimStart();
+		interior += prefix + (item ? text.slice(item.offset, item.offset + item.length) : inserted.get(index));
+		if (index < order.length - 1 || trailingComma) interior += ",";
+		interior += comments[oldIndex] ?? "";
+	}
+	return {
+		start: array.offset + 1,
+		end: array.offset + array.length - 1,
+		text: interior + closing
+	};
+}
+/** Keep unchanged source spans as anchors while composing successive tree edits. */
+var PreservedText = class {
+	pieces;
+	constructor(original) {
+		this.original = original;
+		this.pieces = [{
+			text: original,
+			originalOffset: 0
+		}];
+	}
+	replace(start, end, text) {
+		const before = [];
+		const after = [];
+		let offset = 0;
+		for (const piece of this.pieces) {
+			const pieceEnd = offset + piece.text.length;
+			if (offset < start) before.push({
+				...piece,
+				text: piece.text.slice(0, Math.min(start, pieceEnd) - offset)
+			});
+			if (pieceEnd > end) {
+				const skip = Math.max(end - offset, 0);
+				after.push({
+					text: piece.text.slice(skip),
+					originalOffset: piece.originalOffset === void 0 ? void 0 : piece.originalOffset + skip
+				});
+			}
+			offset = pieceEnd;
+		}
+		this.pieces = [
+			...before,
+			...text ? [{ text }] : [],
+			...after
+		];
+	}
+	replacements(document) {
+		const edits = [];
+		let cursor = 0;
+		let pending = "";
+		const flush = (end) => {
+			let start = cursor;
+			let replacement = pending;
+			while (start < end && replacement && this.original[start] === replacement[0]) {
+				start++;
+				replacement = replacement.slice(1);
+			}
+			while (end > start && replacement && this.original[end - 1] === replacement.at(-1)) {
+				end--;
+				replacement = replacement.slice(0, -1);
+			}
+			if (start !== end || replacement) {
+				const from = document.positionAt(start);
+				const to = document.positionAt(end);
+				edits.push({
+					range: {
+						startLine: from.line,
+						startChar: from.character,
+						endLine: to.line,
+						endChar: to.character
+					},
+					newText: replacement
+				});
+			}
+			pending = "";
+		};
+		for (const piece of this.pieces) if (piece.originalOffset === void 0) pending += piece.text;
+		else {
+			flush(piece.originalOffset);
+			cursor = piece.originalOffset + piece.text.length;
+		}
+		flush(this.original.length);
+		return edits;
+	}
+};
 function isRecord$2(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -17128,6 +17439,36 @@ function collectPropertyRenames(previousGraph, nextGraph, patches) {
 	}
 	return renames;
 }
+/** Recover authored IDs and discard retained implicit runtime IDs using the source. */
+function recoverSourceNodeIds(graph, previousGraph, source, authoredIdChanges = /* @__PURE__ */ new Set()) {
+	const previousById = new Map(previousGraph.nodes.map((node) => [node.id, node]));
+	const defaultIds = /* @__PURE__ */ new Map();
+	const implicitIds = /* @__PURE__ */ new Map();
+	const authoredIds = /* @__PURE__ */ new Map();
+	const resolve = (id) => {
+		const cached = defaultIds.get(id);
+		if (cached !== void 0) return cached;
+		const node = previousById.get(id);
+		const authoredId = findNodeAtLocation(source, [...node.parentId ? [...statePath(previousGraph, id), node.data.key] : [], "id"]);
+		const implicitId = node.parentId ? `${resolve(node.parentId)}.${node.data.key}` : "(machine)";
+		const defaultId = !node.parentId && authoredId ? getNodeValue(authoredId) : implicitId;
+		defaultIds.set(id, defaultId);
+		if (authoredId) authoredIds.set(id, getNodeValue(authoredId));
+		else implicitIds.set(id, implicitId);
+		return defaultId;
+	};
+	for (const node of previousGraph.nodes) resolve(node.id);
+	const updates = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		if (authoredIdChanges.has(node.id)) continue;
+		if (node.data.nodeId == null && authoredIds.has(node.id)) updates.set(node.id, authoredIds.get(node.id));
+		else if (node.data.nodeId != null && node.data.nodeId === implicitIds.get(node.id)) updates.set(node.id, void 0);
+	}
+	if (!updates.size) return graph;
+	const normalized = structuredClone(graph);
+	for (const node of normalized.nodes) if (updates.has(node.id)) node.data.nodeId = updates.get(node.id);
+	return normalized;
+}
 function onlyTargetChanged(previous, next) {
 	if (typeof previous.target !== "string" || typeof next.target !== "string") return false;
 	const { target: _previousTarget, ...previousRest } = previous;
@@ -17148,12 +17489,24 @@ function formattingOptions(text) {
 	};
 }
 /** Apply graph-level semantic changes to the source JSON tree, not to an export. */
-function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, patches, preserveStatelyMetadata) {
+function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, patches, preserveStatelyMetadata, authoredIdChanges) {
 	if (!isGraph$1(previousGraph) || !isGraph$1(nextGraph) || !isRecord$2(machineConfig)) return null;
 	const original = document.getText();
 	let text = original;
-	const previousConfig = preserveStatelyMetadata ? graphToMachineConfig(previousGraph) : stripStatelyMetadata(graphToMachineConfig(previousGraph));
-	const nextConfig = preserveStatelyMetadata ? machineConfig : stripStatelyMetadata(machineConfig);
+	const preservedText = new PreservedText(original);
+	const replace = (start, end, value) => {
+		preservedText.replace(start, end, value);
+		text = text.slice(0, start) + value + text.slice(end);
+	};
+	const originalTree = parseTree(original, [], { allowTrailingComma: true });
+	if (!originalTree) return null;
+	const normalizedPrevious = recoverSourceNodeIds(previousGraph, previousGraph, originalTree);
+	const previousIds = new Map(previousGraph.nodes.map((node) => [node.id, node.data.nodeId ?? null]));
+	const intentionalIds = authoredIdChanges ?? nextGraph.nodes.filter((node) => previousIds.has(node.id) && previousIds.get(node.id) !== (node.data.nodeId ?? null)).map((node) => node.id);
+	const normalizedNext = recoverSourceNodeIds(nextGraph, previousGraph, originalTree, new Set(intentionalIds));
+	const previousConfig = preserveStatelyMetadata ? graphToMachineConfig(normalizedPrevious) : stripStatelyMetadata(graphToMachineConfig(normalizedPrevious));
+	const nextMachineConfig = normalizedNext === nextGraph ? machineConfig : graphToMachineConfig(normalizedNext);
+	const nextConfig = preserveStatelyMetadata ? nextMachineConfig : stripStatelyMetadata(nextMachineConfig);
 	const renames = collectPropertyRenames(previousGraph, nextGraph, patches);
 	const treeAt = (path) => {
 		const errors = [];
@@ -17163,12 +17516,39 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 	};
 	if (!treeAt([])) return null;
 	const setValue = (path, value) => {
-		text = applyEdits(text, modify(text, path, value, { formattingOptions: formattingOptions(text) }));
+		let containerPath = path.slice(0, -1);
+		let container = treeAt(containerPath);
+		while (!container && containerPath.length) {
+			containerPath = containerPath.slice(0, -1);
+			container = treeAt(containerPath);
+		}
+		const compact = container && !text.slice(container.offset, container.offset + container.length).includes("\n");
+		const edits = modify(text, path, value, { ...compact ? {} : { formattingOptions: formattingOptions(text) } });
+		for (const edit of [...edits].sort((a, b) => b.offset - a.offset)) {
+			let content = edit.content;
+			if (compact && container) {
+				const authored = text.slice(container.offset, container.offset + container.length);
+				const colonSpace = authored.match(/"[^"\r\n]+"\s*:([ \t]*)/)?.[1] ?? "";
+				const commaSpace = authored.match(/,([ \t]*)/)?.[1] ?? "";
+				const scanner = createScanner(content, false);
+				const insertions = [];
+				for (let token = scanner.scan(); token !== 17; token = scanner.scan()) {
+					const spacing = token === 6 ? colonSpace : token === 5 ? commaSpace : "";
+					const offset = scanner.getTokenOffset() + scanner.getTokenLength();
+					if (spacing && !/\s/.test(content[offset] ?? "")) insertions.push({
+						offset,
+						text: spacing
+					});
+				}
+				for (const insertion of insertions.reverse()) content = content.slice(0, insertion.offset) + insertion.text + content.slice(insertion.offset);
+			}
+			replace(edit.offset, edit.offset + edit.length, content);
+		}
 	};
 	const renameKey = (path, oldKey, newKey) => {
 		const keyNode = treeAt([...path, oldKey])?.parent?.children?.[0];
 		if (!keyNode || keyNode.type !== "string") return false;
-		text = `${text.slice(0, keyNode.offset)}${JSON.stringify(newKey)}${text.slice(keyNode.offset + keyNode.length)}`;
+		replace(keyNode.offset, keyNode.offset + keyNode.length, JSON.stringify(newKey));
 		return true;
 	};
 	const removePropertyWithoutFormatting = (path, key) => {
@@ -17187,14 +17567,14 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 			const lineStart = text.lastIndexOf("\n", property.offset - 1) + 1;
 			const nextLineStart = text.lastIndexOf("\n", next.offset - 1) + 1;
 			if (nextLineStart <= lineStart || text.slice(lineStart, property.offset).trim() !== "" || !/^\s*,\s*$/.test(text.slice(propertyEnd, nextLineStart))) return false;
-			text = `${text.slice(0, lineStart)}${text.slice(nextLineStart)}`;
+			replace(lineStart, nextLineStart, "");
 			return true;
 		}
 		const previous = properties[index - 1];
 		if (!previous || trailingLine.trim() !== "") return false;
 		const previousEnd = previous.offset + previous.length;
 		if (!/^\s*,\s*$/.test(text.slice(previousEnd, property.offset))) return false;
-		text = `${text.slice(0, previousEnd)}${text.slice(propertyEnd)}`;
+		replace(previousEnd, propertyEnd, "");
 		return true;
 	};
 	const removeArrayItem = (path, index) => {
@@ -17218,7 +17598,7 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 			const nextLineStart = next && text.lastIndexOf("\n", next.offset - 1) + 1;
 			const separatorOnNextLine = itemLineEnd >= 0 && nextLineStart !== void 0 && /^[ \t]*,[ \t]*\r?\n$/.test(text.slice(itemLineEnd + 1, nextLineStart));
 			if (next && next.offset > lineEnd && (/^\s*,\s*\/\//.test(inlineSuffix) || /^\s*\/\//.test(inlineSuffix) && separatorOnNextLine)) {
-				text = `${text.slice(0, itemLineStart)}${text.slice(separatorOnNextLine ? nextLineStart : itemLineEnd < 0 ? lineEnd : lineEnd + 1)}`;
+				replace(itemLineStart, separatorOnNextLine ? nextLineStart : itemLineEnd < 0 ? lineEnd : lineEnd + 1, "");
 				return true;
 			}
 		} else {
@@ -17228,7 +17608,7 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 			const withoutComma = beforeItem.replace(/^(\s*),/, "$1");
 			if (previousEnd !== void 0 && itemLineEnd >= 0 && itemLineStart > previousEnd && withoutComma !== beforeItem && stripComments(withoutComma).trim() === "") {
 				const separator = /^\s*$/.test(withoutComma) ? formattingOptions(text).eol : withoutComma;
-				text = `${text.slice(0, previousEnd)}${separator}${text.slice(itemLineEnd + 1)}`;
+				replace(previousEnd, itemLineEnd + 1, separator);
 				return true;
 			}
 		}
@@ -17255,7 +17635,7 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 				end = nextLineStart;
 			} else if (!text.slice(end, nextItem.offset).includes("\n") && text.slice(end, nextItem.offset).trim() === "") end = nextItem.offset;
 		} else end = item.offset + item.length;
-		text = `${text.slice(0, start)}${text.slice(end)}`;
+		replace(start, end, "");
 		return true;
 	};
 	const appendArrayItemWithoutFormatting = (path, value) => {
@@ -17275,7 +17655,7 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 			if (indentation.trim() !== "") return false;
 			separator = `,${formattingOptions(text).eol}${indentation}`;
 		}
-		text = `${text.slice(0, lastEnd)}${separator}${serialized}${text.slice(lastEnd)}`;
+		replace(lastEnd, lastEnd, separator + serialized);
 		return true;
 	};
 	const authoredBranchText = (path, index) => {
@@ -17292,6 +17672,39 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 		}
 		return `${leadingText}${text.slice(branchNode.offset, branchNode.offset + branchNode.length)}`;
 	};
+	const actionOrder = (previous, next, path) => {
+		const group = path.at(-1);
+		if (group !== "entry" && group !== "exit" && group !== "actions") return void 0;
+		const owner = nextGraph.nodes.filter((node) => {
+			return (node.parentId ? [...statePath(nextGraph, node.id), node.data.key] : []).every((key, index) => path[index] === key);
+		}).sort((a, b) => (statePath(nextGraph, b.id)?.length ?? 0) - (statePath(nextGraph, a.id)?.length ?? 0))[0];
+		if (!owner) return void 0;
+		const previousNode = previousGraph.nodes.find((node) => node.id === owner.id);
+		const serialize = (actions) => actions.map(({ type, params }) => ({
+			type,
+			...params && Object.keys(params).length ? { params } : {}
+		}));
+		const normalized = (values) => values.map((value) => typeof value === "string" ? { type: value } : value);
+		const ownerPath = owner.parentId ? [...statePath(nextGraph, owner.id), owner.data.key] : [];
+		const transitionPath = path.slice(ownerPath.length);
+		const event = transitionPath[0] === "on" ? transitionPath[1] : transitionPath[0] === "always" ? "" : void 0;
+		const matchingEdges = nextGraph.edges.filter((edge) => edge.sourceId === owner.id && (event === void 0 || edge.data.eventType === event));
+		const branchIndex = typeof path.at(-2) === "number" ? path.at(-2) : 0;
+		const edgeId = event === void 0 ? void 0 : matchingEdges[branchIndex]?.id;
+		const matches = (group === "actions" ? previousGraph.edges.filter((edge) => edge.sourceId === owner.id && (event === void 0 || edge.id === edgeId)).map((edge) => ({
+			previous: edge.data.actions ?? [],
+			next: nextGraph.edges.find((candidate) => candidate.id === edge.id)?.data.actions ?? []
+		})) : [{
+			previous: previousNode?.data[group] ?? [],
+			next: owner.data[group] ?? []
+		}]).filter((candidate) => sameValue(serialize(candidate.previous), normalized(previous)) && sameValue(serialize(candidate.next), normalized(next)));
+		if (matches.length !== 1) return void 0;
+		const candidate = matches[0];
+		const ids = candidate.previous.map((action) => action.id);
+		if (ids.some((id) => !id) || new Set(ids).size !== ids.length) return void 0;
+		const order = candidate.next.map((action) => ids.indexOf(action.id));
+		return candidate.next.every((action) => action.id) ? order : void 0;
+	};
 	const visit = (previous, next, path) => {
 		if (sameValue(previous, next)) return true;
 		const sourceNode = treeAt(path);
@@ -17311,10 +17724,15 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 			const authoredAction = Object.keys(next).length === 1 ? next.type : next;
 			if (text.slice(sourceNode.offset + 1, sourceNode.offset + sourceNode.length - 1) === "") {
 				const insertion = sourceNode.offset + 1;
-				text = `${text.slice(0, insertion)}${JSON.stringify(authoredAction)}${text.slice(insertion)}`;
+				replace(insertion, insertion, JSON.stringify(authoredAction));
 			} else setValue(path, [authoredAction]);
 			return true;
 		}
+		if (sourceNode?.type === "array" && sourceNode.children?.length === 1 && isRecord$2(previous) && Array.isArray(next) && [
+			"entry",
+			"exit",
+			"actions"
+		].includes(String(path.at(-1)))) return visit([previous], next, path);
 		if (sourceNode?.type === "array" && sourceNode.children?.length === 1 && isRecord$2(previous) && isRecord$2(next)) return visit(previous, next, [...path, 0]);
 		if (isRecord$2(previous) && isRecord$2(next) && sourceNode?.type === "object") {
 			const handledOld = /* @__PURE__ */ new Set();
@@ -17375,14 +17793,14 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 								index
 							]);
 							if (!insertedNode) return false;
-							text = `${text.slice(0, insertedNode.offset)}${authoredText}${text.slice(insertedNode.offset + insertedNode.length)}`;
+							replace(insertedNode.offset, insertedNode.offset + insertedNode.length, authoredText);
 						}
 						continue;
 					}
 					if (!visit(previous[key], next[key], [...path, key])) return false;
 				} else {
 					const existing = key === "actions" ? treeAt([...path, key]) : void 0;
-					if (existing?.type === "array") text = `${text.slice(0, existing.offset)}[]${text.slice(existing.offset + existing.length)}`;
+					if (existing?.type === "array") replace(existing.offset, existing.offset + existing.length, "[]");
 					else if ((key === "entry" || key === "exit") && removePropertyWithoutFormatting(path, key)) {} else setValue([...path, key], void 0);
 				}
 			}
@@ -17395,11 +17813,33 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 				if (originalBranch !== void 0) {
 					const insertedNode = treeAt([...path, key]);
 					if (!insertedNode) return false;
-					text = `${text.slice(0, insertedNode.offset)}${originalBranch}${text.slice(insertedNode.offset + insertedNode.length)}`;
+					replace(insertedNode.offset, insertedNode.offset + insertedNode.length, originalBranch);
 				}
 			}
 			return true;
 		}
+		if (Array.isArray(previous) && sourceNode?.type === "array" && (Array.isArray(next) || isRecord$2(next))) {
+			const nextValues = Array.isArray(next) ? next : [next];
+			const order = actionOrder(previous, nextValues, path);
+			const pureDeletion = previous.length === nextValues.length + 1 && previous.some((_, index) => sameValue(previous.filter((_, candidate) => candidate !== index), nextValues));
+			const lastSourceItem = sourceNode.children?.at(-1);
+			const sourceSuffix = lastSourceItem ? text.slice(lastSourceItem.offset + lastSourceItem.length, sourceNode.offset + sourceNode.length - 1) : "";
+			const pureAppend = !(stripComments(sourceSuffix) !== sourceSuffix) && order && nextValues.length > previous.length && order.slice(0, previous.length).every((oldIndex, index) => oldIndex === index);
+			if (order && !pureDeletion && !pureAppend && (previous.length !== nextValues.length || order.some((oldIndex, index) => oldIndex !== index))) {
+				for (const [index, oldIndex] of order.entries()) if (oldIndex >= 0 && !visit(previous[oldIndex], nextValues[index], [...path, oldIndex])) return false;
+				const array = treeAt(path);
+				if (!array) return false;
+				const inserted = new Map(order.flatMap((oldIndex, index) => {
+					if (oldIndex >= 0) return [];
+					const value = nextValues[index];
+					return [[index, JSON.stringify(value)]];
+				}));
+				const edit = reorderedActionArray(text, array, order, inserted);
+				if (!edit) return false;
+				replace(edit.start, edit.end, edit.text);
+				return true;
+			}
+		}
 		if (Array.isArray(previous) && isRecord$2(next) && sourceNode?.type === "array") {
 			if (previous.length === 1 && isRecord$2(previous[0])) return visit(previous[0], next, [...path, 0]);
 			const matches = previous.flatMap((value, index) => sameValue(value, next) ? [index] : []);
@@ -17431,25 +17871,7 @@ function preserveXStateJson(document, previousGraph, nextGraph, machineConfig, p
 	parseTree(text, errors, { allowTrailingComma: true });
 	if (errors.length) return null;
 	if (text === original) return [];
-	let start = 0;
-	while (start < original.length && start < text.length && original[start] === text[start]) start++;
-	let oldEnd = original.length;
-	let newEnd = text.length;
-	while (oldEnd > start && newEnd > start && original[oldEnd - 1] === text[newEnd - 1]) {
-		oldEnd--;
-		newEnd--;
-	}
-	const startPosition = document.positionAt(start);
-	const endPosition = document.positionAt(oldEnd);
-	return [{
-		range: {
-			startLine: startPosition.line,
-			startChar: startPosition.character,
-			endLine: endPosition.line,
-			endChar: endPosition.character
-		},
-		newText: text.slice(start, newEnd)
-	}];
+	return preservedText.replacements(document);
 }
 const xstateAdapter = {
 	id: "xstate",
@@ -17538,7 +17960,7 @@ const xstateJsonAdapter = {
 		if (options?.sourceUpdateStrategy === "rewrite") return createSerializedDocumentReplacement(document, options, "xstate-json");
 		const patches = options?.preserveStatelyMetadata === false ? stripPresentationPatches(options.patches ?? []) : options?.patches ?? [];
 		if (!options || !patches.length) return [];
-		return preserveXStateJson(document, options.prevGraph, options.nextGraph, machineConfig, patches, options.preserveStatelyMetadata ?? true) ?? [];
+		return preserveXStateJson(document, options.prevGraph, options.nextGraph, machineConfig, patches, options.preserveStatelyMetadata ?? true, options.authoredIdChanges) ?? [];
 	}
 };
 const asyncAdapter = createSerializedExportAdapter("async", (document, text) => isJavaScriptOrTypeScriptFile(document.fileName) && looksLikeAsyncWorkflow(text));
@@ -17821,7 +18243,7 @@ function diagnosticKey$1(diagnostic) {
 }
 
 //#endregion
-//#region ../editor-sync/dist/localBackend-M-YkjWse.mjs
+//#region ../editor-sync/dist/localBackend-DH1qEsOz.mjs
 var LocalEditorSyncBackend = class {
 	constructor(access) {
 		this.access = access;
@@ -17960,7 +18382,7 @@ function toFileName(uriOrPath) {
 }
 
 //#endregion
-//#region ../editor-sync/dist/pushMerge-BTyVbmbW.mjs
+//#region ../editor-sync/dist/pushMerge-piN5M1Ej.mjs
 const GEOMETRY_KEYS = [
 	"x",
 	"y",
@@ -17977,6 +18399,36 @@ const DEFAULT_ANNOTATION_SIZE = {
 };
 const NEW_NODE_GAP = 80;
 const MAX_CONCURRENT_MERGE_ATTEMPTS = 3;
+/** Match presentation events independently of converter-specific entity IDs. */
+function presentationMatchingGraph(graph) {
+	const nodes = new Map(graph.nodes.map((node) => [node.id, node]));
+	return {
+		...graph,
+		edges: graph.edges.map((edge) => {
+			let eventType = edge.data.eventType;
+			if (typeof eventType !== "string") return edge;
+			const sourceSuffix = `.${edge.sourceId}`;
+			if (eventType.startsWith("xstate.after.") && eventType.endsWith(sourceSuffix)) eventType = eventType.slice(0, -sourceSuffix.length);
+			else if (/^(?:@statelyai?\.state\.done\.|xstate\.done\.state(?:\.|$))/.test(eventType)) eventType = "xstate.done.state";
+			else {
+				const ref = /^@statelyai?\.invoke\.(done|error|snapshot|timeout)\.(.+)$/.exec(eventType);
+				const literal = /^xstate\.(done|error|snapshot|timeout)\.actor\.(.+)$/.exec(eventType);
+				const match = ref ?? literal;
+				if (match) {
+					const index = (nodes.get(edge.sourceId)?.data?.invokes ?? []).findIndex((invoke) => invoke.id === match[2] || "invocationId" in invoke && invoke.invocationId === match[2]);
+					if (index >= 0) eventType = `@presentation.invoke.${match[1]}.${index}`;
+				}
+			}
+			return {
+				...edge,
+				data: {
+					...edge.data,
+					eventType
+				}
+			};
+		})
+	};
+}
 function indexBySemanticId(normalized, original) {
 	const bySemanticId = /* @__PURE__ */ new Map();
 	normalized.forEach((entity, index) => {
@@ -18014,6 +18466,7 @@ function restoreEdgeFields(edges, remoteEdgesById, remoteEdgeIdByLocalId) {
 		const remote = remoteId ? remoteEdgesById.get(remoteId) : void 0;
 		if (remote) {
 			if (remote.uniqueId !== void 0) edge.uniqueId = remote.uniqueId;
+			edge.data.eventTypeData = structuredClone(remote.data.eventTypeData);
 			if (remote.data.assets !== void 0) edge.data.assets = structuredClone(remote.data.assets);
 		}
 	}
@@ -18058,7 +18511,7 @@ function mergePresentationIntoRemoteDefinition(editedDefinition, remoteDefinitio
 	remoteGraph.nodes = remoteGraph.nodes.filter((node) => !remoteAnnotationIds.has(node.id));
 	editedGraph.edges = editedGraph.edges.filter((edge) => !editedAnnotationIds.has(edge.sourceId) && !editedAnnotationIds.has(edge.targetId));
 	remoteGraph.edges = remoteGraph.edges.filter((edge) => !remoteAnnotationIds.has(edge.sourceId) && !remoteAnnotationIds.has(edge.targetId));
-	const { base, compare } = diffGraphsSemantically(remoteGraph, editedGraph);
+	const { base, compare } = diffGraphsSemantically(presentationMatchingGraph(remoteGraph), presentationMatchingGraph(editedGraph));
 	const remoteNodesBySemanticId = indexBySemanticId(base.nodes, remoteGraph.nodes);
 	const editedNodesBySemanticId = indexBySemanticId(compare.nodes, editedGraph.nodes);
 	const remoteEdgesBySemanticId = indexBySemanticId(base.edges, remoteGraph.edges);
@@ -18067,6 +18520,7 @@ function mergePresentationIntoRemoteDefinition(editedDefinition, remoteDefinitio
 	const mergedNodesById = collectDigraphNodes(merged.rootNode, /* @__PURE__ */ new Map());
 	const editedNodesById = collectDigraphNodes(editedDefinition.rootNode, /* @__PURE__ */ new Map());
 	const editedNodeIdToRemoteNodeId = /* @__PURE__ */ new Map();
+	const editedEdgeIdToRemoteEdgeId = /* @__PURE__ */ new Map();
 	for (const [semanticId, remoteNode] of remoteNodesBySemanticId) {
 		const editedNode = editedNodesBySemanticId.get(semanticId);
 		const target = mergedNodesById.get(remoteNode.id);
@@ -18089,6 +18543,7 @@ function mergePresentationIntoRemoteDefinition(editedDefinition, remoteDefinitio
 		const target = mergedEdgesById.get(remoteEdge.id);
 		const source = editedEdge ? editedEdgesById.get(editedEdge.id) : void 0;
 		if (!editedEdge || !target || !source) continue;
+		editedEdgeIdToRemoteEdgeId.set(editedEdge.id, remoteEdge.id);
 		for (const field of ["position", "size"]) replacePresentationField(target, source, field);
 		for (const field of ["color", "assets"]) replacePresentationField(target.data, source.data, field);
 	}
@@ -18097,7 +18552,10 @@ function mergePresentationIntoRemoteDefinition(editedDefinition, remoteDefinitio
 	collectAnnotations(editedDefinition.rootNode, null, editedAnnotations);
 	for (const annotation of editedAnnotations) {
 		const remoteParentId = annotation.parentId ? editedNodeIdToRemoteNodeId.get(annotation.parentId) : merged.rootNode.id;
-		(remoteParentId ? mergedNodesById.get(remoteParentId) : void 0)?.nodes.push(structuredClone(annotation.node));
+		const parent = remoteParentId ? mergedNodesById.get(remoteParentId) : void 0;
+		const note = structuredClone(annotation.node);
+		if (Array.isArray(note.data.data?.referenceIds)) note.data.data.referenceIds = note.data.data.referenceIds.map((id) => editedNodeIdToRemoteNodeId.get(id) ?? editedEdgeIdToRemoteEdgeId.get(id) ?? id);
+		parent?.nodes.push(note);
 	}
 	return merged;
 }
@@ -18141,7 +18599,7 @@ function mergeLocalGraphIntoRemoteDefinition(localGraph, remoteDefinition) {
 	const remoteGraph = fromStudioMachine(remoteDefinition);
 	remoteGraph.nodes = remoteGraph.nodes.filter((node) => !annotationIds.has(node.id));
 	remoteGraph.edges = remoteGraph.edges.filter((edge) => !annotationIds.has(edge.sourceId) && !annotationIds.has(edge.targetId));
-	const { base, compare, summary } = diffGraphsSemantically(remoteGraph, localGraph);
+	const { base, compare, summary } = diffGraphsSemantically(presentationMatchingGraph(remoteGraph), presentationMatchingGraph(localGraph));
 	const remoteNodesBySemanticId = indexBySemanticId(base.nodes, remoteGraph.nodes);
 	const remoteEdgesBySemanticId = indexBySemanticId(base.edges, remoteGraph.edges);
 	const merged = structuredClone(localGraph);
@@ -18165,7 +18623,10 @@ function mergeLocalGraphIntoRemoteDefinition(localGraph, remoteDefinition) {
 	});
 	const definition = toStudioMachine(merged);
 	restoreNodeFields(definition.rootNode, remoteNodesById, remoteNodeIdByLocalId);
-	restoreEdgeFields(definition.edges, new Map(remoteDefinition.edges.map((edge) => [edge.id, edge])), remoteEdgeIdByLocalId);
+	restoreEdgeFields(definition.edges, new Map(remoteDefinition.edges.map((edge) => [edge.id, edge])), new Map(definition.edges.flatMap((edge, index) => {
+		const remoteId = remoteEdgeIdByLocalId.get(merged.edges[index].id);
+		return remoteId ? [[edge.id, remoteId]] : [];
+	})));
 	ensureCompleteNodeGeometry(definition.rootNode);
 	return {
 		definition: {
@@ -18230,7 +18691,7 @@ async function updateMachineDefinition(client, machineId, localGraph) {
 }
 
 //#endregion
-//#region ../editor-sync/dist/presentationMetadata-DH591jIC.mjs
+//#region ../editor-sync/dist/presentationMetadata-YX6iRP4T.mjs
 function createStudioPresentationMetadataStore(client, machineId) {
 	const load = async () => {
 		return {
@@ -18249,7 +18710,7 @@ function createStudioPresentationMetadataStore(client, machineId) {
 		},
 		async persist(_graph, context) {
 			const serialized = context?.serialized?.digraph;
-			if (!serialized) return;
+			if (!serialized) throw new Error("Studio presentation requires a serialized digraph. Presentation was not saved.");
 			const editedDefinition = JSON.parse(serialized);
 			const latest = await client.machines.get(machineId);
 			if (!latest.updatedAt) throw new Error(`Studio machine "${machineId}" did not provide an updatedAt guard. Presentation was not saved.`);
@@ -18310,10 +18771,29 @@ function createLocalPresentationMetadataRepository(file) {
 		};
 	} };
 }
-function applyPresentationInitializer(initializer, current) {
+function applyPresentationInitializer(initializer, current, convertStudioDefinition = fromStudioMachine) {
 	if (initializer.type === "overlay") return applyPresentationMetadata(initializer.overlay, current);
 	if (!isGraph(current)) return current;
-	return fromStudioMachine(mergeLocalGraphIntoRemoteDefinition(current, initializer.definition).definition);
+	const presentationGraph = convertStudioDefinition(initializer.definition);
+	if (!isGraph(presentationGraph)) return current;
+	const overlay = createPresentationSnapshot(presentationGraph);
+	const sourceIds = presentationIds(current);
+	const studioIds = presentationIds(presentationGraph);
+	const liveIds = /* @__PURE__ */ new Map();
+	for (const kind of ["nodes", "edges"]) {
+		const bySemanticId = new Map(current[kind].map((entity, index) => [sourceIds[kind][index], entity.id]));
+		presentationGraph[kind].forEach((entity, index) => {
+			const liveId = bySemanticId.get(studioIds[kind][index]);
+			if (typeof liveId === "string") liveIds.set(entity.id, liveId);
+		});
+	}
+	const sourceEntityIds = new Set([...current.nodes, ...current.edges].map((entity) => entity.id));
+	overlay.annotations = (overlay.annotations ?? []).filter((annotation) => annotation.parentId == null || liveIds.has(annotation.parentId));
+	for (const annotation of overlay.annotations) {
+		annotation.parentId = liveIds.get(annotation.parentId) ?? annotation.parentId;
+		if (Array.isArray(annotation.data?.referenceIds)) annotation.data.referenceIds = annotation.data.referenceIds.map((id) => liveIds.get(id) ?? id).filter((id) => sourceEntityIds.has(id));
+	}
+	return applyPresentationMetadata(overlay, current);
 }
 function applyPresentationMetadata(overlay, current) {
 	if (!isPresentationOverlay(overlay) || !isGraph(current)) return current;
@@ -18321,6 +18801,7 @@ function applyPresentationMetadata(overlay, current) {
 	const addedNodes = [];
 	const addedEdges = [];
 	const semanticIds = overlay.identity === "semantic-v1" ? presentationIds(result) : void 0;
+	const legacyIds = semanticIds ? presentationIds(result, false) : void 0;
 	const renamedGuardPresentation = semanticIds ? matchUniqueGuardRenames(semanticIds.edges, overlay.edges ?? {}) : /* @__PURE__ */ new Map();
 	for (const [index, node] of result.nodes.entries()) {
 		normalizeCanonicalGeometry(node);
@@ -18331,7 +18812,7 @@ function applyPresentationMetadata(overlay, current) {
 	for (const [index, edge] of result.edges.entries()) {
 		normalizeCanonicalGeometry(edge);
 		const semanticId = semanticIds?.edges[index] ?? edge.id;
-		const presentation = overlay.edges?.[semanticId] ?? renamedGuardPresentation.get(semanticId);
+		const presentation = overlay.edges?.[semanticId] ?? overlay.edges?.[legacyIds?.edges[index] ?? edge.id] ?? renamedGuardPresentation.get(semanticId);
 		if (presentation) applyEntityPresentation(presentation, edge);
 		else addedEdges.push(edge);
 	}
@@ -18411,6 +18892,7 @@ function entityPresentationMap(entities, includeSourceSide, ids) {
 		const presentation = compactDefined({
 			...pick(canonicalGeometry(entity), GEOMETRY_FIELDS),
 			color: clone(entity.data?.color),
+			layout: clone(entity.data?.layout),
 			assets: clone(entity.data?.assets),
 			sourceSide: includeSourceSide ? clone(entity.data?.sourceSide) : void 0
 		});
@@ -18418,7 +18900,8 @@ function entityPresentationMap(entities, includeSourceSide, ids) {
 	});
 	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
 }
-function presentationIds(graph) {
+function presentationIds(graph, canonicalEvents = true) {
+	const matchingGraph = canonicalEvents ? presentationMatchingGraph(graph) : graph;
 	const normalized = normalizeGraphForSemanticDiff({
 		id: graph.id ?? "presentation",
 		nodes: graph.nodes.map((node) => ({
@@ -18426,7 +18909,7 @@ function presentationIds(graph) {
 			parentId: node.parentId,
 			data: { key: node.data?.key }
 		})),
-		edges: graph.edges.map((edge) => ({
+		edges: matchingGraph.edges.map((edge) => ({
 			id: edge.id,
 			sourceId: edge.sourceId,
 			targetId: edge.targetId,
@@ -18459,10 +18942,12 @@ function createAnnotationSnapshot(annotations) {
 			parentId: annotation.parentId,
 			content: clone(annotation.content),
 			...pick(geometry, GEOMETRY_FIELDS),
+			...pick(annotation, ["width", "height"]),
 			data: compactDefined({
 				referenceIds: clone(annotation.data?.referenceIds),
 				color: clone(annotation.data?.color),
-				textAlign: clone(annotation.data?.textAlign)
+				textAlign: clone(annotation.data?.textAlign),
+				placement: clone(annotation.data?.placement)
 			})
 		});
 	});
@@ -18481,7 +18966,8 @@ function applyEntityPresentation(presentation, entity) {
 	for (const field of [
 		"color",
 		"assets",
-		"sourceSide"
+		"sourceSide",
+		"layout"
 	]) copyField(presentation, entity.data, field);
 }
 function placeAddedNodes(added, allNodes) {
@@ -19004,7 +19490,7 @@ const editorSyncApplyResponseSchema = z$1.object({ replacements: z$1.array(edito
 const editorSyncAccessResponseSchema = z$1.object({ access: editorSyncAccessSchema });
 
 //#endregion
-//#region ../editor-sync/dist/host-THez2yXn.mjs
+//#region ../editor-sync/dist/host-BX7mLyHj.mjs
 let diagnosticSequence = 0;
 function presentationsEqual(first, second) {
 	return JSON.stringify(createPresentationSnapshot(first)) === JSON.stringify(createPresentationSnapshot(second));
@@ -19031,6 +19517,12 @@ var EditorSyncError = class extends Error {
 		this.code = code;
 	}
 };
+function isEditorSyncAuthenticationError(error) {
+	return error instanceof Error && "status" in error && error.status === 401;
+}
+function authenticationRecoveryInstructions(recovery) {
+	return recovery.host === "cli" ? "Run `npx statelyai login` in your terminal, then reload the editor." : "In the VS Code Command Palette, run “Stately: Sign In”, then reopen the visual editor.";
+}
 async function fetchEditorSyncAccess(options) {
 	const fetchImpl = options.fetch ?? globalThis.fetch;
 	const url = new URL("/api/editor-sync/access", `${options.editorUrl.replace(/\/+$/, "")}/`);
@@ -19124,12 +19616,14 @@ var EditorHostSession = class {
 					await this.initialize();
 				} catch (error) {
 					const message = formatError(error, "Failed to initialize the visual editor.");
+					const recovery = isEditorSyncAuthenticationError(error) ? this.options.authenticationRecovery : void 0;
 					this.options.send({
 						type: "@statelyai.error",
 						code: "initialization_failed",
-						message
+						message,
+						...recovery ? { authenticationRecovery: recovery } : {}
 					});
-					this.options.showError?.(message);
+					this.options.showError?.(recovery ? `${message}\n${authenticationRecoveryInstructions(recovery)}` : message);
 				}
 				break;
 			case "@statelyai.loaded":
@@ -19330,7 +19824,7 @@ var EditorHostSession = class {
 			return;
 		}
 		const documents = await this.options.source.collectDocuments(sourceLocationUris(this.currentSourceLocations));
-		const serialized = await this.getSerializedPayload();
+		const serialized = await this.getSerializedPayload(message.serialized);
 		const response = await this.options.sync.apply({
 			rootUri: this.options.source.rootUri,
 			rootFileName: this.options.source.rootFileName,
@@ -19379,7 +19873,7 @@ var EditorHostSession = class {
 		});
 	}
 	async acknowledgeWithoutSourceChanges(message, serialized) {
-		await this.persistPresentation(message.graph, serialized ?? await this.getSerializedPayload());
+		await this.persistPresentation(message.graph, serialized ?? await this.getSerializedPayload(message.serialized));
 		this.currentGraph = message.graph;
 		this.lastPersistedGraph = message.graph;
 		this.options.send({
@@ -19477,11 +19971,12 @@ var EditorHostSession = class {
 		this.watchedSourceUris.clear();
 		for (const uri of sourceLocationUris(sourceLocations)) if (uri !== this.options.source.rootUri) this.watchedSourceUris.add(uri);
 	}
-	async getSerializedPayload() {
+	async getSerializedPayload(provided) {
 		const format = this.currentFormat;
-		if (!format || format === "xstate") return void 0;
+		const formats = [...new Set([...format && format !== "xstate" ? [format] : [], ...this.initialPresentation?.type === "studio" ? ["digraph"] : []])];
+		if (formats.length === 0) return void 0;
 		try {
-			return { [format]: await this.requestSerialized(format) };
+			return Object.fromEntries(await Promise.all(formats.map(async (format) => [format, provided?.[format] ?? await this.requestSerialized(format)])));
 		} catch {
 			return;
 		}
@@ -19856,14 +20351,31 @@ async function assertSourceSaveMatchesGraph(input) {
 			const graph = convertMachineToGraph({
 				machine: parsed.machine,
 				format,
-				...input.profile ? { profile: input.profile } : {}
+				profile: input.profile ?? (format === "json" ? input.graph.data?.profile : void 0)
 			}).graph;
+			if (format === "json" && graph.data.schemas && input.machineConfig?.schemas !== void 0) {
+				const root = graph.nodes.find((node) => !node.parentId);
+				if (root) root.data.schemas = graph.data.schemas;
+			}
 			return graphToMachineConfig(graph);
 		};
 		const expectedConfig = comparableMachineConfig(stripStatelyMetadata(input.machineConfig));
 		const actualConfig = comparableMachineConfig(stripStatelyMetadata(projectConfig(documents)));
+		const baselineConfig = comparableMachineConfig(stripStatelyMetadata(projectConfig(input.documents)));
+		const schemaEvents = (config) => config?.schemas?.events;
+		const expectedEvents = schemaEvents(expectedConfig);
+		const eventOrigins = input.graph.data?.schemaMeta?.events;
+		let removedAutoEvent = false;
+		for (const [event, origin] of Object.entries(eventOrigins ?? {})) if (origin.origin === "auto" && expectedEvents && JSON.stringify(expectedEvents[event]) === JSON.stringify(comparableMachineConfig({
+			type: "object",
+			properties: {},
+			required: []
+		})) && !Object.hasOwn(schemaEvents(baselineConfig) ?? {}, event) && !Object.hasOwn(schemaEvents(actualConfig) ?? {}, event)) {
+			delete expectedEvents[event];
+			removedAutoEvent = true;
+		}
+		if (removedAutoEvent && expectedEvents && Object.keys(expectedEvents).length === 0) delete expectedConfig.schemas.events;
 		if (expectedConfig && typeof expectedConfig === "object" && !Array.isArray(expectedConfig) && actualConfig && typeof actualConfig === "object" && !Array.isArray(actualConfig) && !("id" in expectedConfig) && "id" in actualConfig) {
-			const baselineConfig = comparableMachineConfig(stripStatelyMetadata(projectConfig(input.documents)));
 			if (baselineConfig && typeof baselineConfig === "object" && "id" in baselineConfig && actualConfig.id === baselineConfig.id) delete actualConfig.id;
 		}
 		if (JSON.stringify(expectedConfig) !== JSON.stringify(actualConfig)) throw new Error("The updated source does not match the requested machine.");
@@ -19945,7 +20457,7 @@ function sourceLocationUris(sourceLocations) {
 
 //#endregion
 //#region src/version.ts
-const CLI_VERSION = "0.12.2";
+const CLI_VERSION = "0.12.4";
 
 //#endregion
 //#region src/cliHost.ts
@@ -19986,11 +20498,21 @@ function rawDataToBuffer(data) {
 var CliEditorSession = class {
 	session;
 	workspaceWatcher;
+	readyMessage;
+	loginPromise;
+	loginController;
+	disposed = false;
 	constructor(options, sendMessage) {
 		this.options = options;
+		this.sendMessage = sendMessage;
+		this.workspaceWatcher = createSharedWorkspaceWatcher(options.rootDir);
+		this.session = this.createSession();
+	}
+	createSession() {
+		const options = this.options;
 		const send = (message) => {
 			this.log("send", message.type, message);
-			sendMessage(message);
+			this.sendMessage(message);
 		};
 		const machines = options.machines ?? [{
 			id: `${options.rootUri}#0`,
@@ -20004,8 +20526,7 @@ var CliEditorSession = class {
 			baseUrl: options.studioUrl,
 			apiKey: options.apiKey
 		});
-		this.workspaceWatcher = createSharedWorkspaceWatcher(options.rootDir);
-		let access;
+		let access = options.access ? Promise.resolve(options.access) : void 0;
 		const getAccess = () => {
 			if (!access) {
 				const request = fetchEditorSyncAccess({
@@ -20020,7 +20541,11 @@ var CliEditorSession = class {
 			}
 			return access;
 		};
-		this.session = new EditorHostWorkspaceSession({
+		return new EditorHostWorkspaceSession({
+			authenticationRecovery: {
+				host: "cli",
+				canLogin: Boolean(options.onLogin)
+			},
 			machines: machines.map((machine) => ({
 				id: machine.id,
 				name: machine.name,
@@ -20056,14 +20581,75 @@ var CliEditorSession = class {
 			showError: (message) => console.error(`Stately Editor: ${message}`)
 		});
 	}
-	receiveMessage(message) {
+	async receiveMessage(message) {
 		this.log("recv", message.type, message);
+		if (this.disposed) return;
+		if (message.type === "@statelyai.login") {
+			if (!this.readyMessage || !this.options.onLogin) return;
+			this.loginPromise ??= this.login().finally(() => {
+				this.loginPromise = void 0;
+			});
+			return this.loginPromise;
+		}
+		if (this.loginPromise) {
+			if (message.type !== "@statelyai.ready") return this.loginPromise;
+			this.loginController?.abort();
+			await this.loginPromise;
+			if (this.disposed) return;
+		}
+		if (message.type === "@statelyai.ready") {
+			this.readyMessage = message;
+			try {
+				const apiKey = this.options.getApiKey ? await this.options.getApiKey() : this.options.apiKey;
+				if (this.disposed) return;
+				if (apiKey !== this.options.apiKey) this.replaceCredential(apiKey);
+			} catch (error) {
+				this.reportLoginError(error);
+				return;
+			}
+		}
 		return this.session.receive(message);
 	}
 	dispose() {
+		this.disposed = true;
+		this.loginController?.abort();
 		this.session.dispose();
 		this.workspaceWatcher.dispose();
 	}
+	replaceCredential(apiKey) {
+		this.session.dispose();
+		this.options.apiKey = apiKey;
+		this.options.access = void 0;
+		this.session = this.createSession();
+	}
+	async login() {
+		const controller = new AbortController();
+		this.loginController = controller;
+		try {
+			const apiKey = await this.options.onLogin(controller.signal);
+			if (this.disposed || controller.signal.aborted) return;
+			this.replaceCredential(apiKey);
+			await this.session.receive(this.readyMessage);
+		} catch (error) {
+			if (!this.disposed) this.reportLoginError(error);
+		} finally {
+			this.loginController = void 0;
+		}
+	}
+	reportLoginError(error) {
+		const message = error instanceof Error ? error.message : "Stately login failed. Try again.";
+		const authenticationRecovery = {
+			host: "cli",
+			canLogin: Boolean(this.options.onLogin)
+		};
+		this.sendMessage({
+			type: "@statelyai.error",
+			code: "initialization_failed",
+			message,
+			authenticationRecovery
+		});
+		console.error(`Stately Editor: ${message}\n${authenticationRecoveryInstructions(authenticationRecovery)}`);
+	}
 	log(direction, type, payload) {
 		if (this.options.debug) console.error(`[${direction}] ${type}`, redactDebugPayload(payload) ?? "");
 	}
@@ -20165,6 +20751,31 @@ function redactDebugPayload(payload) {
 	if (!payload || typeof payload !== "object") return payload;
 	return Object.fromEntries(Object.entries(payload).map(([key, value]) => [key, /^(?:apiKey|accessToken|refreshToken|token|authorization)$/i.test(key) ? "[REDACTED]" : redactDebugPayload(value)]));
 }
+async function prepareEditorAuthentication(options) {
+	const getAccess = (apiKey) => fetchEditorSyncAccess({
+		editorUrl: options.editorUrl,
+		apiKey,
+		fetch: (input, init) => fetchEditorHost(input instanceof URL ? input : new URL(String(input)), init)
+	});
+	try {
+		return {
+			apiKey: options.apiKey,
+			access: await getAccess(options.apiKey)
+		};
+	} catch (error) {
+		if (!isEditorSyncAuthenticationError(error)) return { apiKey: options.apiKey };
+		console.log("Log in to Stately to open this machine. Complete sign-in in your browser; the editor will open automatically.");
+		const apiKey = await options.onLogin(new AbortController().signal);
+		try {
+			return {
+				apiKey,
+				access: await getAccess(apiKey)
+			};
+		} catch {
+			return { apiKey };
+		}
+	}
+}
 async function openEditor(options) {
 	const fileName = path$1.resolve(options.fileName);
 	const machines = (options.machines ?? [{
@@ -20177,6 +20788,11 @@ async function openEditor(options) {
 	}));
 	await Promise.all([...new Set(machines.map((machine) => machine.fileName))].map((target) => fsPromises.access(target)));
 	await assertEditorHostAvailable(options.editorUrl);
+	if (options.shouldOpen && options.onLogin && process.stdin.isTTY && process.stdout.isTTY) Object.assign(options, await prepareEditorAuthentication({
+		editorUrl: options.editorUrl,
+		apiKey: options.apiKey,
+		onLogin: options.onLogin
+	}));
 	const rootUri = fileNameToUri(fileName);
 	const rootDir = path$1.resolve(options.rootDir ?? path$1.dirname(fileName));
 	let activeClient;
@@ -20196,6 +20812,10 @@ async function openEditor(options) {
 			socket.end("HTTP/1.1 404 Not Found\r\n\r\n");
 			return;
 		}
+		if (request.headers.origin !== editorPageUrl || request.headers.host !== new URL(editorPageUrl).host) {
+			socket.end("HTTP/1.1 403 Forbidden\r\n\r\n");
+			return;
+		}
 		webSocketServer.handleUpgrade(request, socket, head, (webSocket) => {
 			activeClient?.close();
 			session?.dispose();
@@ -20218,7 +20838,11 @@ async function openEditor(options) {
 	const editorPageUrl = `http://${options.host}:${port}`;
 	console.log(`Stately visual editor: ${editorPageUrl}`);
 	console.log(`Editing ${machines.length} machine${machines.length === 1 ? "" : "s"} in ${rootDir}`);
-	if (options.shouldOpen) openBrowser(editorPageUrl);
+	if (options.shouldOpen) try {
+		await openBrowser(editorPageUrl);
+	} catch {
+		console.warn("Could not open a browser automatically. Open the editor URL above.");
+	}
 	const shutdown = () => {
 		session?.dispose();
 		activeClient?.close();
@@ -20399,6 +21023,7 @@ function getCliWebviewContent(options) {
   ></iframe>
   <script>
     const iframe = document.getElementById('stately-editor');
+    const editorOrigin = new URL(iframe.src).origin;
     const socket = new WebSocket(
       (location.protocol === 'https:' ? 'wss:' : 'ws:') + '//' + location.host + '/ws'
     );
@@ -20419,10 +21044,13 @@ function getCliWebviewContent(options) {
     });
 
     socket.addEventListener('message', (event) => {
-      iframe.contentWindow?.postMessage(JSON.parse(event.data), '*');
+      iframe.contentWindow?.postMessage(JSON.parse(event.data), editorOrigin);
     });
 
     window.addEventListener('message', (event) => {
+      if (event.source !== iframe.contentWindow || event.origin !== editorOrigin) {
+        return;
+      }
       if (!event.data?.type?.startsWith?.('@statelyai.')) {
         return;
       }
@@ -20455,8 +21083,8 @@ async function assertEditorHostAvailable(editorUrl) {
 function formatEditorHostError(baseUrl, status, cause) {
 	return `Cannot reach a usable editor host at ${baseUrl}.${status ? ` HTTP ${status} from /embed.` : ""}${cause instanceof Error && cause.message ? ` ${cause.message}` : ""} The CLI loads editor URL defaults from your environment, including \`.env.local\`. Start the editor host, set \`STATELY_EDITOR_URL\`, or pass \`--editor-url <url>\`.`;
 }
-function openBrowser(url) {
-	spawn(process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open", process.platform === "win32" ? [
+async function openBrowser(url) {
+	const child = spawn(process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open", process.platform === "win32" ? [
 		"/c",
 		"start",
 		"",
@@ -20464,7 +21092,12 @@ function openBrowser(url) {
 	] : [url], {
 		detached: true,
 		stdio: "ignore"
-	}).unref();
+	});
+	child.unref();
+	await new Promise((resolve, reject) => {
+		child.once("spawn", resolve);
+		child.once("error", reject);
+	});
 }
 function fileNameToUri(fileName) {
 	return pathToFileURL(path$1.resolve(fileName)).toString();
@@ -20490,6 +21123,8 @@ async function createLocalOAuthCallbackServer(options) {
 		resolveCode = resolve;
 		rejectCode = reject;
 	});
+	codePromise.catch(() => {});
+	const cancel = () => rejectCode(/* @__PURE__ */ new Error("Stately sign-in was canceled."));
 	const server = http.createServer((req, res) => {
 		const requestUrl = new URL(req.url ?? "/", "http://127.0.0.1");
 		const code = requestUrl.searchParams.get("code");
@@ -20517,12 +21152,17 @@ async function createLocalOAuthCallbackServer(options) {
 	});
 	const address = server.address();
 	if (!address || typeof address === "string") throw new Error("Could not start OAuth callback server.");
+	options.signal?.addEventListener("abort", cancel, { once: true });
+	if (options.signal?.aborted) cancel();
 	return {
 		redirectUri: `http://127.0.0.1:${address.port}/callback`,
 		waitForCode: () => codePromise,
-		close: () => new Promise((resolve) => {
-			server.close(() => resolve());
-		})
+		close: () => {
+			options.signal?.removeEventListener("abort", cancel);
+			return new Promise((resolve) => {
+				server.close(() => resolve());
+			});
+		}
 	};
 }
 
@@ -20918,7 +21558,7 @@ function getScriptKind$1(fileName) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@statelyai+graph@2.1.0_@statelyai+layout@0.1.2_cytoscape@3.34.0_d3-force@3.0.0_d3-hiera_3600605a69f548f83255fd3d12957cf4/node_modules/@statelyai/graph/dist/index.mjs
+//#region ../../node_modules/.pnpm/@statelyai+graph@2.1.0_@statelyai+layout@0.3.0_cytoscape@3.34.0_d3-force@3.0.0_d3-hiera_7624816e5d9226bed30c68417318a8b7/node_modules/@statelyai/graph/dist/index.mjs
 const LAYOUT_KEYS = {
 	node: [
 		"x",
@@ -21781,9 +22421,10 @@ function getOAuthExpiresAt(credential) {
 function isTerminalOAuthRefreshError(error) {
 	return error instanceof Error && /Token refresh failed with HTTP (?:400|401|403)\b/.test(error.message);
 }
+var ExpiredStatelyCredentialError = class extends Error {};
 async function invalidateExpiredOAuthCredential() {
 	await deleteStoredApiKey();
-	throw new Error("Your Stately session expired. Run `npx statelyai login` to continue.");
+	throw new ExpiredStatelyCredentialError("Your Stately session expired. Run `npx statelyai login` to continue.");
 }
 async function refreshStoredOAuthCredential(credential, options) {
 	if (!credential.refreshToken) return invalidateExpiredOAuthCredential();
@@ -21817,7 +22458,7 @@ async function refreshStoredOAuthCredential(credential, options) {
 	}
 }
 async function resolveApiKey(options = {}) {
-	const envApiKey = getEnvApiKey();
+	const envApiKey = options.ignoreEnvironment ? void 0 : getEnvApiKey();
 	if (envApiKey) return {
 		apiKey: envApiKey.apiKey,
 		source: "env",
@@ -22043,22 +22684,32 @@ function formatStoredCredentialSource(storedCredential) {
 	return `Credential source: stored unknown (${describeCredentialBackend(storedCredential.backend, storedCredential.location)}).`;
 }
 async function runOAuthBrowserLogin(options) {
+	options.signal?.throwIfAborted();
 	const state = crypto.randomBytes(16).toString("base64url");
-	const callbackServer = await createLocalOAuthCallbackServer({ state });
+	const callbackServer = await createLocalOAuthCallbackServer({
+		state,
+		signal: options.signal
+	});
+	const loginFetch = (input, init) => fetch(input, {
+		...init,
+		signal: options.signal
+	});
 	try {
 		const { authorizeUrl, codeVerifier, discovery } = await buildOAuthLoginStart({
+			fetch: loginFetch,
 			baseUrl: options.baseUrl,
 			redirectUri: callbackServer.redirectUri,
 			state
 		});
+		options.signal?.throwIfAborted();
 		options.log(`Opening browser for ${discovery.resourceUrl}`);
-		options.log(authorizeUrl);
 		let openedBrowser = false;
 		try {
-			openBrowser(authorizeUrl);
+			await openBrowser(authorizeUrl);
 			openedBrowser = true;
 		} catch {
 			options.log("Could not open a browser automatically.");
+			options.log(authorizeUrl);
 		}
 		const codePromise = callbackServer.waitForCode();
 		const pastedCodePromise = !openedBrowser && process.stdin.isTTY && process.stdout.isTTY ? promptForOAuthCallback().then((value) => {
@@ -22067,13 +22718,16 @@ async function runOAuthBrowserLogin(options) {
 			return callback.code;
 		}) : void 0;
 		const code = await (pastedCodePromise ? Promise.race([codePromise, pastedCodePromise]) : codePromise);
-		return setStoredCredential(createOAuthCredential(await exchangeCodeForToken({
+		const tokenResponse = await exchangeCodeForToken({
+			fetch: loginFetch,
 			tokenEndpoint: discovery.tokenEndpoint,
 			code,
 			codeVerifier,
 			redirectUri: callbackServer.redirectUri,
 			clientId: discovery.clientId
-		}), {
+		});
+		options.signal?.throwIfAborted();
+		return setStoredCredential(createOAuthCredential(tokenResponse, {
 			clientId: discovery.clientId,
 			tokenEndpoint: discovery.tokenEndpoint
 		}));
@@ -22986,7 +23640,16 @@ var OpenCommand = class OpenCommand extends Command {
 	};
 	async run() {
 		const { args, flags } = await this.parse(OpenCommand);
-		const apiKey = (await resolveApiKey()).apiKey;
+		let hasLoggedIn = false;
+		const getApiKey = async () => {
+			try {
+				return (await resolveApiKey({ ignoreEnvironment: hasLoggedIn })).apiKey;
+			} catch (error) {
+				if (error instanceof ExpiredStatelyCredentialError) return void 0;
+				throw error;
+			}
+		};
+		const apiKey = await getApiKey();
 		const cwd = process.cwd();
 		const discovered = args.file ? await discoverMachinesInFile(path.resolve(args.file)) : await scanProjectMachines({ cwd });
 		if (discovered.length === 0) throw new Error(args.file ? `No machines found in ${path.resolve(args.file)}.` : `No machines found in ${cwd}.`);
@@ -23019,7 +23682,19 @@ var OpenCommand = class OpenCommand extends Command {
 			sourceUpdateStrategy: flags["source-update"] ?? configuredSourceUpdateStrategy ?? "preserve",
 			apiKey,
 			studioUrl: resolveApiBaseUrl(configuredStudioUrl),
-			debug: flags.debug
+			debug: flags.debug,
+			getApiKey,
+			onLogin: async (signal) => {
+				const stored = await runOAuthBrowserLogin({
+					baseUrl: flags["editor-url"] ?? getDefaultEditorUrl(),
+					log: (message) => this.log(message),
+					signal
+				});
+				if (stored.credential?.type !== "oauth") throw new Error("Stately login did not return an OAuth credential.");
+				hasLoggedIn = true;
+				this.log("Logged in to Stately. Loading your machine…");
+				return stored.credential.accessToken;
+			}
 		});
 	}
 };