statelyai 0.12.8 → 0.14.0

package/dist/{cli-B2Dd5vY-.mjs → cli-BtgsQvTR.mjs}

@@ -2,30 +2,193 @@ import { Args, Command, Flags, flush, handle, run } from "@oclif/core";
 import fsPromises from "node:fs/promises";
 import * as path$1 from "node:path";
 import path from "node:path";
+import { changeSet, createFileStore, createLoop, parseModelGraph, proposalOutline, verdictLines, verify } from "@statelyai/mcp/loop";
 import { z, z as z$1 } from "zod";
 import { execFile, execFileSync, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import * as crypto from "node:crypto";
+import { randomUUID } from "node:crypto";
+import { StudioApiError, buildAuthorizeUrl, createPkcePair, createStatelyClient, discoverAuthorizationServer, discoverProtectedResource, exchangeCodeForToken, refreshToken, registerOAuthClient } from "@statelyai/sdk";
+import * as ts$1 from "typescript";
+import ts from "typescript";
 import fs, { promises, statSync, watch } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { Writable } from "node:stream";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import * as http from "node:http";
-import * as ts$1 from "typescript";
-import ts from "typescript";
 import * as fs$1 from "fs";
 import * as path$2 from "path";
 import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1 } from "url";
 import { fromStudioMachine, toStudioMachine } from "@statelyai/sdk/graph";
 import { EDITOR_PROTOCOL_VERSION } from "@statelyai/sdk/editor-host-protocol";
-import { createStatelyClient, createStatelyClient as createStatelyClient$1$1 } from "@statelyai/sdk/studio";
+import { createStatelyClient as createStatelyClient$1, createStatelyClient as createStatelyClient$1$1 } from "@statelyai/sdk/studio";
 import { WebSocket, WebSocketServer } from "ws";
 import os from "node:os";
-import { StudioApiError, buildAuthorizeUrl, createPkcePair, createStatelyClient as createStatelyClient$1, discoverAuthorizationServer, discoverProtectedResource, exchangeCodeForToken, refreshToken, registerOAuthClient } from "@statelyai/sdk";
 
 //#region \0rolldown/runtime.js
 var __commonJSMin$1 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
+//#endregion
+//#region src/loopCommands.ts
+/** An XGraph file, or a `.statelyai` head or version file (its `graph`). */
+async function readGraphFile(file) {
+	const value = JSON.parse(await fsPromises.readFile(file, "utf8"));
+	return parseModelGraph(Array.isArray(value.nodes) ? value : value.graph);
+}
+/** `statelyai changes`: change lines and the proposed flow outline, base -> proposed. */
+async function changesReport(baseFile, proposedFile, json = false) {
+	const [base, proposed] = await Promise.all([readGraphFile(baseFile), readGraphFile(proposedFile)]);
+	const { comparison, changes } = await changeSet(base, proposed);
+	if (json) return {
+		text: JSON.stringify({
+			changes,
+			comparison
+		}, null, 2),
+		exitCode: 0
+	};
+	return {
+		text: [
+			...changes.length ? changes.map((line) => `- ${line}`) : ["No behavior changes."],
+			"",
+			proposalOutline({
+				name: path.basename(proposedFile),
+				proposed,
+				comparison,
+				changes
+			})
+		].join("\n"),
+		exitCode: 0
+	};
+}
+/** `statelyai verify <proposal> <regenerated>`: behavior verdict; 1 on drift, 2 when unavailable. */
+async function verifyReport(proposalFile, regeneratedFile, json = false) {
+	const [proposal, regenerated] = await Promise.all([readGraphFile(proposalFile), readGraphFile(regeneratedFile)]);
+	const verdict = await verify(path.basename(proposalFile), proposal, regenerated);
+	return {
+		text: json ? JSON.stringify(verdict, null, 2) : verdictLines(verdict).join("\n"),
+		exitCode: verdict.status === "matches" ? 0 : verdict.status === "drifted" ? 1 : 2
+	};
+}
+const localLoop = (root) => createLoop({ store: createFileStore(root) });
+/** `statelyai brief`: the Apply brief for a pending proposal in `.statelyai/`. */
+async function briefReport(root, machineId, versionId, json = false) {
+	const loop = localLoop(root);
+	const brief = await loop.brief(machineId, versionId);
+	if (json) return {
+		text: JSON.stringify(brief, null, 2),
+		exitCode: 0
+	};
+	const proposal = await loop.getProposal(machineId, versionId);
+	return {
+		text: [
+			proposalOutline({
+				name: `${brief.name} (${machineId}, ${versionId}, from ${brief.origin === "prompt" ? "a prompt" : "the editor"})`,
+				proposed: proposal.proposed,
+				comparison: proposal.comparison,
+				changes: proposal.changes,
+				evidence: proposal.evidence
+			}),
+			"",
+			brief.text
+		].join("\n"),
+		exitCode: 0
+	};
+}
+/** `statelyai pending`: proposals in `.statelyai/` whose baseline is still the head. */
+async function pendingReport(root, json = false) {
+	const { proposals } = await localLoop(root).listPendingProposals({});
+	if (json) return {
+		text: JSON.stringify({ proposals }, null, 2),
+		exitCode: 0
+	};
+	if (!proposals.length) return {
+		text: "No pending proposals in .statelyai/.",
+		exitCode: 0
+	};
+	return {
+		text: proposals.flatMap((proposal) => [
+			`- ${JSON.stringify(proposal.name)} for ${JSON.stringify(proposal.machineName)} (from ${proposal.origin === "prompt" ? "a prompt" : "the editor"})`,
+			`  statelyai brief ${proposal.machineId} --proposal ${proposal.versionId}`,
+			...proposal.changes.map((line) => `  - ${line}`)
+		]).join("\n"),
+		exitCode: 0
+	};
+}
+const jsonFlag = Flags.boolean({
+	description: "Print machine-readable JSON",
+	default: false
+});
+const rootFlag = Flags.string({ description: "Repository root containing .statelyai/ (defaults to the current directory)" });
+var ReportCommand = class extends Command {
+	static enableJsonFlag = false;
+	async print(report) {
+		let result;
+		try {
+			result = await report;
+		} catch (error) {
+			this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+		}
+		this.log(result.text);
+		if (result.exitCode) this.exit(result.exitCode);
+	}
+};
+var ChangesCommand = class ChangesCommand extends ReportCommand {
+	static summary = "Print the behavior changes between two machine graphs.";
+	static description = "Compares XGraph JSON files (or .statelyai head and version files) offline, then prints change lines and an outline of the proposed flow.";
+	static args = {
+		base: Args.string({
+			required: true,
+			description: "Base XGraph JSON file"
+		}),
+		proposed: Args.string({
+			required: true,
+			description: "Proposed XGraph JSON file"
+		})
+	};
+	static flags = {
+		help: Flags.help({ char: "h" }),
+		json: jsonFlag
+	};
+	async run() {
+		const { args, flags } = await this.parse(ChangesCommand);
+		await this.print(changesReport(args.base, args.proposed, flags.json));
+	}
+};
+var BriefCommand = class BriefCommand extends ReportCommand {
+	static summary = "Print the implementation brief for a pending local proposal.";
+	static description = "Reads .statelyai/ and prints the proposal outline and the Apply message an agent implements. Fails when the model changed since the proposal.";
+	static args = { machine: Args.string({
+		required: true,
+		description: "Machine id (its .statelyai/machines file name)"
+	}) };
+	static flags = {
+		help: Flags.help({ char: "h" }),
+		proposal: Flags.string({
+			required: true,
+			description: "Proposal version id, for example v0002"
+		}),
+		root: rootFlag,
+		json: jsonFlag
+	};
+	async run() {
+		const { args, flags } = await this.parse(BriefCommand);
+		await this.print(briefReport(flags.root ?? process.cwd(), args.machine, flags.proposal, flags.json));
+	}
+};
+var PendingCommand = class PendingCommand extends ReportCommand {
+	static summary = "List pending proposals in .statelyai/.";
+	static description = "Lists proposals whose baseline still matches the machine head, newest first.";
+	static flags = {
+		help: Flags.help({ char: "h" }),
+		root: rootFlag,
+		json: jsonFlag
+	};
+	async run() {
+		const { flags } = await this.parse(PendingCommand);
+		await this.print(pendingReport(flags.root ?? process.cwd(), flags.json));
+	}
+};
+
 //#endregion
 //#region ../api-contract/dist/verification.mjs
 const count = z.number().int().nonnegative();
@@ -679,7 +842,11 @@ async function verifyProject(options = {}) {
 var VerifyCommand = class VerifyCommand extends Command {
 	static enableJsonFlag = false;
 	static summary = "Validate a verification report, print its verdict, and export JSON or JUnit.";
-	static description = "Saved-report processing works offline. Live execution requires a configured verification adapter.";
+	static description = "Saved-report processing works offline. Live execution requires a configured verification adapter. With two graph files, compares a proposal with its regeneration instead (exit 1 on drift).";
+	static args = {
+		proposal: Args.string({ description: "Proposal XGraph JSON file (or .statelyai version file) to compare" }),
+		regenerated: Args.string({ description: "Regenerated XGraph JSON file (or .statelyai head file)" })
+	};
 	static flags = {
 		model: Flags.string({ description: "Model file or registry machine ID (live execution)" }),
 		bindings: Flags.string({ description: "Bindings file (live execution)" }),
@@ -698,7 +865,19 @@ var VerifyCommand = class VerifyCommand extends Command {
 		})
 	};
 	async run() {
-		const { flags } = await this.parse(VerifyCommand);
+		const { args, flags } = await this.parse(VerifyCommand);
+		if (args.proposal || args.regenerated) {
+			if (!args.proposal || !args.regenerated) this.error("Pass both the proposal and the regenerated graph files.", { exit: 2 });
+			let report;
+			try {
+				report = await verifyReport(args.proposal, args.regenerated);
+			} catch (error) {
+				this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+			}
+			this.log(report.text);
+			if (report.exitCode) this.exit(report.exitCode);
+			return;
+		}
 		let result;
 		try {
 			result = await verifyProject({
@@ -719,6 +898,236 @@ var VerifyCommand = class VerifyCommand extends Command {
 	}
 };
 
+//#endregion
+//#region ../editor-sync/dist/statelyPragma-D46lczJR.mjs
+function findStatelyPragmaAttachments(sourceText, fileName = "machine.ts") {
+	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind$4(fileName));
+	const attachments = [];
+	const visit = (node) => {
+		if (ts.isCallExpression(node) && isCreateMachineExpression$3(node.expression)) {
+			const attachNode = findAttachNode(node);
+			if (attachNode) attachments.push({
+				machineStart: getMachineExpressionStart(node.expression, sourceFile),
+				attachStart: attachNode.getStart(sourceFile),
+				pragma: findAttachedStatelyPragma(sourceText, attachNode)
+			});
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return attachments;
+}
+function getStatelyPragma(sourceText, fileName = "machine.ts", machineIndex = 0) {
+	return findStatelyPragmaAttachments(sourceText, fileName)[machineIndex]?.pragma;
+}
+function upsertStatelyPragma(sourceText, id, options = {}) {
+	const attachment = findStatelyPragmaAttachments(sourceText, options.fileName ?? "machine.ts")[options.machineIndex ?? 0];
+	if (!attachment) return sourceText;
+	const lineEnding = options.lineEnding ?? detectLineEnding(sourceText);
+	const canonicalComment = `// @statelyai id=${id}`;
+	if (attachment.pragma) return sourceText.slice(0, attachment.pragma.start) + canonicalComment + sourceText.slice(attachment.pragma.end);
+	const insertText = `${getIndentationAtOffset(sourceText, attachment.attachStart)}${canonicalComment}${lineEnding}`;
+	return sourceText.slice(0, attachment.attachStart) + insertText + sourceText.slice(attachment.attachStart);
+}
+function findAttachedStatelyPragma(sourceText, node) {
+	const comments = ts.getLeadingCommentRanges(sourceText, node.getFullStart()) ?? [];
+	for (let index = comments.length - 1; index >= 0; index -= 1) {
+		const comment = comments[index];
+		const parsed = parseStatelyPragma(sourceText, comment.pos, comment.end);
+		if (parsed) return parsed;
+	}
+}
+function parseStatelyPragma(sourceText, start, end) {
+	const match = normalizeCommentContent(sourceText.slice(start, end)).match(/^@statelyai(?:\s+(.*))?$/s);
+	if (!match) return;
+	const fields = parseFields(match[1] ?? "");
+	return {
+		tag: "@statelyai",
+		id: fields.id,
+		fields,
+		start,
+		end
+	};
+}
+function normalizeCommentContent(rawComment) {
+	if (rawComment.startsWith("//")) return rawComment.slice(2).trim();
+	if (rawComment.startsWith("/*")) return rawComment.slice(2, rawComment.endsWith("*/") ? -2 : void 0).split(/\r?\n/).map((line) => line.replace(/^\s*\*\s?/, "")).join(" ").trim();
+	return rawComment.trim();
+}
+function parseFields(input) {
+	const fields = {};
+	for (const token of input.split(/\s+/)) {
+		if (!token) continue;
+		const equalsIndex = token.indexOf("=");
+		if (equalsIndex <= 0) continue;
+		const key = token.slice(0, equalsIndex);
+		const value = token.slice(equalsIndex + 1);
+		if (!key || !value) continue;
+		fields[key] = value;
+	}
+	return fields;
+}
+function findAttachNode(node) {
+	let current = node;
+	while (current?.parent) {
+		if (ts.isVariableStatement(current.parent) || ts.isExpressionStatement(current.parent) || ts.isExportAssignment(current.parent)) return current.parent;
+		current = current.parent;
+	}
+	return current;
+}
+function isCreateMachineExpression$3(expression) {
+	const isMachineFactoryName = (name) => name === "createMachine" || name === "createMachineFromConfig";
+	return ts.isIdentifier(expression) && isMachineFactoryName(expression.text) || ts.isPropertyAccessExpression(expression) && isMachineFactoryName(expression.name.text);
+}
+function getMachineExpressionStart(expression, sourceFile) {
+	if (ts.isPropertyAccessExpression(expression)) return expression.name.getStart(sourceFile);
+	return expression.getStart(sourceFile);
+}
+function getIndentationAtOffset(sourceText, offset) {
+	const lineStart = sourceText.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
+	return sourceText.slice(lineStart, offset).match(/^[ \t]*/)?.[0] ?? "";
+}
+function detectLineEnding(sourceText) {
+	return sourceText.includes("\r\n") ? "\r\n" : "\n";
+}
+function getScriptKind$4(fileName) {
+	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (fileName.endsWith(".js")) return ts.ScriptKind.JS;
+	return ts.ScriptKind.TS;
+}
+
+//#endregion
+//#region src/link.ts
+function resourceId(locator, kind) {
+	let id = locator.trim();
+	if (/^https?:\/\//.test(id)) {
+		const url = new URL(id);
+		id = kind === "machine" ? url.searchParams.get("machineId") ?? url.pathname.match(/\/machines?\/([^/]+)/)?.[1] ?? "" : url.pathname.match(/\/(?:projects?|editor)\/([^/]+)/)?.[1] ?? "";
+		id = decodeURIComponent(id);
+	}
+	if (!/^[\w-]+$/.test(id)) throw new Error(`Pass a ${kind} ID or a URL containing a ${kind} ID.`);
+	return id;
+}
+/** Association only: no definitions are uploaded, downloaded, or executed. */
+async function linkProject(options) {
+	if (options.projectId && options.create) throw new Error("Choose --project or --create, not both.");
+	if (Boolean(options.file) !== Boolean(options.machineId)) throw new Error("Machine association requires a file and --machine <id|url>.");
+	if (options.create && options.machineId) throw new Error("Link an existing machine to its existing project with --project; --create creates an empty project.");
+	if (options.visibility && !options.create) throw new Error("--visibility requires --create.");
+	if (options.name && !options.create) throw new Error("--name requires --create.");
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	const configPath = path.resolve(cwd, options.configPath ?? STATELY_CONFIG_FILE);
+	const existing = await readStatelyProjectConfig({
+		cwd,
+		configPath,
+		rewriteIfNeeded: false
+	}).catch((error) => {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	});
+	if (existing?.rewriteStatus.reason === "multiple-legacy-sources") throw new Error("Update the legacy sources configuration manually before linking; no files were changed.");
+	const studioUrl = options.baseUrl ?? existing?.config.studioUrl ?? "https://stately.ai";
+	const requestedId = options.projectId ? resourceId(options.projectId, "project") : void 0;
+	const sameDeployment = !existing?.config.studioUrl || resolveApiBaseUrl(studioUrl) === resolveApiBaseUrl(existing.config.studioUrl);
+	if (existing?.config.projectId && (!sameDeployment || options.create || requestedId && requestedId !== existing.config.projectId) && !options.force) throw new Error(`Already linked to project ${existing.config.projectId}. Use --force to change the project association; existing machine IDs are retained.`);
+	const machineId = options.machineId ? resourceId(options.machineId, "machine") : void 0;
+	const filePath = options.file ? path.resolve(cwd, options.file) : void 0;
+	const source = filePath ? await fsPromises.readFile(filePath, "utf8") : void 0;
+	const machineIndex = options.machineIndex ?? 0;
+	if (filePath && source !== void 0) {
+		if (!/\.[cm]?[jt]sx?$/.test(filePath)) throw new Error("Machine association supports JavaScript and TypeScript source files.");
+		const attachments = findStatelyPragmaAttachments(source, filePath);
+		if (attachments.length > 1 && options.machineIndex === void 0) throw new Error("This file contains multiple machines. Select one with --machine-index (zero-based).");
+		const attachment = attachments[machineIndex];
+		if (!attachment || !Number.isInteger(machineIndex) || machineIndex < 0) throw new Error("No machine at the selected index.");
+		if (attachment.pragma?.id && attachment.pragma.id !== machineId && !options.force) throw new Error(`Machine already linked to ${attachment.pragma.id}. Use --force to replace its association.`);
+	} else if (options.machineIndex !== void 0) throw new Error("--machine-index requires a file and --machine.");
+	const client = options.client ?? createStatelyClient({
+		apiKey: options.apiKey,
+		baseUrl: resolveApiBaseUrl(studioUrl)
+	});
+	let project;
+	if (options.create) project = await client.projects.create({
+		name: options.name ?? path.basename(cwd),
+		visibility: options.visibility ?? "Private"
+	});
+	else {
+		const projectId = requestedId ?? existing?.config.projectId;
+		if (!projectId) throw new Error("Choose --project <id|url> or --create to connect this workspace.");
+		project = await client.projects.get(projectId);
+	}
+	if (machineId) {
+		if (!project.machines.some((machine) => machine.machineId === machineId)) throw new Error(`Machine ${machineId} is not in project ${project.projectId}. No files were changed.`);
+		await client.machines.get(machineId);
+	}
+	if (filePath && await fsPromises.readFile(filePath, "utf8") !== source) throw new Error("Source changed while linking. Retry; no files were changed.");
+	const config = {
+		...existing?.config ?? createStatelyProjectConfig({}),
+		projectId: project.projectId,
+		studioUrl
+	};
+	const writes = [];
+	const stage = async (destination, write) => {
+		const suffix = randomUUID();
+		const entry = {
+			path: destination,
+			staged: `${destination}.${suffix}.tmp`,
+			backup: `${destination}.${suffix}.bak`,
+			existed: false,
+			committed: false
+		};
+		writes.push(entry);
+		try {
+			await fsPromises.copyFile(destination, entry.backup);
+			entry.existed = true;
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await write(entry.staged);
+		if (entry.existed) await fsPromises.chmod(entry.staged, (await fsPromises.stat(destination)).mode);
+	};
+	let rollbackFailed = false;
+	try {
+		await stage(configPath, (temporary) => writeStatelyProjectConfig(temporary, config));
+		if (filePath && source !== void 0 && machineId) {
+			const updated = upsertStatelyPragma(source, machineId, {
+				fileName: filePath,
+				machineIndex
+			});
+			if (updated !== source) await stage(filePath, (temporary) => fsPromises.writeFile(temporary, updated, "utf8"));
+		}
+		if (filePath && await fsPromises.readFile(filePath, "utf8") !== source) throw new Error("Source changed while linking. Retry; no files were changed.");
+		for (const entry of writes) {
+			await fsPromises.rename(entry.staged, entry.path);
+			entry.committed = true;
+		}
+	} catch (error) {
+		const rollbackErrors = [];
+		for (const entry of [...writes].reverse()) {
+			if (!entry.committed) continue;
+			try {
+				if (entry.existed) await fsPromises.rename(entry.backup, entry.path);
+				else await fsPromises.unlink(entry.path);
+			} catch (rollbackError) {
+				rollbackFailed = true;
+				rollbackErrors.push(rollbackError);
+			}
+		}
+		if (rollbackFailed) throw new AggregateError([error, ...rollbackErrors], "Link failed and could not restore every file. Original files are retained in .bak files beside their destinations.");
+		throw error;
+	} finally {
+		await Promise.all(writes.flatMap((entry) => rollbackFailed ? [entry.staged] : [entry.staged, entry.backup]).map((temporary) => fsPromises.rm(temporary, { force: true })));
+	}
+	return {
+		project,
+		config,
+		configPath,
+		machineId,
+		filePath
+	};
+}
+
 //#endregion
 //#region ../editor-sync/dist/fs-Dw5c-Wnp.mjs
 function comparePosition(left, right) {
@@ -928,131 +1337,467 @@ function offsetAt(lineStarts, line, character) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/xstate@5.32.1/node_modules/xstate/dist/xstate-dev.esm.js
-function getGlobal() {
-	if (typeof globalThis !== "undefined") return globalThis;
-	if (typeof self !== "undefined") return self;
-	if (typeof window !== "undefined") return window;
-	if (typeof global !== "undefined") return global;
-}
-function getDevTools() {
-	const w = getGlobal();
-	if (w.__xstate__) return w.__xstate__;
+//#region ../graph-tools/dist/semanticGraphDiffModel-1Yw70u6x.mjs
+/**
+* Convert a resolved {@link GraphNode} back into a {@link NodeConfig}.
+*
+* Faithful and complete: round-tripping through `createGraphNode` yields a
+* deep-equal node. Optional fields are only included when present; ports are
+* deep-copied so the config does not share port objects with the source node.
+*/
+function toNodeConfig(node) {
+	const config = { id: node.id };
+	if (node.parentId != null) config.parentId = node.parentId;
+	if (node.initialNodeId != null) config.initialNodeId = node.initialNodeId;
+	if (node.label != null) config.label = node.label;
+	if (node.data != null) config.data = node.data;
+	if (node.ports !== void 0) config.ports = node.ports.map((p) => ({ ...p }));
+	if (node.x !== void 0) config.x = node.x;
+	if (node.y !== void 0) config.y = node.y;
+	if (node.width !== void 0) config.width = node.width;
+	if (node.height !== void 0) config.height = node.height;
+	if (node.shape !== void 0) config.shape = node.shape;
+	if (node.color !== void 0) config.color = node.color;
+	if (node.style !== void 0) config.style = node.style;
+	return config;
 }
-const devToolsAdapter = (service) => {
-	if (typeof window === "undefined") return;
-	const devTools = getDevTools();
-	if (devTools) devTools.register(service);
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/xstate@5.32.1/node_modules/xstate/dist/raise-e974d1c9.esm.js
-var Mailbox = class {
-	constructor(_process) {
-		this._process = _process;
-		this._active = false;
-		this._current = null;
-		this._last = null;
-	}
-	start() {
-		this._active = true;
-		this.flush();
-	}
-	clear() {
-		if (this._current) {
-			this._current.next = null;
-			this._last = this._current;
-		}
-	}
-	enqueue(event) {
-		const enqueued = {
-			value: event,
-			next: null
-		};
-		if (this._current) {
-			this._last.next = enqueued;
-			this._last = enqueued;
-			return;
-		}
-		this._current = enqueued;
-		this._last = enqueued;
-		if (this._active) this.flush();
-	}
-	flush() {
-		while (this._current) {
-			const consumed = this._current;
-			this._process(consumed.value);
-			this._current = consumed.next;
-		}
-		this._last = null;
-	}
-};
-const STATE_DELIMITER = ".";
-const TARGETLESS_KEY = "";
-const NULL_EVENT = "";
-const STATE_IDENTIFIER = "#";
-const WILDCARD = "*";
-const XSTATE_INIT = "xstate.init";
-const XSTATE_STOP = "xstate.stop";
 /**
-* Returns an event that represents an implicit event that is sent after the
-* specified `delay`.
+* Convert a resolved {@link GraphEdge} back into an {@link EdgeConfig}.
 *
-* @param delayRef The delay in milliseconds
-* @param id The state node ID where this event is handled
+* Faithful and complete: round-tripping through `createGraphEdge` yields a
+* deep-equal edge. Optional fields are only included when present.
 */
-function createAfterEvent(delayRef, id) {
-	return { type: `xstate.after.${delayRef}.${id}` };
+function toEdgeConfig(edge) {
+	const config = {
+		id: edge.id,
+		sourceId: edge.sourceId,
+		targetId: edge.targetId
+	};
+	if (edge.label != null) config.label = edge.label;
+	if (edge.data != null) config.data = edge.data;
+	if (edge.weight !== void 0) config.weight = edge.weight;
+	if (edge.mode !== void 0) config.mode = edge.mode;
+	if (edge.sourcePort !== void 0) config.sourcePort = edge.sourcePort;
+	if (edge.targetPort !== void 0) config.targetPort = edge.targetPort;
+	if (edge.points !== void 0) config.points = edge.points.map((p) => ({ ...p }));
+	if (edge.routing !== void 0) config.routing = edge.routing;
+	if (edge.x !== void 0) config.x = edge.x;
+	if (edge.y !== void 0) config.y = edge.y;
+	if (edge.width !== void 0) config.width = edge.width;
+	if (edge.height !== void 0) config.height = edge.height;
+	if (edge.color !== void 0) config.color = edge.color;
+	if (edge.style !== void 0) config.style = edge.style;
+	return config;
+}
+const LAYOUT_KEYS$1 = {
+	node: [
+		"x",
+		"y",
+		"width",
+		"height",
+		"style",
+		"color",
+		"shape"
+	],
+	edge: [
+		"x",
+		"y",
+		"width",
+		"height",
+		"points",
+		"routing",
+		"style",
+		"color"
+	]
+};
+new Set(LAYOUT_KEYS$1.node), new Set(LAYOUT_KEYS$1.edge);
+/** Shallow-compare two values, returning true if they differ. */
+function differs(a, b) {
+	if (a === b) return false;
+	if (a == null || b == null) return a !== b;
+	if (typeof a === "object" && typeof b === "object") return JSON.stringify(a) !== JSON.stringify(b);
+	return true;
 }
+const NODE_COMPARE_KEYS = [
+	"parentId",
+	"initialNodeId",
+	"label",
+	"data",
+	"ports",
+	"x",
+	"y",
+	"width",
+	"height",
+	"shape",
+	"color",
+	"style"
+];
+const EDGE_COMPARE_KEYS = [
+	"sourceId",
+	"targetId",
+	"label",
+	"data",
+	"weight",
+	"mode",
+	"sourcePort",
+	"targetPort",
+	"points",
+	"routing",
+	"x",
+	"y",
+	"width",
+	"height",
+	"color",
+	"style"
+];
 /**
-* Returns an event that represents that a final state node has been reached in
-* the parent state node.
+* Compute a structured diff from graph `a` to graph `b` by matching IDs.
 *
-* @param id The final state node's parent state node `id`
-* @param output The data to pass into the event
+* @example
+* ```ts
+* import { createGraph, getDiff } from '@statelyai/graph';
+*
+* const a = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
+* const b = createGraph({ nodes: [{ id: 'n1', label: 'hello' }, { id: 'n2' }], edges: [] });
+*
+* const diff = getDiff(a, b);
+* // diff.nodes.added → [{ id: 'n2' }]
+* // diff.nodes.updated → [{ id: 'n1', old: { label: '' }, new: { label: 'hello' } }]
+* ```
 */
-function createDoneStateEvent(id, output) {
-	return {
-		type: `xstate.done.state.${id}`,
-		output
+function getDiff(a, b) {
+	const aNodeMap = new Map(a.nodes.map((n) => [n.id, n]));
+	const bNodeMap = new Map(b.nodes.map((n) => [n.id, n]));
+	const aEdgeMap = new Map(a.edges.map((e) => [e.id, e]));
+	const bEdgeMap = new Map(b.edges.map((e) => [e.id, e]));
+	const diff = {
+		nodes: {
+			added: [],
+			removed: [],
+			updated: []
+		},
+		edges: {
+			added: [],
+			removed: [],
+			updated: []
+		}
 	};
+	for (const [id, nodeB] of bNodeMap) {
+		const nodeA = aNodeMap.get(id);
+		if (!nodeA) diff.nodes.added.push(toNodeConfig(nodeB));
+		else {
+			const oldPartial = {};
+			const newPartial = {};
+			for (const key of NODE_COMPARE_KEYS) {
+				const oldValue = nodeA[key] ?? null;
+				const newValue = nodeB[key] ?? null;
+				if (differs(oldValue, newValue)) {
+					oldPartial[key] = oldValue;
+					newPartial[key] = newValue;
+				}
+			}
+			if (Object.keys(oldPartial).length > 0) diff.nodes.updated.push({
+				id,
+				old: oldPartial,
+				new: newPartial
+			});
+		}
+	}
+	for (const [id, nodeA] of aNodeMap) if (!bNodeMap.has(id)) diff.nodes.removed.push(toNodeConfig(nodeA));
+	for (const [id, edgeB] of bEdgeMap) {
+		const edgeA = aEdgeMap.get(id);
+		if (!edgeA) diff.edges.added.push(toEdgeConfig(edgeB));
+		else {
+			const oldPartial = {};
+			const newPartial = {};
+			for (const key of EDGE_COMPARE_KEYS) {
+				const oldValue = edgeA[key] ?? null;
+				const newValue = edgeB[key] ?? null;
+				if (differs(oldValue, newValue)) {
+					oldPartial[key] = oldValue;
+					newPartial[key] = newValue;
+				}
+			}
+			if (Object.keys(oldPartial).length > 0) diff.edges.updated.push({
+				id,
+				old: oldPartial,
+				new: newPartial
+			});
+		}
+	}
+	for (const [id, edgeA] of aEdgeMap) if (!bEdgeMap.has(id)) diff.edges.removed.push(toEdgeConfig(edgeA));
+	return diff;
 }
 /**
-* Returns an event that represents that an invoked service has terminated.
+* Check if a diff has zero changes.
 *
-* An invoked service is terminated when it has reached a top-level final state
-* node, but not when it is canceled.
+* @example
+* ```ts
+* import { createGraph, getDiff, isEmptyDiff } from '@statelyai/graph';
 *
-* @param invokeId The invoked service ID
-* @param output The data to pass into the event
+* const g = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
+* const diff = getDiff(g, g);
+* isEmptyDiff(diff); // true
+* ```
 */
-function createDoneActorEvent(invokeId, output) {
-	return {
-		type: `xstate.done.actor.${invokeId}`,
-		output,
-		actorId: invokeId
-	};
+function isEmptyDiff$1(diff) {
+	return diff.nodes.added.length === 0 && diff.nodes.removed.length === 0 && diff.nodes.updated.length === 0 && diff.edges.added.length === 0 && diff.edges.removed.length === 0 && diff.edges.updated.length === 0;
 }
-function createErrorActorEvent(id, error) {
+function summarizeGraphDiff(diff) {
 	return {
-		type: `xstate.error.actor.${id}`,
-		error,
-		actorId: id
+		hasChanges: !isEmptyDiff$1(diff),
+		nodeChanges: diff.nodes.added.length + diff.nodes.removed.length + diff.nodes.updated.length,
+		edgeChanges: diff.edges.added.length + diff.edges.removed.length + diff.edges.updated.length
 	};
 }
-function createInitEvent(input) {
-	return {
-		type: XSTATE_INIT,
-		input
-	};
+function nodeDepth$1(graph, node) {
+	let depth = 0;
+	let parentId = node.parentId;
+	while (parentId) {
+		depth++;
+		parentId = graph.nodes.find((candidate) => candidate.id === parentId)?.parentId;
+	}
+	return depth;
 }
-/**
-* This function makes sure that unhandled errors are thrown in a separate
-* macrotask. It allows those errors to be detected by global error handlers and
-* reported to bug tracking services without interrupting our own stack of
-* execution.
-*
-* @param err Error to be thrown
+function nodeKey(node) {
+	return node.data?.key || node.id;
+}
+function edgeSignature(edge) {
+	return [
+		edge.sourceId,
+		edge.data?.eventType,
+		edge.targetId,
+		edge.data?.guard?.type ?? ""
+	].join("->");
+}
+function getStableNodeId(node, parentStableId, siblingIndex, preferredIds) {
+	const preferredId = preferredIds?.get(node.id);
+	if (preferredId !== void 0) return preferredId;
+	if (node.parentId === null) return "root";
+	const key = nodeKey(node);
+	const suffix = siblingIndex === 0 ? key : `${key}_${siblingIndex + 1}`;
+	return parentStableId ? `${parentStableId}.${suffix}` : suffix;
+}
+function getStableEdgeId(edge, siblingIndex, preferredIds) {
+	const preferredId = preferredIds?.get(edge.id);
+	if (preferredId !== void 0) return preferredId;
+	const suffix = siblingIndex === 0 ? "" : `.${siblingIndex + 1}`;
+	return edgeSignature(edge).concat(suffix);
+}
+function removePresentationFields(entity, kind) {
+	const mutableEntity = entity;
+	for (const key of LAYOUT_KEYS$1[kind]) delete mutableEntity[key];
+	const data = mutableEntity.data;
+	if (data && typeof data === "object" && !Array.isArray(data)) delete data.color;
+}
+/**
+* Rewrites entity ids to structural ("semantic") ids so two graphs that model
+* the same machine compare equal regardless of how their ids were minted.
+*
+* Invariant: node and edge array order is preserved exactly. Callers
+* (`alignCompareIds` in the editor's /v1/diff route) rely on
+* `normalized.nodes[i]` describing `graph.nodes[i]` to translate a semantic id
+* back to the caller's original id. Never sort, filter, or reorder the arrays
+* on the returned graph; sorting for traversal must be done on a copy, as the
+* depth ordering below does.
+*
+* Presentation-only fields defined by `LAYOUT_KEYS`, plus entity data colors,
+* are removed. When preferred ids are supplied, matching raw ids retain the
+* base graph's semantic identity so a stable-id rename is reported as an
+* update.
+*
+* Entity `data` is treated as optional throughout: sparse graphs (a node with
+* `data: {}`, an edge with `data: null`) normalize instead of throwing.
+*/
+function normalizeGraphForSemanticDiff(graph, preferredIds) {
+	const normalized = structuredClone(graph);
+	const nodeIdMap = /* @__PURE__ */ new Map();
+	const siblingKeys = /* @__PURE__ */ new Map();
+	const reservedNodeIds = new Set(preferredIds?.nodes.values());
+	const claimedNodeIds = /* @__PURE__ */ new Set();
+	const nodesByDepth = [...normalized.nodes].sort((a, b) => nodeDepth$1(normalized, a) - nodeDepth$1(normalized, b));
+	for (const node of nodesByDepth) {
+		const parentStableId = node.parentId ? nodeIdMap.get(node.parentId) ?? node.parentId : null;
+		const key = `${parentStableId ?? ""}:${nodeKey(node)}`;
+		const siblingIndex = siblingKeys.get(key) ?? 0;
+		siblingKeys.set(key, siblingIndex + 1);
+		const proposedId = getStableNodeId(node, parentStableId, siblingIndex, preferredIds?.nodes);
+		let stableId = proposedId;
+		let collisionIndex = 2;
+		while (!preferredIds?.nodes.has(node.id) && (reservedNodeIds.has(stableId) || claimedNodeIds.has(stableId))) stableId = `${proposedId}:unmatched:${collisionIndex++}`;
+		claimedNodeIds.add(stableId);
+		nodeIdMap.set(node.id, stableId);
+	}
+	for (const node of normalized.nodes) {
+		removePresentationFields(node, "node");
+		node.id = nodeIdMap.get(node.id) ?? node.id;
+		if (node.parentId) node.parentId = nodeIdMap.get(node.parentId) ?? node.parentId;
+		if (node.initialNodeId) node.initialNodeId = nodeIdMap.get(node.initialNodeId) ?? node.initialNodeId;
+		if (node.data?.initialId) node.data.initialId = nodeIdMap.get(node.data.initialId) ?? node.data.initialId;
+	}
+	const edgeSiblingKeys = /* @__PURE__ */ new Map();
+	const reservedEdgeIds = new Set(preferredIds?.edges.values());
+	const claimedEdgeIds = /* @__PURE__ */ new Set();
+	for (const edge of normalized.edges) {
+		removePresentationFields(edge, "edge");
+		edge.sourceId = nodeIdMap.get(edge.sourceId) ?? edge.sourceId;
+		edge.targetId = nodeIdMap.get(edge.targetId) ?? edge.targetId;
+		const key = edgeSignature(edge);
+		const siblingIndex = edgeSiblingKeys.get(key) ?? 0;
+		edgeSiblingKeys.set(key, siblingIndex + 1);
+		const proposedId = getStableEdgeId(edge, siblingIndex, preferredIds?.edges);
+		let stableId = proposedId;
+		let collisionIndex = 2;
+		while (!preferredIds?.edges.has(edge.id) && (reservedEdgeIds.has(stableId) || claimedEdgeIds.has(stableId))) stableId = `${proposedId}:unmatched:${collisionIndex++}`;
+		claimedEdgeIds.add(stableId);
+		edge.id = stableId;
+	}
+	if (normalized.initialNodeId) normalized.initialNodeId = nodeIdMap.get(normalized.initialNodeId) ?? normalized.initialNodeId;
+	return normalized;
+}
+function diffGraphsSemantically(baseGraph, compareGraph) {
+	const base = normalizeGraphForSemanticDiff(baseGraph);
+	const compareNodeIds = new Set(compareGraph.nodes.map((node) => node.id));
+	const compareEdgeIds = new Set(compareGraph.edges.map((edge) => edge.id));
+	const compare = normalizeGraphForSemanticDiff(compareGraph, {
+		nodes: new Map(baseGraph.nodes.map((node, index) => [node.id, base.nodes[index].id]).filter(([id]) => compareNodeIds.has(id))),
+		edges: new Map(baseGraph.edges.map((edge, index) => [edge.id, base.edges[index].id]).filter(([id]) => compareEdgeIds.has(id)))
+	});
+	const diff = getDiff(base, compare);
+	return {
+		base,
+		compare,
+		diff,
+		summary: summarizeGraphDiff(diff)
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.32.1/node_modules/xstate/dist/xstate-dev.esm.js
+function getGlobal() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof self !== "undefined") return self;
+	if (typeof window !== "undefined") return window;
+	if (typeof global !== "undefined") return global;
+}
+function getDevTools() {
+	const w = getGlobal();
+	if (w.__xstate__) return w.__xstate__;
+}
+const devToolsAdapter = (service) => {
+	if (typeof window === "undefined") return;
+	const devTools = getDevTools();
+	if (devTools) devTools.register(service);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.32.1/node_modules/xstate/dist/raise-e974d1c9.esm.js
+var Mailbox = class {
+	constructor(_process) {
+		this._process = _process;
+		this._active = false;
+		this._current = null;
+		this._last = null;
+	}
+	start() {
+		this._active = true;
+		this.flush();
+	}
+	clear() {
+		if (this._current) {
+			this._current.next = null;
+			this._last = this._current;
+		}
+	}
+	enqueue(event) {
+		const enqueued = {
+			value: event,
+			next: null
+		};
+		if (this._current) {
+			this._last.next = enqueued;
+			this._last = enqueued;
+			return;
+		}
+		this._current = enqueued;
+		this._last = enqueued;
+		if (this._active) this.flush();
+	}
+	flush() {
+		while (this._current) {
+			const consumed = this._current;
+			this._process(consumed.value);
+			this._current = consumed.next;
+		}
+		this._last = null;
+	}
+};
+const STATE_DELIMITER = ".";
+const TARGETLESS_KEY = "";
+const NULL_EVENT = "";
+const STATE_IDENTIFIER = "#";
+const WILDCARD = "*";
+const XSTATE_INIT = "xstate.init";
+const XSTATE_STOP = "xstate.stop";
+/**
+* Returns an event that represents an implicit event that is sent after the
+* specified `delay`.
+*
+* @param delayRef The delay in milliseconds
+* @param id The state node ID where this event is handled
+*/
+function createAfterEvent(delayRef, id) {
+	return { type: `xstate.after.${delayRef}.${id}` };
+}
+/**
+* Returns an event that represents that a final state node has been reached in
+* the parent state node.
+*
+* @param id The final state node's parent state node `id`
+* @param output The data to pass into the event
+*/
+function createDoneStateEvent(id, output) {
+	return {
+		type: `xstate.done.state.${id}`,
+		output
+	};
+}
+/**
+* Returns an event that represents that an invoked service has terminated.
+*
+* An invoked service is terminated when it has reached a top-level final state
+* node, but not when it is canceled.
+*
+* @param invokeId The invoked service ID
+* @param output The data to pass into the event
+*/
+function createDoneActorEvent(invokeId, output) {
+	return {
+		type: `xstate.done.actor.${invokeId}`,
+		output,
+		actorId: invokeId
+	};
+}
+function createErrorActorEvent(id, error) {
+	return {
+		type: `xstate.error.actor.${id}`,
+		error,
+		actorId: id
+	};
+}
+function createInitEvent(input) {
+	return {
+		type: XSTATE_INIT,
+		input
+	};
+}
+/**
+* This function makes sure that unhandled errors are thrown in a separate
+* macrotask. It allows those errors to be detected by global error handlers and
+* reported to bug tracking services without interrupting our own stack of
+* execution.
+*
+* @param err Error to be thrown
 */
 function reportUnhandledError(err) {
 	setTimeout(() => {
@@ -5831,373 +6576,40 @@ var import_js_yaml = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((ex
 			throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
 		};
 	}
-	module.exports.Type = require_type();
-	module.exports.Schema = require_schema();
-	module.exports.FAILSAFE_SCHEMA = require_failsafe();
-	module.exports.JSON_SCHEMA = require_json();
-	module.exports.CORE_SCHEMA = require_core();
-	module.exports.DEFAULT_SCHEMA = require_default();
-	module.exports.load = loader.load;
-	module.exports.loadAll = loader.loadAll;
-	module.exports.dump = dumper.dump;
-	module.exports.YAMLException = require_exception();
-	module.exports.types = {
-		binary: require_binary(),
-		float: require_float(),
-		map: require_map(),
-		null: require_null(),
-		pairs: require_pairs(),
-		set: require_set(),
-		timestamp: require_timestamp(),
-		bool: require_bool(),
-		int: require_int(),
-		merge: require_merge(),
-		omap: require_omap(),
-		seq: require_seq(),
-		str: require_str()
-	};
-	module.exports.safeLoad = renamed("safeLoad", "load");
-	module.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
-	module.exports.safeDump = renamed("safeDump", "dump");
-})))(), 1);
-var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default;
-var index_vite_proxy_tmp_default = import_js_yaml.default;
-
-//#endregion
-//#region ../graph-tools/dist/index.mjs
-/**
-* Convert a resolved {@link GraphNode} back into a {@link NodeConfig}.
-*
-* Faithful and complete: round-tripping through `createGraphNode` yields a
-* deep-equal node. Optional fields are only included when present; ports are
-* deep-copied so the config does not share port objects with the source node.
-*/
-function toNodeConfig(node) {
-	const config = { id: node.id };
-	if (node.parentId != null) config.parentId = node.parentId;
-	if (node.initialNodeId != null) config.initialNodeId = node.initialNodeId;
-	if (node.label != null) config.label = node.label;
-	if (node.data != null) config.data = node.data;
-	if (node.ports !== void 0) config.ports = node.ports.map((p) => ({ ...p }));
-	if (node.x !== void 0) config.x = node.x;
-	if (node.y !== void 0) config.y = node.y;
-	if (node.width !== void 0) config.width = node.width;
-	if (node.height !== void 0) config.height = node.height;
-	if (node.shape !== void 0) config.shape = node.shape;
-	if (node.color !== void 0) config.color = node.color;
-	if (node.style !== void 0) config.style = node.style;
-	return config;
-}
-/**
-* Convert a resolved {@link GraphEdge} back into an {@link EdgeConfig}.
-*
-* Faithful and complete: round-tripping through `createGraphEdge` yields a
-* deep-equal edge. Optional fields are only included when present.
-*/
-function toEdgeConfig(edge) {
-	const config = {
-		id: edge.id,
-		sourceId: edge.sourceId,
-		targetId: edge.targetId
-	};
-	if (edge.label != null) config.label = edge.label;
-	if (edge.data != null) config.data = edge.data;
-	if (edge.weight !== void 0) config.weight = edge.weight;
-	if (edge.mode !== void 0) config.mode = edge.mode;
-	if (edge.sourcePort !== void 0) config.sourcePort = edge.sourcePort;
-	if (edge.targetPort !== void 0) config.targetPort = edge.targetPort;
-	if (edge.points !== void 0) config.points = edge.points.map((p) => ({ ...p }));
-	if (edge.routing !== void 0) config.routing = edge.routing;
-	if (edge.x !== void 0) config.x = edge.x;
-	if (edge.y !== void 0) config.y = edge.y;
-	if (edge.width !== void 0) config.width = edge.width;
-	if (edge.height !== void 0) config.height = edge.height;
-	if (edge.color !== void 0) config.color = edge.color;
-	if (edge.style !== void 0) config.style = edge.style;
-	return config;
-}
-const LAYOUT_KEYS$1 = {
-	node: [
-		"x",
-		"y",
-		"width",
-		"height",
-		"style",
-		"color",
-		"shape"
-	],
-	edge: [
-		"x",
-		"y",
-		"width",
-		"height",
-		"points",
-		"routing",
-		"style",
-		"color"
-	]
-};
-new Set(LAYOUT_KEYS$1.node), new Set(LAYOUT_KEYS$1.edge);
-/** Shallow-compare two values, returning true if they differ. */
-function differs(a, b) {
-	if (a === b) return false;
-	if (a == null || b == null) return a !== b;
-	if (typeof a === "object" && typeof b === "object") return JSON.stringify(a) !== JSON.stringify(b);
-	return true;
-}
-const NODE_COMPARE_KEYS = [
-	"parentId",
-	"initialNodeId",
-	"label",
-	"data",
-	"ports",
-	"x",
-	"y",
-	"width",
-	"height",
-	"shape",
-	"color",
-	"style"
-];
-const EDGE_COMPARE_KEYS = [
-	"sourceId",
-	"targetId",
-	"label",
-	"data",
-	"weight",
-	"mode",
-	"sourcePort",
-	"targetPort",
-	"points",
-	"routing",
-	"x",
-	"y",
-	"width",
-	"height",
-	"color",
-	"style"
-];
-/**
-* Compute a structured diff from graph `a` to graph `b` by matching IDs.
-*
-* @example
-* ```ts
-* import { createGraph, getDiff } from '@statelyai/graph';
-*
-* const a = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
-* const b = createGraph({ nodes: [{ id: 'n1', label: 'hello' }, { id: 'n2' }], edges: [] });
-*
-* const diff = getDiff(a, b);
-* // diff.nodes.added → [{ id: 'n2' }]
-* // diff.nodes.updated → [{ id: 'n1', old: { label: '' }, new: { label: 'hello' } }]
-* ```
-*/
-function getDiff(a, b) {
-	const aNodeMap = new Map(a.nodes.map((n) => [n.id, n]));
-	const bNodeMap = new Map(b.nodes.map((n) => [n.id, n]));
-	const aEdgeMap = new Map(a.edges.map((e) => [e.id, e]));
-	const bEdgeMap = new Map(b.edges.map((e) => [e.id, e]));
-	const diff = {
-		nodes: {
-			added: [],
-			removed: [],
-			updated: []
-		},
-		edges: {
-			added: [],
-			removed: [],
-			updated: []
-		}
-	};
-	for (const [id, nodeB] of bNodeMap) {
-		const nodeA = aNodeMap.get(id);
-		if (!nodeA) diff.nodes.added.push(toNodeConfig(nodeB));
-		else {
-			const oldPartial = {};
-			const newPartial = {};
-			for (const key of NODE_COMPARE_KEYS) {
-				const oldValue = nodeA[key] ?? null;
-				const newValue = nodeB[key] ?? null;
-				if (differs(oldValue, newValue)) {
-					oldPartial[key] = oldValue;
-					newPartial[key] = newValue;
-				}
-			}
-			if (Object.keys(oldPartial).length > 0) diff.nodes.updated.push({
-				id,
-				old: oldPartial,
-				new: newPartial
-			});
-		}
-	}
-	for (const [id, nodeA] of aNodeMap) if (!bNodeMap.has(id)) diff.nodes.removed.push(toNodeConfig(nodeA));
-	for (const [id, edgeB] of bEdgeMap) {
-		const edgeA = aEdgeMap.get(id);
-		if (!edgeA) diff.edges.added.push(toEdgeConfig(edgeB));
-		else {
-			const oldPartial = {};
-			const newPartial = {};
-			for (const key of EDGE_COMPARE_KEYS) {
-				const oldValue = edgeA[key] ?? null;
-				const newValue = edgeB[key] ?? null;
-				if (differs(oldValue, newValue)) {
-					oldPartial[key] = oldValue;
-					newPartial[key] = newValue;
-				}
-			}
-			if (Object.keys(oldPartial).length > 0) diff.edges.updated.push({
-				id,
-				old: oldPartial,
-				new: newPartial
-			});
-		}
-	}
-	for (const [id, edgeA] of aEdgeMap) if (!bEdgeMap.has(id)) diff.edges.removed.push(toEdgeConfig(edgeA));
-	return diff;
-}
-/**
-* Check if a diff has zero changes.
-*
-* @example
-* ```ts
-* import { createGraph, getDiff, isEmptyDiff } from '@statelyai/graph';
-*
-* const g = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
-* const diff = getDiff(g, g);
-* isEmptyDiff(diff); // true
-* ```
-*/
-function isEmptyDiff$1(diff) {
-	return diff.nodes.added.length === 0 && diff.nodes.removed.length === 0 && diff.nodes.updated.length === 0 && diff.edges.added.length === 0 && diff.edges.removed.length === 0 && diff.edges.updated.length === 0;
-}
-function summarizeGraphDiff(diff) {
-	return {
-		hasChanges: !isEmptyDiff$1(diff),
-		nodeChanges: diff.nodes.added.length + diff.nodes.removed.length + diff.nodes.updated.length,
-		edgeChanges: diff.edges.added.length + diff.edges.removed.length + diff.edges.updated.length
-	};
-}
-function nodeDepth$1(graph, node) {
-	let depth = 0;
-	let parentId = node.parentId;
-	while (parentId) {
-		depth++;
-		parentId = graph.nodes.find((candidate) => candidate.id === parentId)?.parentId;
-	}
-	return depth;
-}
-function nodeKey(node) {
-	return node.data?.key || node.id;
-}
-function edgeSignature(edge) {
-	return [
-		edge.sourceId,
-		edge.data?.eventType,
-		edge.targetId,
-		edge.data?.guard?.type ?? ""
-	].join("->");
-}
-function getStableNodeId(node, parentStableId, siblingIndex, preferredIds) {
-	const preferredId = preferredIds?.get(node.id);
-	if (preferredId !== void 0) return preferredId;
-	if (node.parentId === null) return "root";
-	const key = nodeKey(node);
-	const suffix = siblingIndex === 0 ? key : `${key}_${siblingIndex + 1}`;
-	return parentStableId ? `${parentStableId}.${suffix}` : suffix;
-}
-function getStableEdgeId(edge, siblingIndex, preferredIds) {
-	const preferredId = preferredIds?.get(edge.id);
-	if (preferredId !== void 0) return preferredId;
-	const suffix = siblingIndex === 0 ? "" : `.${siblingIndex + 1}`;
-	return edgeSignature(edge).concat(suffix);
-}
-function removePresentationFields(entity, kind) {
-	const mutableEntity = entity;
-	for (const key of LAYOUT_KEYS$1[kind]) delete mutableEntity[key];
-	const data = mutableEntity.data;
-	if (data && typeof data === "object" && !Array.isArray(data)) delete data.color;
-}
-/**
-* Rewrites entity ids to structural ("semantic") ids so two graphs that model
-* the same machine compare equal regardless of how their ids were minted.
-*
-* Invariant: node and edge array order is preserved exactly. Callers
-* (`alignCompareIds` in the editor's /v1/diff route) rely on
-* `normalized.nodes[i]` describing `graph.nodes[i]` to translate a semantic id
-* back to the caller's original id. Never sort, filter, or reorder the arrays
-* on the returned graph; sorting for traversal must be done on a copy, as the
-* depth ordering below does.
-*
-* Presentation-only fields defined by `LAYOUT_KEYS`, plus entity data colors,
-* are removed. When preferred ids are supplied, matching raw ids retain the
-* base graph's semantic identity so a stable-id rename is reported as an
-* update.
-*
-* Entity `data` is treated as optional throughout: sparse graphs (a node with
-* `data: {}`, an edge with `data: null`) normalize instead of throwing.
-*/
-function normalizeGraphForSemanticDiff(graph, preferredIds) {
-	const normalized = structuredClone(graph);
-	const nodeIdMap = /* @__PURE__ */ new Map();
-	const siblingKeys = /* @__PURE__ */ new Map();
-	const reservedNodeIds = new Set(preferredIds?.nodes.values());
-	const claimedNodeIds = /* @__PURE__ */ new Set();
-	const nodesByDepth = [...normalized.nodes].sort((a, b) => nodeDepth$1(normalized, a) - nodeDepth$1(normalized, b));
-	for (const node of nodesByDepth) {
-		const parentStableId = node.parentId ? nodeIdMap.get(node.parentId) ?? node.parentId : null;
-		const key = `${parentStableId ?? ""}:${nodeKey(node)}`;
-		const siblingIndex = siblingKeys.get(key) ?? 0;
-		siblingKeys.set(key, siblingIndex + 1);
-		const proposedId = getStableNodeId(node, parentStableId, siblingIndex, preferredIds?.nodes);
-		let stableId = proposedId;
-		let collisionIndex = 2;
-		while (!preferredIds?.nodes.has(node.id) && (reservedNodeIds.has(stableId) || claimedNodeIds.has(stableId))) stableId = `${proposedId}:unmatched:${collisionIndex++}`;
-		claimedNodeIds.add(stableId);
-		nodeIdMap.set(node.id, stableId);
-	}
-	for (const node of normalized.nodes) {
-		removePresentationFields(node, "node");
-		node.id = nodeIdMap.get(node.id) ?? node.id;
-		if (node.parentId) node.parentId = nodeIdMap.get(node.parentId) ?? node.parentId;
-		if (node.initialNodeId) node.initialNodeId = nodeIdMap.get(node.initialNodeId) ?? node.initialNodeId;
-		if (node.data?.initialId) node.data.initialId = nodeIdMap.get(node.data.initialId) ?? node.data.initialId;
-	}
-	const edgeSiblingKeys = /* @__PURE__ */ new Map();
-	const reservedEdgeIds = new Set(preferredIds?.edges.values());
-	const claimedEdgeIds = /* @__PURE__ */ new Set();
-	for (const edge of normalized.edges) {
-		removePresentationFields(edge, "edge");
-		edge.sourceId = nodeIdMap.get(edge.sourceId) ?? edge.sourceId;
-		edge.targetId = nodeIdMap.get(edge.targetId) ?? edge.targetId;
-		const key = edgeSignature(edge);
-		const siblingIndex = edgeSiblingKeys.get(key) ?? 0;
-		edgeSiblingKeys.set(key, siblingIndex + 1);
-		const proposedId = getStableEdgeId(edge, siblingIndex, preferredIds?.edges);
-		let stableId = proposedId;
-		let collisionIndex = 2;
-		while (!preferredIds?.edges.has(edge.id) && (reservedEdgeIds.has(stableId) || claimedEdgeIds.has(stableId))) stableId = `${proposedId}:unmatched:${collisionIndex++}`;
-		claimedEdgeIds.add(stableId);
-		edge.id = stableId;
-	}
-	if (normalized.initialNodeId) normalized.initialNodeId = nodeIdMap.get(normalized.initialNodeId) ?? normalized.initialNodeId;
-	return normalized;
-}
-function diffGraphsSemantically(baseGraph, compareGraph) {
-	const base = normalizeGraphForSemanticDiff(baseGraph);
-	const compareNodeIds = new Set(compareGraph.nodes.map((node) => node.id));
-	const compareEdgeIds = new Set(compareGraph.edges.map((edge) => edge.id));
-	const compare = normalizeGraphForSemanticDiff(compareGraph, {
-		nodes: new Map(baseGraph.nodes.map((node, index) => [node.id, base.nodes[index].id]).filter(([id]) => compareNodeIds.has(id))),
-		edges: new Map(baseGraph.edges.map((edge, index) => [edge.id, base.edges[index].id]).filter(([id]) => compareEdgeIds.has(id)))
-	});
-	const diff = getDiff(base, compare);
-	return {
-		base,
-		compare,
-		diff,
-		summary: summarizeGraphDiff(diff)
+	module.exports.Type = require_type();
+	module.exports.Schema = require_schema();
+	module.exports.FAILSAFE_SCHEMA = require_failsafe();
+	module.exports.JSON_SCHEMA = require_json();
+	module.exports.CORE_SCHEMA = require_core();
+	module.exports.DEFAULT_SCHEMA = require_default();
+	module.exports.load = loader.load;
+	module.exports.loadAll = loader.loadAll;
+	module.exports.dump = dumper.dump;
+	module.exports.YAMLException = require_exception();
+	module.exports.types = {
+		binary: require_binary(),
+		float: require_float(),
+		map: require_map(),
+		null: require_null(),
+		pairs: require_pairs(),
+		set: require_set(),
+		timestamp: require_timestamp(),
+		bool: require_bool(),
+		int: require_int(),
+		merge: require_merge(),
+		omap: require_omap(),
+		seq: require_seq(),
+		str: require_str()
 	};
-}
+	module.exports.safeLoad = renamed("safeLoad", "load");
+	module.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
+	module.exports.safeDump = renamed("safeDump", "dump");
+})))(), 1);
+var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default;
+var index_vite_proxy_tmp_default = import_js_yaml.default;
+
+//#endregion
+//#region ../graph-tools/dist/index.mjs
 /** A patch changes machine semantics rather than presentation metadata. */
 function isStructuralPatch(patch) {
 	if (patch.op === "createImplementation" && !patch.implementation.code) return false;
@@ -10174,7 +10586,7 @@ function graphToXStateTSResult(inputGraph, options = {}) {
 	if (xstateVersion === 6) stripStateSchemas(machineConfig);
 	let machineExpr;
 	if (hasSetup) {
-		const setupObj = buildSetupObject(schemas, impls, {
+		const setupObj = buildSetupObject(graph, schemas, impls, {
 			includeTypeSyntax: supportsTypeSyntax,
 			xstateVersion,
 			xstateV6SchemaFormat
@@ -10974,7 +11386,7 @@ function getActorSourceImports(graph) {
 	}
 	return imports;
 }
-function buildSetupObject(schemas, impls, options) {
+function buildSetupObject(graph, schemas, impls, options) {
 	const setup = {};
 	if (options.xstateVersion === 6) {
 		const schemasBlock = buildV6SchemasBlock(schemas, options);
@@ -10984,7 +11396,10 @@ function buildSetupObject(schemas, impls, options) {
 		if (types) setup.types = types;
 	}
 	if (impls?.actions.length) setup.actions = buildActionsBlock(impls.actions, options);
-	if (impls?.guards.length) setup.guards = buildGuardsBlock(impls.guards, options);
+	if (impls?.guards.length) setup.guards = buildGuardsBlock(impls.guards, {
+		...options,
+		argsTypes: options.xstateVersion === 6 && options.includeTypeSyntax ? new Map(impls.guards.map((guard) => [guard.name, getV6GuardArgsType(graph, guard.name)])) : void 0
+	});
 	if (impls?.actors.length) setup.actors = buildActorsBlock(impls.actors, {
 		...options,
 		xstateVersion: options.xstateVersion
@@ -11085,18 +11500,68 @@ function buildActionsBlock(actions, options) {
 	} else block[implementation.name] = raw(options.xstateVersion === 6 ? `function () {\n  // TODO: implement ${implementation.name}\n}` : `function ({ context, event }) {\n  // TODO: implement ${implementation.name}\n}`);
 	return block;
 }
+/**
+* XState v6 types `setup({ guards })` entries as `(...params: any[]) => boolean`
+* and injects nothing: a named guard receives exactly what its caller passes.
+* Generated transition functions call `guards[name]({ context, event }, params)`
+* (as does `createMachineFromConfig`), so that is the argument type to declare.
+*/
+function getV6GuardArgsType(graph, guardName) {
+	const schemas = graph.data.schemas;
+	const rootContextType = contextSchemaToTSType(schemas?.context);
+	const contexts = graph.edges.filter((edge) => !edge.data.temp && edge.data.guard?.type === guardName).map((edge) => {
+		const types = [];
+		let node = graph.nodes.find((candidate) => candidate.id === edge.sourceId);
+		while (node) {
+			const type = contextSchemaToTSType(node.data.schemas?.context);
+			if (type) types.unshift(type);
+			node = graph.nodes.find((candidate) => candidate.id === node?.parentId);
+		}
+		if (rootContextType) types.unshift(rootContextType);
+		return types.length ? types.join(" & ") : void 0;
+	});
+	const contextType = contexts.some(Boolean) ? [...new Set(contexts.map((type) => type ?? "any"))].join(" | ") : rootContextType;
+	const eventSchemas = {
+		...schemas?.events,
+		...schemas?.internalEvents
+	};
+	const declaredEventType = eventsSchemaToTSType(eventSchemas);
+	if (!contextType && !declaredEventType) return void 0;
+	const eventType = declaredEventType ? `${declaredEventType} | Exclude<import('xstate').ReservedMachineEvent, { type: ${Object.keys(eventSchemas).map((type) => serializeJS(type)).join(" | ")} }>` : "any";
+	return `{ context: ${contextType ?? "any"}; event: ${eventType} }`;
+}
+/**
+* True when an authored guard expression destructures the generated
+* `{ context, event }` argument without annotating it, so contextual typing
+* can supply the types without contradicting an authored signature.
+*/
+function usesGeneratedGuardArgs(code) {
+	const expression = parseSingleExpression(code)?.expression;
+	if (!expression || !ts.isArrowFunction(expression) && !ts.isFunctionExpression(expression)) return false;
+	const [first] = expression.parameters;
+	if (!first || first.type || !ts.isObjectBindingPattern(first.name)) return false;
+	return first.name.elements.every((element) => {
+		const property = element.propertyName ?? element.name;
+		return !element.dotDotDotToken && ts.isIdentifier(property) && (property.text === "context" || property.text === "event");
+	});
+}
 function buildGuardsBlock(guards, options) {
 	const block = {};
-	for (const guard of guards) if (guard.code?.body) {
-		const inlineExpression = getInlineExpression$1(guard.code.body);
-		if (inlineExpression) {
-			block[guard.name] = raw(inlineExpression, guard.code);
-			continue;
-		}
-		const params = hasSchemaProperties(guard.paramsSchema) ? options.includeTypeSyntax ? `, params: ${jsonSchemaToTSType(guard.paramsSchema)}` : ", params" : "";
-		const body = dedent(guard.code.body);
-		block[guard.name] = rawWithSourceSlice(`function ({ context, event }${params ? params : ""}) {\n  `, body, "\n}", guard.code);
-	} else block[guard.name] = raw(`function ({ context, event }) {\n  // TODO: implement ${guard.name}\n  return false;\n}`);
+	for (const guard of guards) {
+		const argsType = options.argsTypes?.get(guard.name);
+		const argsAnnotation = argsType ? `: ${argsType}` : "";
+		const paramsType = hasSchemaProperties(guard.paramsSchema) ? jsonSchemaToTSType(guard.paramsSchema) : void 0;
+		if (guard.code?.body) {
+			const inlineExpression = getInlineExpression$1(guard.code.body);
+			if (inlineExpression) {
+				block[guard.name] = argsType && usesGeneratedGuardArgs(inlineExpression) ? rawWithSourceSlice("(", inlineExpression, `) satisfies (args: ${argsType}, params: ${paramsType ?? "any"}) => boolean`, guard.code) : raw(inlineExpression, guard.code);
+				continue;
+			}
+			const params = paramsType ? options.includeTypeSyntax ? `, params: ${paramsType}` : ", params" : "";
+			const body = dedent(guard.code.body);
+			block[guard.name] = rawWithSourceSlice(`function ({ context, event }${argsAnnotation}${params}) {\n  `, body, "\n}", guard.code);
+		} else block[guard.name] = raw(`function ({ context, event }${argsAnnotation}) {\n  // TODO: implement ${guard.name}\n  return false;\n}`);
+	}
 	return block;
 }
 function buildActorsBlock(actors, options) {
@@ -13344,10 +13809,10 @@ function modify(text, path, value, options) {
 }
 
 //#endregion
-//#region ../editor-sync/dist/adapters-Dt77BFUa.mjs
+//#region ../editor-sync/dist/adapters-9XXzVfbF.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));
+	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
 	const uri = document.uri?.toString() ?? document.fileName;
 	sourceFileUris.set(sourceFile, uri);
 	const bindings = collectBindings(sourceFile, uri, document.fileName, options);
@@ -13359,10 +13824,13 @@ function collectXStateSourceLocations(sourceText, document, options = {}) {
 	const states = [];
 	const statesObjectLocations = [];
 	collectStateLocations(root, [], states, statesObjectLocations, bindings, staticValues, root);
-	const packageProfile = detectXStatePackageProfile(options.resolver?.resolvePackageJson?.({
+	const packageProfile = detectXStatePackageProfile(machineFactoryPackage(sourceFile, {
+		fileName: document.fileName,
+		uri
+	}, options.machineIndex, options.resolver) === "xstate" ? options.resolver?.resolvePackageJson?.({
 		fileName: document.fileName,
 		uri
-	}, "xstate"));
+	}, "xstate") : void 0);
 	const rootProfile = detectXStateSourceProfile(sourceText);
 	const referencedStateSymbols = new Set([...states, ...statesObjectLocations].map((state) => state.symbol).filter((symbol) => typeof symbol === "string"));
 	const resolvedTransitionFunctions = collectResolvedTransitionFunctions(root, bindings);
@@ -13390,6 +13858,104 @@ function collectXStateSourceLocations(sourceText, document, options = {}) {
 		}])
 	};
 }
+/** Only the package providing this machine's factory can establish its version. */
+function machineFactoryPackage(sourceFile, document, machineIndex = 0, resolver) {
+	const modules = /* @__PURE__ */ new Map();
+	const rootModule = {
+		file: sourceFile,
+		document
+	};
+	modules.set(document.uri, rootModule);
+	const visited = /* @__PURE__ */ new Set();
+	function imported(module, specifier, name) {
+		if (!specifier.startsWith(".")) return specifier;
+		const snapshot = resolver?.resolveImport(module.document, specifier);
+		if (!snapshot || !name) return void 0;
+		let target = modules.get(snapshot.uri);
+		if (!target) {
+			target = {
+				file: ts$1.createSourceFile(snapshot.fileName, snapshot.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(snapshot.fileName)),
+				document: snapshot
+			};
+			modules.set(snapshot.uri, target);
+		}
+		return exported(target, name);
+	}
+	function exported(module, name) {
+		const key = `${module.document.uri}\0export\0${name}`;
+		if (visited.has(key)) return void 0;
+		visited.add(key);
+		try {
+			for (const statement of module.file.statements) {
+				if (!ts$1.isExportDeclaration(statement) || !statement.exportClause || !ts$1.isNamedExports(statement.exportClause)) continue;
+				const element = statement.exportClause.elements.find((element) => element.name.text === name);
+				if (!element) continue;
+				const localName = element.propertyName?.text ?? element.name.text;
+				return statement.moduleSpecifier && ts$1.isStringLiteral(statement.moduleSpecifier) ? imported(module, statement.moduleSpecifier.text, localName) : symbol(module, localName);
+			}
+			for (const statement of module.file.statements) if (ts$1.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts$1.SyntaxKind.ExportKeyword)) {
+				if (statement.declarationList.declarations.some((declaration) => ts$1.isIdentifier(declaration.name) && declaration.name.text === name)) return symbol(module, name);
+			}
+			for (const statement of module.file.statements) {
+				if (!ts$1.isExportDeclaration(statement) || statement.exportClause || !statement.moduleSpecifier || !ts$1.isStringLiteral(statement.moduleSpecifier)) continue;
+				const result = imported(module, statement.moduleSpecifier.text, name);
+				if (result) return result;
+			}
+			return;
+		} finally {
+			visited.delete(key);
+		}
+	}
+	function symbol(module, name, member) {
+		const key = `${module.document.uri}\0symbol\0${name}\0${member ?? ""}`;
+		if (visited.has(key)) return void 0;
+		visited.add(key);
+		try {
+			for (const statement of module.file.statements) {
+				if (ts$1.isImportDeclaration(statement) && ts$1.isStringLiteral(statement.moduleSpecifier)) {
+					const bindings = statement.importClause?.namedBindings;
+					if (bindings && ts$1.isNamedImports(bindings)) {
+						const element = bindings.elements.find((element) => element.name.text === name);
+						if (element) return imported(module, statement.moduleSpecifier.text, element.propertyName?.text ?? element.name.text);
+					} else if (bindings && ts$1.isNamespaceImport(bindings) && bindings.name.text === name) return imported(module, statement.moduleSpecifier.text, member);
+				}
+				if (!ts$1.isVariableStatement(statement)) continue;
+				for (const declaration of statement.declarationList.declarations) {
+					if (!declaration.initializer) continue;
+					if (ts$1.isIdentifier(declaration.name) && declaration.name.text === name) return resolve(module, declaration.initializer, member);
+					if (ts$1.isObjectBindingPattern(declaration.name)) {
+						const element = declaration.name.elements.find((element) => !element.dotDotDotToken && ts$1.isIdentifier(element.name) && element.name.text === name);
+						if (element) return resolve(module, declaration.initializer, element.propertyName ? element.propertyName.getText(module.file).replace(/^['"]|['"]$/g, "") : name);
+					}
+				}
+			}
+			return;
+		} finally {
+			visited.delete(key);
+		}
+	}
+	function resolve(module, node, member) {
+		if (ts$1.isIdentifier(node)) return symbol(module, node.text, member);
+		if (ts$1.isCallExpression(node)) {
+			if (ts$1.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length === 1 && ts$1.isStringLiteral(node.arguments[0])) return imported(module, node.arguments[0].text, member);
+			return resolve(module, node.expression);
+		}
+		if (ts$1.isPropertyAccessExpression(node)) return resolve(module, node.expression, node.name.text);
+		if (ts$1.isParenthesizedExpression(node) || ts$1.isAsExpression(node) || ts$1.isSatisfiesExpression(node) || ts$1.isNonNullExpression(node)) return resolve(module, node.expression, member);
+	}
+	let factory;
+	let index = 0;
+	const visit = (node) => {
+		if (factory) return;
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1(node.expression)) {
+			if (index++ === machineIndex) factory = node;
+			return;
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return factory ? resolve(rootModule, factory) : void 0;
+}
 function detectXStatePackageProfile(packageJson) {
 	if (!packageJson) return void 0;
 	let manifest;
@@ -13462,7 +14028,7 @@ function parseRangePart(value) {
 }
 function collectImportedXStateTransitionSources(sourceText, document, options = {}) {
 	if (!options.resolver) return [];
-	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(document.fileName));
+	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
 	const uri = document.uri?.toString() ?? document.fileName;
 	sourceFileUris.set(sourceFile, uri);
 	const bindings = collectBindings(sourceFile, uri, document.fileName, options);
@@ -13553,7 +14119,7 @@ function resolveExportedStaticValue(document, exportName, resolver, visited) {
 	if (visited.has(visitKey)) return null;
 	visited.add(visitKey);
 	try {
-		const sourceFile = ts$1.createSourceFile(document.fileName, document.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(document.fileName));
+		const sourceFile = ts$1.createSourceFile(document.fileName, document.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(document.fileName));
 		sourceFileUris.set(sourceFile, document.uri);
 		const localBindings = collectStaticValueBindings(sourceFile);
 		const localBinding = localBindings.get(exportName);
@@ -13691,7 +14257,7 @@ function addImportedBindings(bindings, sourceFile, uri, fileName, options, cache
 			uri
 		}, statement.moduleSpecifier.text);
 		if (!importedDocument) continue;
-		const importedSourceFile = ts$1.createSourceFile(importedDocument.fileName, importedDocument.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(importedDocument.fileName));
+		const importedSourceFile = ts$1.createSourceFile(importedDocument.fileName, importedDocument.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(importedDocument.fileName));
 		sourceFileUris.set(importedSourceFile, importedDocument.uri);
 		const importedBindings = collectBindings(importedSourceFile, importedDocument.uri, importedDocument.fileName, options, cache);
 		for (const element of namedBindings.elements) {
@@ -13762,7 +14328,7 @@ function findMachineConfigObjectLiteral$1(sourceFile, bindings, machineIndex = 0
 	let currentMachineIndex = 0;
 	const visit = (node) => {
 		if (found) return;
-		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1$1(node.expression)) {
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1(node.expression)) {
 			const isSelectedMachine = currentMachineIndex === machineIndex;
 			currentMachineIndex += 1;
 			if (!isSelectedMachine) return;
@@ -14030,7 +14596,7 @@ function getEnumMemberName(name) {
 	if (ts$1.isIdentifier(name) || ts$1.isStringLiteral(name) || ts$1.isNumericLiteral(name)) return name.text;
 	return null;
 }
-function isCreateMachineExpression$1$1(expression) {
+function isCreateMachineExpression$1(expression) {
 	const isMachineFactoryName = (name) => name === "createMachine" || name === "createMachineFromConfig";
 	return ts$1.isIdentifier(expression) && isMachineFactoryName(expression.text) || ts$1.isPropertyAccessExpression(expression) && isMachineFactoryName(expression.name.text);
 }
@@ -14066,7 +14632,7 @@ function toSourceRange$1(sourceFile, node) {
 		endChar: end.character
 	};
 }
-function getScriptKind$2$1(fileName) {
+function getScriptKind$2(fileName) {
 	if (fileName.endsWith(".tsx")) return ts$1.ScriptKind.TSX;
 	if (fileName.endsWith(".jsx")) return ts$1.ScriptKind.JSX;
 	if (fileName.endsWith(".js")) return ts$1.ScriptKind.JS;
@@ -14121,7 +14687,14 @@ function parseSourceToMachine(text, document, options = {}) {
 	].filter(removeOverlappingRanges).sort(compareSourceRangesDescending));
 	if (sourceLocations.profile === "xstate-v6-alpha" || options.machineIndex !== void 0) {
 		const importedTransitionSources = collectImportedXStateTransitionSources(text, document, options);
-		const parseText = importedTransitionSources.length ? `${hydratedText}\n${importedTransitionSources.join("\n")}` : hydratedText;
+		const transitionDeclarations = ts$1.createSourceFile(document.fileName, importedTransitionSources.join("\n"), ts$1.ScriptTarget.Latest, true, ts$1.ScriptKind.TSX);
+		const transitionSymbols = /* @__PURE__ */ new Set();
+		for (const statement of transitionDeclarations.statements) if (ts$1.isFunctionDeclaration(statement) && statement.name) transitionSymbols.add(statement.name.text);
+		else if (ts$1.isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) if (ts$1.isIdentifier(declaration.name)) transitionSymbols.add(declaration.name.text);
+		}
+		const moduleText = applySourceRangeReplacements(hydratedText, collectHydratedImportReplacements(hydratedText, document, transitionSymbols).sort(compareSourceRangesDescending));
+		const parseText = importedTransitionSources.length ? `${moduleText}\n${importedTransitionSources.join("\n")}` : moduleText;
 		const selectedMachineIndex = options.machineIndex ?? 0;
 		const config = extractXStateMachineConfigEntries(parseText, { profile: sourceLocations.profile }).find((entry) => entry.machineIndex === selectedMachineIndex)?.config;
 		if (!config) throw new Error(`No machine at index ${selectedMachineIndex} was found in ${document.fileName}.`);
@@ -14139,17 +14712,38 @@ function parseSourceToMachine(text, document, options = {}) {
 			setupImplementations[category] = Object.fromEntries(Object.entries(value).map(([name, body]) => [name, typeof body === "string" ? raw(body) : body]));
 			delete machineConfig[category];
 		}
-		if (Object.keys(setupImplementations).length) return `import { setup } from "xstate";
-
-export const machine = setup(${serializeJS(setupImplementations, 0)}).createMachine(${serializeJS(machineConfig, 0)});
-`;
-		return `import { createMachine } from "xstate";
-
-export const machine = createMachine(${serializeJS(machineConfig, 0)});
-`;
+		const factory = Object.keys(setupImplementations).length ? "setup" : "createMachine";
+		return selectMachineInModule(parseText, selectedMachineIndex, factory, factory === "setup" ? `setup(${serializeJS(setupImplementations, 0)}).createMachine(${serializeJS(machineConfig, 0)})` : `createMachine(${serializeJS(machineConfig, 0)})`);
 	}
 	return hydratedText;
 }
+function selectMachineInModule(source, machineIndex, factory, expression) {
+	const file = ts$1.createSourceFile("machine.ts", source, ts$1.ScriptTarget.Latest, true, ts$1.ScriptKind.TSX);
+	const replacements = [];
+	let index = 0;
+	let factoryAlias = "__stately_sync_factory";
+	while (source.includes(factoryAlias)) factoryAlias += "_";
+	const visit = (node) => {
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1(node.expression)) {
+			if (index++ === machineIndex) replacements.push({
+				start: node.getStart(file),
+				end: node.getEnd(),
+				text: `(() => { const ${factory} = ${factoryAlias}; return ${expression}; })()`
+			});
+			else replacements.push({
+				start: node.expression.getStart(file),
+				end: node.expression.getEnd(),
+				text: `(${node.expression.getText(file)})`
+			});
+			return;
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(file);
+	let result = source;
+	for (const replacement of replacements.sort((a, b) => b.start - a.start)) result = result.slice(0, replacement.start) + replacement.text + result.slice(replacement.end);
+	return `import { ${factory} as ${factoryAlias} } from 'xstate';\n${result}`;
+}
 function readHydratedStatesObject(uri, range, states, resolver) {
 	if (!resolver) return null;
 	const document = resolver.read(uri);
@@ -14188,11 +14782,13 @@ function collectHydratedImportReplacements(text, document, hydratedSymbols) {
 		if (!statement.moduleSpecifier.text.startsWith(".")) continue;
 		const namedBindings = statement.importClause?.namedBindings;
 		if (!namedBindings || !ts$1.isNamedImports(namedBindings)) continue;
-		const importedNames = namedBindings.elements.map((element) => element.name.text);
-		if (importedNames.length === 0 || !importedNames.every((name) => hydratedSymbols.has(name))) continue;
+		const remaining = namedBindings.elements.filter((element) => !hydratedSymbols.has(element.name.text));
+		if (remaining.length === namedBindings.elements.length) continue;
+		const clause = statement.importClause;
+		const replacement = remaining.length || clause.name ? ts$1.createPrinter().printNode(ts$1.EmitHint.Unspecified, ts$1.factory.updateImportDeclaration(statement, statement.modifiers, ts$1.factory.updateImportClause(clause, clause.isTypeOnly, clause.name, remaining.length ? ts$1.factory.updateNamedImports(namedBindings, remaining) : void 0), statement.moduleSpecifier, statement.attributes), sourceFile) + "\n" : "";
 		replacements.push({
 			range: toSourceRange(sourceFile, statement, { includeTrailingNewline: true }),
-			newText: ""
+			newText: replacement
 		});
 	}
 	return replacements;
@@ -18434,7 +19030,7 @@ function diagnosticKey$1(diagnostic) {
 }
 
 //#endregion
-//#region ../editor-sync/dist/localBackend-DH1qEsOz.mjs
+//#region ../editor-sync/dist/localBackend-CAt5onqr.mjs
 var LocalEditorSyncBackend = class {
 	constructor(access) {
 		this.access = access;
@@ -18882,7 +19478,7 @@ async function updateMachineDefinition(client, machineId, localGraph) {
 }
 
 //#endregion
-//#region ../editor-sync/dist/presentationMetadata-YX6iRP4T.mjs
+//#region ../editor-sync/dist/presentationMetadata-CIXaHmqN.mjs
 function createStudioPresentationMetadataStore(client, machineId) {
 	const load = async () => {
 		return {
@@ -19248,6 +19844,54 @@ function isPresentationOverlay(value) {
 function clone(value) {
 	return value === void 0 ? value : structuredClone(value);
 }
+/**
+* Apply only what an automatic layout computed to the last persisted graph:
+* the completed layout status of each newly laid-out region and the positions
+* of entities inside those regions. Colors, notes, assets, display choices and
+* manual moves the user has not saved stay as they were persisted.
+*/
+function mergeAutomaticLayout(persisted, laidOut) {
+	if (!isGraph(persisted) || !isGraph(laidOut)) return persisted;
+	const result = clone(persisted);
+	const laidOutNodes = new Map(laidOut.nodes.map((node) => [node.id, node]));
+	const regions = /* @__PURE__ */ new Set();
+	if (laidOut.layout?.status === "complete" && result.layout?.status !== "complete") {
+		regions.add(null);
+		result.layout = {
+			...result.layout,
+			...clone(laidOut.layout)
+		};
+	}
+	for (const node of result.nodes) if (laidOutNodes.get(node.id)?.data?.layout?.status === "complete" && node.data?.layout?.status !== "complete") {
+		regions.add(node.id);
+		node.data = {
+			...node.data,
+			layout: {
+				...node.data?.layout,
+				status: "complete"
+			}
+		};
+	}
+	if (regions.size === 0) return result;
+	const parentOf = new Map(result.nodes.map((node) => [node.id, node.parentId ?? null]));
+	const inRegion = (nodeId) => typeof nodeId === "string" && parentOf.has(nodeId) && regions.has(parentOf.get(nodeId));
+	const copyPosition = (target, source) => {
+		if (!source) return;
+		for (const field of [
+			"position",
+			"x",
+			"y"
+		]) if (source[field] !== void 0) target[field] = clone(source[field]);
+	};
+	for (const node of result.nodes) if (inRegion(node.id)) copyPosition(node, laidOutNodes.get(node.id));
+	const laidOutEdges = new Map(laidOut.edges.map((edge) => [edge.id, edge]));
+	for (const edge of result.edges) if (inRegion(edge.sourceId) || inRegion(edge.targetId)) copyPosition(edge, laidOutEdges.get(edge.id));
+	if (Array.isArray(result.annotations) && Array.isArray(laidOut.annotations)) {
+		const laidOutAnnotations = new Map(laidOut.annotations.map((item) => [item.id, item]));
+		for (const annotation of result.annotations) if (regions.has(annotation.parentId ?? null)) copyPosition(annotation, laidOutAnnotations.get(annotation.id));
+	}
+	return result;
+}
 
 //#endregion
 //#region ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.5.0_zod@4.4.3/node_modules/@asteasolutions/zod-to-openapi/dist/index.cjs
@@ -19681,7 +20325,7 @@ const editorSyncApplyResponseSchema = z$1.object({ replacements: z$1.array(edito
 const editorSyncAccessResponseSchema = z$1.object({ access: editorSyncAccessSchema });
 
 //#endregion
-//#region ../editor-sync/dist/host-BX7mLyHj.mjs
+//#region ../editor-sync/dist/host-DCVLN7MS.mjs
 let diagnosticSequence = 0;
 function presentationsEqual(first, second) {
 	return JSON.stringify(createPresentationSnapshot(first)) === JSON.stringify(createPresentationSnapshot(second));
@@ -19858,6 +20502,7 @@ var EditorHostSession = class {
 				this.currentGraph = message.graph;
 				if (message.source === "external") this.lastPersistedGraph = message.sourceBaselineGraph ?? message.graph;
 				this.currentSourceLocations = mergeSourceLocations(this.currentSourceLocations, message.sourceLocations);
+				if (message.source === "layout") await this.persistAutomaticLayout(message.graph, message.serialized);
 				break;
 			case "@statelyai.save":
 				try {
@@ -20088,6 +20733,27 @@ var EditorHostSession = class {
 			return graph;
 		}
 	}
+	/**
+	* Store automatic layout positions as presentation metadata so the next
+	* session skips automatic layout. Unsaved colors, notes or moves are never
+	* committed this way: such a graph waits for the user's save. Source files are never written, and a graph with unsaved structural edits
+	* waits for the user's save instead.
+	*/
+	async persistAutomaticLayout(graph, serialized) {
+		const persisted = this.lastPersistedGraph;
+		if (!this.options.presentation || this.access?.readOnly || persisted === void 0) return;
+		try {
+			const change = graphChangeToPatchesResult(persisted, graph);
+			if (change.unsupportedChanges.length > 0 || change.patches.some(isStructuralPatch)) return;
+		} catch {
+			return;
+		}
+		if (!presentationsEqual(mergeAutomaticLayout(persisted, graph), graph)) return;
+		try {
+			await this.options.presentation.persist(graph, { serialized: serialized?.digraph !== void 0 ? serialized : await this.getSerializedPayload(serialized) });
+			this.lastPersistedGraph = graph;
+		} catch {}
+	}
 	async persistPresentation(graph, serialized) {
 		if (!this.options.presentation) return;
 		try {
@@ -20648,7 +21314,7 @@ function sourceLocationUris(sourceLocations) {
 
 //#endregion
 //#region src/version.ts
-const CLI_VERSION = "0.12.8";
+const CLI_VERSION = "0.14.0";
 
 //#endregion
 //#region src/cliHost.ts
@@ -21100,7 +21766,7 @@ async function openSourceDocument(fileName) {
 	};
 }
 function collectRelativeImportSpecifiers(text, fileName) {
-	const sourceFile = ts$1.createSourceFile(fileName, text, ts$1.ScriptTarget.Latest, true, getScriptKind$2(fileName));
+	const sourceFile = ts$1.createSourceFile(fileName, text, ts$1.ScriptTarget.Latest, true, getScriptKind$1(fileName));
 	const specifiers = [];
 	for (const statement of sourceFile.statements) {
 		const moduleSpecifier = ts$1.isImportDeclaration(statement) || ts$1.isExportDeclaration(statement) ? statement.moduleSpecifier : void 0;
@@ -21127,7 +21793,7 @@ function resolveRelativeImportCandidates(fromFileName, specifier) {
 		...importExtensions.map((extension) => path$1.join(basePath, `index${extension}`))
 	];
 }
-function getScriptKind$2(fileName) {
+function getScriptKind$1(fileName) {
 	if (fileName.endsWith(".tsx")) return ts$1.ScriptKind.TSX;
 	if (fileName.endsWith(".jsx")) return ts$1.ScriptKind.JSX;
 	if (/\.(?:c|m)?js$/.test(fileName)) return ts$1.ScriptKind.JS;
@@ -21650,106 +22316,7 @@ function describeCredentialBackend(backend, location) {
 }
 
 //#endregion
-//#region ../editor-sync/dist/statelyPragma-D46lczJR.mjs
-function findStatelyPragmaAttachments(sourceText, fileName = "machine.ts") {
-	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind$1(fileName));
-	const attachments = [];
-	const visit = (node) => {
-		if (ts.isCallExpression(node) && isCreateMachineExpression$1(node.expression)) {
-			const attachNode = findAttachNode(node);
-			if (attachNode) attachments.push({
-				machineStart: getMachineExpressionStart(node.expression, sourceFile),
-				attachStart: attachNode.getStart(sourceFile),
-				pragma: findAttachedStatelyPragma(sourceText, attachNode)
-			});
-		}
-		ts.forEachChild(node, visit);
-	};
-	visit(sourceFile);
-	return attachments;
-}
-function getStatelyPragma(sourceText, fileName = "machine.ts", machineIndex = 0) {
-	return findStatelyPragmaAttachments(sourceText, fileName)[machineIndex]?.pragma;
-}
-function upsertStatelyPragma(sourceText, id, options = {}) {
-	const attachment = findStatelyPragmaAttachments(sourceText, options.fileName ?? "machine.ts")[options.machineIndex ?? 0];
-	if (!attachment) return sourceText;
-	const lineEnding = options.lineEnding ?? detectLineEnding(sourceText);
-	const canonicalComment = `// @statelyai id=${id}`;
-	if (attachment.pragma) return sourceText.slice(0, attachment.pragma.start) + canonicalComment + sourceText.slice(attachment.pragma.end);
-	const insertText = `${getIndentationAtOffset(sourceText, attachment.attachStart)}${canonicalComment}${lineEnding}`;
-	return sourceText.slice(0, attachment.attachStart) + insertText + sourceText.slice(attachment.attachStart);
-}
-function findAttachedStatelyPragma(sourceText, node) {
-	const comments = ts.getLeadingCommentRanges(sourceText, node.getFullStart()) ?? [];
-	for (let index = comments.length - 1; index >= 0; index -= 1) {
-		const comment = comments[index];
-		const parsed = parseStatelyPragma(sourceText, comment.pos, comment.end);
-		if (parsed) return parsed;
-	}
-}
-function parseStatelyPragma(sourceText, start, end) {
-	const match = normalizeCommentContent(sourceText.slice(start, end)).match(/^@statelyai(?:\s+(.*))?$/s);
-	if (!match) return;
-	const fields = parseFields(match[1] ?? "");
-	return {
-		tag: "@statelyai",
-		id: fields.id,
-		fields,
-		start,
-		end
-	};
-}
-function normalizeCommentContent(rawComment) {
-	if (rawComment.startsWith("//")) return rawComment.slice(2).trim();
-	if (rawComment.startsWith("/*")) return rawComment.slice(2, rawComment.endsWith("*/") ? -2 : void 0).split(/\r?\n/).map((line) => line.replace(/^\s*\*\s?/, "")).join(" ").trim();
-	return rawComment.trim();
-}
-function parseFields(input) {
-	const fields = {};
-	for (const token of input.split(/\s+/)) {
-		if (!token) continue;
-		const equalsIndex = token.indexOf("=");
-		if (equalsIndex <= 0) continue;
-		const key = token.slice(0, equalsIndex);
-		const value = token.slice(equalsIndex + 1);
-		if (!key || !value) continue;
-		fields[key] = value;
-	}
-	return fields;
-}
-function findAttachNode(node) {
-	let current = node;
-	while (current?.parent) {
-		if (ts.isVariableStatement(current.parent) || ts.isExpressionStatement(current.parent) || ts.isExportAssignment(current.parent)) return current.parent;
-		current = current.parent;
-	}
-	return current;
-}
-function isCreateMachineExpression$1(expression) {
-	const isMachineFactoryName = (name) => name === "createMachine" || name === "createMachineFromConfig";
-	return ts.isIdentifier(expression) && isMachineFactoryName(expression.text) || ts.isPropertyAccessExpression(expression) && isMachineFactoryName(expression.name.text);
-}
-function getMachineExpressionStart(expression, sourceFile) {
-	if (ts.isPropertyAccessExpression(expression)) return expression.name.getStart(sourceFile);
-	return expression.getStart(sourceFile);
-}
-function getIndentationAtOffset(sourceText, offset) {
-	const lineStart = sourceText.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
-	return sourceText.slice(lineStart, offset).match(/^[ \t]*/)?.[0] ?? "";
-}
-function detectLineEnding(sourceText) {
-	return sourceText.includes("\r\n") ? "\r\n" : "\n";
-}
-function getScriptKind$1(fileName) {
-	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
-	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
-	if (fileName.endsWith(".js")) return ts.ScriptKind.JS;
-	return ts.ScriptKind.TS;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/@statelyai+graph@2.1.0_@statelyai+layout@0.4.2_cytoscape@3.34.0_d3-force@3.0.0_d3-hiera_48d6687797f6ba8a844c48e50eec3ae1/node_modules/@statelyai/graph/dist/index.mjs
+//#region ../../node_modules/.pnpm/@statelyai+graph@2.1.0_@statelyai+layout@0.4.3_cytoscape@3.34.0_d3-force@3.0.0_d3-hiera_2afdfa88fae2fa10712f99651d0f58d6/node_modules/@statelyai/graph/dist/index.mjs
 const LAYOUT_KEYS = {
 	node: [
 		"x",
@@ -22200,7 +22767,7 @@ function fromXStateConfig(config) {
 	};
 }
 async function pushLocalMachineLinks(options) {
-	const client = options.client ?? createStatelyClient({
+	const client = options.client ?? createStatelyClient$1({
 		apiKey: options.apiKey,
 		baseUrl: options.baseUrl,
 		fetch: options.fetch
@@ -22297,7 +22864,7 @@ async function resolveLocalFile(locator, options, machineIndex = 0) {
 		let config = localExtraction.machines[0]?.config;
 		const extractionIssue = localExtraction.error;
 		if (!config) {
-			const extracted = await (options.client ?? createStatelyClient({
+			const extracted = await (options.client ?? createStatelyClient$1({
 				apiKey: options.apiKey,
 				baseUrl: options.baseUrl,
 				fetch: options.fetch
@@ -22369,7 +22936,7 @@ function inferXStateTargetLanguage(targetPath) {
 	return /\.(?:c|m)?jsx?$/i.test(targetPath) ? "javascript" : "typescript";
 }
 async function resolveRemoteMachine(machineId, baseUrl, kind, locator, options) {
-	const digraph = (await (options.client ?? createStatelyClient({
+	const digraph = (await (options.client ?? createStatelyClient$1({
 		apiKey: options.apiKey,
 		baseUrl,
 		fetch: options.fetch
@@ -23141,7 +23708,7 @@ async function initProject(options) {
 			reusedExistingConfig: true
 		};
 		if (existingConfig.config.projectId) {
-			const client = options.client ?? createStatelyClient$1({
+			const client = options.client ?? createStatelyClient({
 				apiKey: options.apiKey,
 				baseUrl: apiBaseUrl
 			});
@@ -23162,7 +23729,7 @@ async function initProject(options) {
 			reusedExistingConfig: false
 		};
 	}
-	const client = options.client ?? createStatelyClient$1({
+	const client = options.client ?? createStatelyClient({
 		apiKey: options.apiKey,
 		baseUrl: apiBaseUrl
 	});
@@ -23288,9 +23855,9 @@ async function resolveConfiguredProject(options) {
 		configPath: options.configPath,
 		rewriteIfNeeded: options.rewriteIfNeeded ?? true
 	});
-	if (!config.projectId) throw new Error("This is a local-only project. Run `statelyai init` to connect it to Stately Studio.");
+	if (!config.projectId) throw new Error("This is a local-only project. Run `statelyai link` to connect it to Stately Studio.");
 	return {
-		client: options.client ?? createStatelyClient$1({
+		client: options.client ?? createStatelyClient({
 			apiKey: options.apiKey,
 			baseUrl: resolveApiBaseUrl(options.baseUrl ?? config.studioUrl)
 		}),
@@ -23397,7 +23964,7 @@ async function resolveProjectStatus(options = {}) {
 		};
 	}
 	const apiKey = options.apiKey ?? (options.client ? void 0 : (await resolveApiKey()).apiKey);
-	const client = options.client ?? createStatelyClient$1({
+	const client = options.client ?? createStatelyClient({
 		apiKey,
 		baseUrl: resolveApiBaseUrl(studioUrl)
 	});
@@ -23911,6 +24478,93 @@ async function discoverMachinesInFile(filePath) {
 		relativePath: path.basename(filePath)
 	}];
 }
+var LinkCommand = class LinkCommand extends Command {
+	static summary = "Connect a workspace or source machine to Stately Studio without syncing definitions.";
+	static args = { file: Args.string({ description: "Source file to associate with --machine" }) };
+	static flags = {
+		help: Flags.help({ char: "h" }),
+		project: Flags.string({
+			description: "Existing Studio project ID or URL",
+			exclusive: ["create"]
+		}),
+		create: Flags.boolean({
+			description: "Create a new Studio project",
+			default: false
+		}),
+		name: Flags.string({
+			description: "Name for --create",
+			dependsOn: ["create"]
+		}),
+		visibility: Flags.string({
+			description: "Visibility for --create",
+			options: [
+				"Private",
+				"Public",
+				"Unlisted"
+			]
+		}),
+		machine: Flags.string({ description: "Existing remote machine ID or URL; requires a source file" }),
+		"machine-index": Flags.integer({
+			description: "Zero-based machine index in a multi-machine source file",
+			min: 0
+		}),
+		"base-url": Flags.string({ description: "Studio deployment origin" }),
+		config: Flags.string({ description: "Path to statelyai.json" }),
+		force: Flags.boolean({
+			description: "Replace an existing project or machine association",
+			default: false
+		})
+	};
+	async run() {
+		const { args, flags } = await this.parse(LinkCommand);
+		let projectId = flags.project;
+		let create = flags.create;
+		const credential = await resolveApiKey();
+		const config = await readStatelyProjectConfig({ configPath: flags.config }).catch((error) => {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		});
+		const baseUrl = flags["base-url"] ?? config?.config.studioUrl ?? getResolvedStudioUrl();
+		if (!projectId && !create && !config?.config.projectId && process.stdin.isTTY && process.stdout.isTTY) {
+			const projects = await createStatelyClient({
+				apiKey: credential.apiKey,
+				baseUrl: resolveApiBaseUrl(baseUrl)
+			}).projects.list();
+			projects.forEach((project, index) => this.log(`${index + 1}. ${project.name} (${project.projectId})`));
+			this.log("0. Create a new Studio project");
+			const rl = createInterface({
+				input: process.stdin,
+				output: process.stdout
+			});
+			try {
+				const answer = (await rl.question("Choose a project number: ")).trim();
+				if (!/^\d+$/.test(answer)) this.error("Choose a project number, or pass --project <id> or --create.");
+				const choice = Number(answer);
+				if (choice === 0) create = true;
+				else if (projects[choice - 1]) projectId = projects[choice - 1].projectId;
+				else this.error("No project at that number.");
+			} finally {
+				rl.close();
+			}
+		}
+		const result = await linkProject({
+			projectId,
+			create,
+			apiKey: credential.apiKey,
+			baseUrl,
+			configPath: flags.config,
+			name: flags.name,
+			visibility: flags.visibility,
+			force: flags.force,
+			file: args.file,
+			machineId: flags.machine,
+			machineIndex: flags["machine-index"]
+		});
+		this.log(`Connected to Studio project ${result.project.name} (${result.project.projectId}).`);
+		if (result.machineId) this.log(`Associated ${args.file} with machine ${result.machineId}.`);
+		this.log("No machine definitions uploaded or downloaded. Use push or pull to sync.");
+	}
+};
 var InitCommand = class InitCommand extends Command {
 	static enableJsonFlag = false;
 	static summary = "Create a local or Studio-connected statelyai.json.";
@@ -23961,6 +24615,7 @@ var InitCommand = class InitCommand extends Command {
 			if (resolvedApiKey.source === "missing" && error instanceof StudioApiError && (error.status === 401 || error.status === 403)) this.error("Not logged in. Run `npx statelyai login` and retry. To initialize without an account, run `npx statelyai init --local` (add `--force` to replace an existing config).");
 			throw error;
 		}
+		this.log("For separate local setup and Studio linking, use `statelyai init --local --scan`, then `statelyai link`.");
 		const initMessage = result.project ? (() => {
 			const projectEditorUrl = buildProjectEditorUrl(result.config.studioUrl, result.project.projectId);
 			return result.reusedExistingConfig ? `Using existing statelyai.json at ${result.configPath} for project ${result.project.projectId}.\nEditor: ${projectEditorUrl}` : `Initialized project ${result.project.projectId} and wrote ${result.configPath}.\nEditor: ${projectEditorUrl}`;
@@ -24128,9 +24783,13 @@ const COMMANDS = {
 	scan: ScanCommand,
 	status: StatusCommand,
 	init: InitCommand,
+	link: LinkCommand,
 	login: LoginCommand,
 	logout: LogoutCommand,
-	whoami: WhoamiCommand
+	whoami: WhoamiCommand,
+	changes: ChangesCommand,
+	brief: BriefCommand,
+	pending: PendingCommand
 };
 async function run$1(argv = process.argv.slice(2), entryUrl = import.meta.url) {
 	const normalizedArgv = argv.length === 1 && argv[0] === "-h" ? ["--help"] : argv;
@@ -24154,4 +24813,4 @@ function isDirectExecution() {
 if (isDirectExecution()) run$1();
 
 //#endregion
-export { run$1 as C, verifyProject as D, resolveVerificationRequest as E, formatVerificationJUnit as O, resolveProjectStatus as S, scanProjectSources as T, isFileGitDirty as _, discoverMachinesInSource as a, resolveCredentialStatus as b, formatDiscoveredMachines as c, formatProjectStatus as d, formatStoredCredentialSource as f, initProject as g, inferInitProjectName as h, discoverLinkedPullTargets as i, createStatelyProjectConfig as k, formatMissingNewMachineDirMessage as l, getEnvCredential as m, buildOAuthLoginStart as n, discoverOAuthLogin as o, getEnvApiKey as p, classifyPushCandidates as r, discoverRemoteProjectMachineTargets as s, COMMANDS as t, formatPlanSummary as u, resolveApiKey as v, scanProjectMachines as w, resolveOpenRootDir as x, resolveConfiguredPullTargets as y };
+export { formatVerificationJUnit as A, run$1 as C, resourceId as D, linkProject as E, readGraphFile as F, verifyReport as I, briefReport as M, changesReport as N, resolveVerificationRequest as O, pendingReport as P, resolveProjectStatus as S, scanProjectSources as T, isFileGitDirty as _, discoverMachinesInSource as a, resolveCredentialStatus as b, formatDiscoveredMachines as c, formatProjectStatus as d, formatStoredCredentialSource as f, initProject as g, inferInitProjectName as h, discoverLinkedPullTargets as i, createStatelyProjectConfig as j, verifyProject as k, formatMissingNewMachineDirMessage as l, getEnvCredential as m, buildOAuthLoginStart as n, discoverOAuthLogin as o, getEnvApiKey as p, classifyPushCandidates as r, discoverRemoteProjectMachineTargets as s, COMMANDS as t, formatPlanSummary as u, resolveApiKey as v, scanProjectMachines as w, resolveOpenRootDir as x, resolveConfiguredPullTargets as y };