@statelyai/sdk 0.7.1 → 0.9.0

package/dist/cli.mjs

@@ -1,1760 +0,0 @@
-#!/usr/bin/env node
-import { createStatelyClient } from "./studio.mjs";
-import { u as getStatelyPragma } from "./graphToXStateTS-Gzh0ZqbN.mjs";
-import { n as pullSync, r as pushLocalMachineLinks, t as planSync } from "./sync-DLkTmSyA.mjs";
-import fs from "node:fs/promises";
-import * as path$1 from "node:path";
-import path from "node:path";
-import { execFile, execFileSync, spawn } from "node:child_process";
-import { promisify } from "node:util";
-import fs$1, { promises, watch } from "node:fs";
-import { createInterface } from "node:readline/promises";
-import { Writable } from "node:stream";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { Args, Command, Flags, flush, handle, run as run$1 } from "@oclif/core";
-import * as crypto from "node:crypto";
-import * as http from "node:http";
-import * as https from "node:https";
-import os from "node:os";
-
-//#region src/cliHost.ts
-const DEFAULT_SYNC_MAX_FILES = 150;
-const DEFAULT_SYNC_MAX_BYTES = 2e6;
-const supportedDocumentPattern = /\.(?:c|m)?(?:jsx?|tsx?)$|\.jsonc?$|\.ya?ml$|\.mmd$|\.mermaid$/i;
-var WebSocketClient = class {
-	buffer = Buffer.alloc(0);
-	listeners = /* @__PURE__ */ new Set();
-	constructor(socket) {
-		this.socket = socket;
-		socket.on("data", (chunk) => {
-			const nextChunk = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-			this.buffer = Buffer.concat([this.buffer, nextChunk]);
-			this.readFrames();
-		});
-	}
-	onMessage(listener) {
-		this.listeners.add(listener);
-	}
-	send(message) {
-		this.socket.write(encodeWebSocketFrame(JSON.stringify(message)));
-	}
-	close() {
-		this.socket.end();
-	}
-	readFrames() {
-		while (this.buffer.length >= 2) {
-			const first = this.buffer[0];
-			const second = this.buffer[1];
-			const opcode = first & 15;
-			const masked = (second & 128) !== 0;
-			let length = second & 127;
-			let offset = 2;
-			if (length === 126) {
-				if (this.buffer.length < offset + 2) return;
-				length = this.buffer.readUInt16BE(offset);
-				offset += 2;
-			} else if (length === 127) {
-				if (this.buffer.length < offset + 8) return;
-				const bigLength = this.buffer.readBigUInt64BE(offset);
-				if (bigLength > BigInt(Number.MAX_SAFE_INTEGER)) {
-					this.socket.destroy(/* @__PURE__ */ new Error("WebSocket frame is too large."));
-					return;
-				}
-				length = Number(bigLength);
-				offset += 8;
-			}
-			const maskLength = masked ? 4 : 0;
-			if (this.buffer.length < offset + maskLength + length) return;
-			const mask = masked ? this.buffer.subarray(offset, offset + 4) : void 0;
-			offset += maskLength;
-			const payload = Buffer.from(this.buffer.subarray(offset, offset + length));
-			this.buffer = this.buffer.subarray(offset + length);
-			if (mask) for (let index = 0; index < payload.length; index++) payload[index] = payload[index] ^ mask[index % 4];
-			if (opcode === 8) {
-				this.close();
-				return;
-			}
-			if (opcode === 9) {
-				this.socket.write(encodeWebSocketFrame(payload, 10));
-				continue;
-			}
-			if (opcode !== 1) continue;
-			const message = JSON.parse(payload.toString("utf8"));
-			for (const listener of this.listeners) listener(message);
-		}
-	}
-};
-var RemoteEditorSession = class {
-	currentGraph;
-	lastPersistedGraph;
-	currentSourceLocations;
-	currentFormat;
-	ready = false;
-	pendingMessages = [];
-	pendingRetrievals = /* @__PURE__ */ new Map();
-	retrieveRequestCount = 0;
-	watchedSourceUris = /* @__PURE__ */ new Set();
-	selfEditCount = 0;
-	watcher;
-	constructor(options, sendMessage) {
-		this.options = options;
-		this.sendMessage = sendMessage;
-		this.watcher = watchWorkspace(this.options.rootDir, (uri) => {
-			this.handleSavedDocument(uri);
-		});
-	}
-	dispose() {
-		for (const pending of this.pendingRetrievals.values()) pending.reject(/* @__PURE__ */ new Error("Editor session disposed before export completed."));
-		this.pendingRetrievals.clear();
-		this.watcher?.dispose();
-	}
-	async receiveMessage(msg) {
-		this.log("recv", msg.type, msg);
-		switch (msg.type) {
-			case "@statelyai.ready":
-				await this.initializeEditor();
-				break;
-			case "@statelyai.loaded":
-				this.currentGraph = msg.graph;
-				this.lastPersistedGraph = msg.graph;
-				this.currentSourceLocations = msg.sourceLocations ?? this.currentSourceLocations;
-				this.updateSourceLocations(this.currentSourceLocations);
-				break;
-			case "@statelyai.change":
-				this.currentGraph = msg.graph;
-				this.currentSourceLocations = msg.sourceLocations ?? this.currentSourceLocations;
-				this.updateSourceLocations(this.currentSourceLocations);
-				break;
-			case "@statelyai.save":
-				await this.saveFromEditor(msg);
-				break;
-			case "@statelyai.retrieved":
-				this.resolveRetrievedSource(msg);
-				break;
-			case "@statelyai.clipboardRead":
-				this.postMessage({
-					type: "@statelyai.clipboardReadResponse",
-					requestId: msg.requestId,
-					text: ""
-				});
-				break;
-			case "@statelyai.error":
-				this.handleErrorMessage(msg);
-				break;
-		}
-	}
-	async initializeEditor() {
-		this.ready = true;
-		try {
-			const update = await this.parseRootDocument();
-			this.currentFormat = update.format;
-			this.currentSourceLocations = update.sourceLocations;
-			this.updateSourceLocations(update.sourceLocations);
-			this.postMessage({
-				type: "@statelyai.init",
-				machine: update.machine,
-				format: update.format,
-				sourceLocations: update.sourceLocations,
-				mode: "editing",
-				theme: "light",
-				unsavedIndicator: { enabled: true },
-				leftPanels: [],
-				rightPanels: [],
-				activePanels: []
-			});
-		} catch (error) {
-			this.showError(formatError(error, "Failed to initialize the visual editor."));
-			return;
-		}
-		for (const pending of this.pendingMessages) this.sendMessage(pending);
-		this.pendingMessages = [];
-	}
-	async handleSavedDocument(uri) {
-		if (uri !== this.options.rootUri && !this.watchedSourceUris.has(uri)) return;
-		if (this.selfEditCount > 0) return;
-		try {
-			const update = await this.parseRootDocument();
-			this.currentFormat = update.format;
-			this.currentSourceLocations = update.sourceLocations;
-			this.updateSourceLocations(update.sourceLocations);
-			this.postMessage({
-				type: "@statelyai.update",
-				machine: update.machine,
-				format: update.format,
-				sourceLocations: update.sourceLocations
-			});
-		} catch (error) {
-			this.showError(formatError(error, "Failed to read the saved document."));
-		}
-	}
-	async saveFromEditor(msg) {
-		const validationErrors = getValidationErrors(msg.validations);
-		if (validationErrors.length > 0) {
-			const message = formatValidationErrorMessage(validationErrors);
-			this.postMessage({
-				type: "@statelyai.toast",
-				message,
-				toastType: "error"
-			});
-			this.showError(message);
-			return;
-		}
-		this.currentSourceLocations = msg.sourceLocations ?? this.currentSourceLocations;
-		this.updateSourceLocations(this.currentSourceLocations);
-		try {
-			const serialized = await this.getSerializedPayloadForCurrentFormat();
-			const documents = await collectSourceDocuments({
-				rootFileName: this.options.fileName,
-				rootDir: this.options.rootDir,
-				extraUris: sourceLocationUris(this.currentSourceLocations)
-			});
-			const response = await this.postSync("/api/editor-sync/apply", {
-				rootUri: this.options.rootUri,
-				rootFileName: this.options.fileName,
-				rootDir: this.options.rootDir,
-				documents,
-				machineConfig: msg.machineConfig,
-				patches: msg.patches,
-				prevGraph: this.lastPersistedGraph ?? this.currentGraph,
-				nextGraph: msg.graph,
-				sourceLocations: this.currentSourceLocations,
-				serialized
-			});
-			if (response.replacements.length === 0) {
-				const message = "Unable to apply Viz changes to the source file automatically.";
-				this.postMessage({
-					type: "@statelyai.toast",
-					message,
-					toastType: "error"
-				});
-				this.showError(message);
-				return;
-			}
-			await this.runWithSelfEdit(async () => {
-				await applyFileReplacements(response.replacements, this.options.rootUri);
-			});
-			this.currentGraph = msg.graph;
-			this.lastPersistedGraph = msg.graph;
-		} catch (error) {
-			const message = formatError(error, "Failed to apply Viz changes.");
-			this.postMessage({
-				type: "@statelyai.toast",
-				message,
-				toastType: "error"
-			});
-			this.showError(message);
-		}
-	}
-	async parseRootDocument() {
-		const documents = await collectSourceDocuments({
-			rootFileName: this.options.fileName,
-			rootDir: this.options.rootDir,
-			extraUris: sourceLocationUris(this.currentSourceLocations)
-		});
-		return this.postSync("/api/editor-sync/parse", {
-			rootUri: this.options.rootUri,
-			rootFileName: this.options.fileName,
-			rootDir: this.options.rootDir,
-			documents
-		});
-	}
-	async postSync(pathname, body) {
-		const url = new URL(pathname, normalizedBaseUrl(this.options.editorUrl));
-		const headers = { "Content-Type": "application/json" };
-		if (this.options.apiKey) headers.Authorization = `Bearer ${this.options.apiKey}`;
-		const response = await fetchEditorHost(url, {
-			method: "POST",
-			headers,
-			body: JSON.stringify(body)
-		});
-		const data = await response.json().catch(() => null);
-		if (!response.ok) {
-			const message = data && typeof data === "object" && "error" in data && typeof data.error === "string" ? data.error : `HTTP ${response.status}`;
-			throw new Error(message);
-		}
-		return data;
-	}
-	async getSerializedPayloadForCurrentFormat() {
-		const format = this.currentFormat;
-		if (!format || format === "xstate") return;
-		try {
-			const serialized = await this.requestSerialized(format);
-			return { [format]: serialized };
-		} catch {
-			return;
-		}
-	}
-	requestSerialized(format) {
-		const requestId = `retrieve-${++this.retrieveRequestCount}`;
-		return new Promise((resolve, reject) => {
-			this.pendingRetrievals.set(requestId, {
-				resolve,
-				reject
-			});
-			this.postMessage({
-				type: "@statelyai.retrieve",
-				requestId,
-				format
-			});
-		});
-	}
-	resolveRetrievedSource(msg) {
-		const pending = this.pendingRetrievals.get(msg.requestId);
-		if (!pending) return;
-		this.pendingRetrievals.delete(msg.requestId);
-		const serialized = typeof msg.data === "string" ? msg.data : JSON.stringify(msg.data, null, 2);
-		pending.resolve(serialized);
-	}
-	handleErrorMessage(msg) {
-		if (msg.requestId) {
-			const pending = this.pendingRetrievals.get(msg.requestId);
-			if (pending) {
-				this.pendingRetrievals.delete(msg.requestId);
-				pending.reject(new Error(msg.message));
-				return;
-			}
-		}
-		this.showError(msg.message);
-	}
-	updateSourceLocations(sourceLocations) {
-		this.watchedSourceUris.clear();
-		for (const location of sourceLocations?.states ?? []) if (location.uri !== this.options.rootUri) this.watchedSourceUris.add(location.uri);
-	}
-	async runWithSelfEdit(operation) {
-		this.selfEditCount++;
-		try {
-			return await operation();
-		} finally {
-			this.selfEditCount--;
-		}
-	}
-	postMessage(msg) {
-		this.log("send", msg.type, msg);
-		if (!this.ready) {
-			this.pendingMessages.push(msg);
-			return;
-		}
-		this.sendMessage(msg);
-	}
-	showError(message) {
-		console.error(`Stately Editor: ${message}`);
-	}
-	log(direction, type, payload) {
-		if (this.options.debug) console.error(`[${direction}] ${type}`, payload ?? "");
-	}
-};
-async function openEditor(options) {
-	const fileName = path$1.resolve(options.fileName);
-	await fs.access(fileName);
-	await assertEditorHostAvailable(options.editorUrl);
-	const rootUri = fileNameToUri(fileName);
-	const rootDir = path$1.dirname(fileName);
-	let activeClient;
-	let session;
-	const server = http.createServer((request, response) => {
-		if (new URL(request.url ?? "/", `http://${request.headers.host}`).pathname !== "/") {
-			response.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
-			response.end("Not found");
-			return;
-		}
-		response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-		response.end(getCliWebviewContent({
-			editorUrl: options.editorUrl,
-			apiKey: options.apiKey
-		}));
-	});
-	server.on("upgrade", (request, socket) => {
-		if (request.url !== "/ws") {
-			socket.end("HTTP/1.1 404 Not Found\r\n\r\n");
-			return;
-		}
-		const key = request.headers["sec-websocket-key"];
-		if (typeof key !== "string") {
-			socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
-			return;
-		}
-		const accept = crypto.createHash("sha1").update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64");
-		socket.write([
-			"HTTP/1.1 101 Switching Protocols",
-			"Upgrade: websocket",
-			"Connection: Upgrade",
-			`Sec-WebSocket-Accept: ${accept}`,
-			"\r\n"
-		].join("\r\n"));
-		activeClient?.close();
-		session?.dispose();
-		activeClient = new WebSocketClient(socket);
-		session = new RemoteEditorSession({
-			...options,
-			fileName,
-			rootUri,
-			rootDir
-		}, (message) => activeClient?.send(message));
-		activeClient.onMessage((message) => {
-			session?.receiveMessage(message);
-		});
-	});
-	await listen(server, options.port, options.host);
-	const address = server.address();
-	const port = typeof address === "object" && address ? address.port : options.port;
-	const editorPageUrl = `http://${options.host}:${port}`;
-	console.log(`Stately visual editor: ${editorPageUrl}`);
-	console.log(`Editing ${fileName}`);
-	if (options.shouldOpen) openBrowser(editorPageUrl);
-	const shutdown = () => {
-		session?.dispose();
-		activeClient?.close();
-		server.close();
-	};
-	process.once("SIGINT", () => {
-		shutdown();
-		process.exit(0);
-	});
-	process.once("SIGTERM", () => {
-		shutdown();
-		process.exit(0);
-	});
-}
-async function collectSourceDocuments(options) {
-	const files = new Set([options.rootFileName]);
-	const maxFiles = Number.parseInt(process.env.STATELY_SYNC_MAX_FILES ?? "", 10) || DEFAULT_SYNC_MAX_FILES;
-	const maxBytes = Number.parseInt(process.env.STATELY_SYNC_MAX_BYTES ?? "", 10) || DEFAULT_SYNC_MAX_BYTES;
-	for (const uri of options.extraUris ?? []) files.add(sourceUriToFileName(uri));
-	await collectDirectoryFiles(options.rootDir, files, maxFiles);
-	const documents = [];
-	let totalBytes = 0;
-	for (const fileName of files) {
-		if (!isSupportedDocument(fileName)) continue;
-		const text = await fs.readFile(fileName, "utf8").catch(() => null);
-		if (text === null) continue;
-		totalBytes += Buffer.byteLength(text);
-		if (totalBytes > maxBytes) throw new Error(`Source payload exceeds ${maxBytes} bytes.`);
-		documents.push({
-			uri: fileNameToUri(fileName),
-			fileName,
-			text
-		});
-	}
-	return documents;
-}
-async function collectDirectoryFiles(rootDir, files, maxFiles) {
-	const queue = [rootDir];
-	while (queue.length > 0 && files.size < maxFiles) {
-		const dir = queue.shift();
-		const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-		for (const entry of entries) {
-			if (files.size >= maxFiles) break;
-			if (entry.name.startsWith(".") || shouldSkipDirectory(entry.name)) continue;
-			const fileName = path$1.join(dir, entry.name);
-			if (entry.isDirectory()) queue.push(fileName);
-			else if (entry.isFile() && isSupportedDocument(fileName)) files.add(fileName);
-		}
-	}
-}
-function shouldSkipDirectory(name) {
-	return [
-		"node_modules",
-		"dist",
-		"out",
-		"build",
-		"coverage",
-		".git"
-	].includes(name);
-}
-function isSupportedDocument(fileName) {
-	return supportedDocumentPattern.test(fileName);
-}
-async function applyFileReplacements(replacements, defaultUri) {
-	const replacementsByUri = /* @__PURE__ */ new Map();
-	for (const replacement of replacements) {
-		const uri = replacement.uri ?? defaultUri;
-		const existing = replacementsByUri.get(uri) ?? [];
-		existing.push(replacement);
-		replacementsByUri.set(uri, existing);
-	}
-	for (const [uri, uriReplacements] of replacementsByUri) {
-		const fileName = sourceUriToFileName(uri);
-		const nextText = applyReplacementsToText(await fs.readFile(fileName, "utf8"), uriReplacements);
-		await fs.writeFile(fileName, nextText, "utf8");
-	}
-}
-function applyReplacementsToText(text, replacements) {
-	let updated = text;
-	const sorted = [...replacements].sort(compareReplacementRangesDescending);
-	for (const replacement of sorted) {
-		const lineStarts = getLineStarts(updated);
-		const start = offsetAt(lineStarts, replacement.range.startLine, replacement.range.startChar);
-		const end = offsetAt(lineStarts, replacement.range.endLine, replacement.range.endChar);
-		updated = `${updated.slice(0, start)}${replacement.newText}${updated.slice(end)}`;
-	}
-	return updated;
-}
-function watchWorkspace(rootDir, listener) {
-	let watcher;
-	const timers = /* @__PURE__ */ new Map();
-	const queue = (fileName) => {
-		const existing = timers.get(fileName);
-		if (existing) clearTimeout(existing);
-		timers.set(fileName, setTimeout(() => {
-			timers.delete(fileName);
-			listener(fileNameToUri(fileName));
-		}, 75));
-	};
-	try {
-		watcher = watch(rootDir, { recursive: true }, (_event, fileName) => {
-			if (fileName) queue(path$1.join(rootDir, fileName.toString()));
-		});
-	} catch {
-		watcher = watch(rootDir, (_event, fileName) => {
-			if (fileName) queue(path$1.join(rootDir, fileName.toString()));
-		});
-	}
-	return { dispose() {
-		watcher?.close();
-		for (const timer of timers.values()) clearTimeout(timer);
-		timers.clear();
-	} };
-}
-function getCliWebviewContent(options) {
-	const baseUrl = normalizedBaseUrl(options.editorUrl);
-	const url = new URL(`${baseUrl}/embed`);
-	if (options.apiKey) url.searchParams.set("api_key", options.apiKey);
-	return `<!DOCTYPE html>
-<html lang="en" style="height:100%;margin:0">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <style>
-    body { margin: 0; padding: 0; height: 100vh; overflow: hidden; }
-    iframe { border: 0; width: 100%; height: 100%; display: block; }
-  </style>
-</head>
-<body>
-  <iframe
-    id="stately-editor"
-    src="${escapeAttribute(url.toString())}"
-    allow="clipboard-read; clipboard-write"
-  ></iframe>
-  <script>
-    const iframe = document.getElementById('stately-editor');
-    const socket = new WebSocket(
-      (location.protocol === 'https:' ? 'wss:' : 'ws:') + '//' + location.host + '/ws'
-    );
-    const pending = [];
-
-    function sendToCli(message) {
-      if (socket.readyState === WebSocket.OPEN) {
-        socket.send(JSON.stringify(message));
-        return;
-      }
-      pending.push(message);
-    }
-
-    socket.addEventListener('open', () => {
-      while (pending.length > 0) {
-        socket.send(JSON.stringify(pending.shift()));
-      }
-    });
-
-    socket.addEventListener('message', (event) => {
-      iframe.contentWindow?.postMessage(JSON.parse(event.data), '*');
-    });
-
-    window.addEventListener('message', (event) => {
-      if (!event.data?.type?.startsWith?.('@statelyai.')) {
-        return;
-      }
-      sendToCli(event.data);
-    });
-  <\/script>
-</body>
-</html>`;
-}
-function encodeWebSocketFrame(payload, opcode = 1) {
-	const data = typeof payload === "string" ? Buffer.from(payload) : payload;
-	const headerLength = data.length < 126 ? 2 : data.length <= 65535 ? 4 : 10;
-	const frame = Buffer.alloc(headerLength + data.length);
-	frame[0] = 128 | opcode;
-	if (data.length < 126) {
-		frame[1] = data.length;
-		data.copy(frame, 2);
-	} else if (data.length <= 65535) {
-		frame[1] = 126;
-		frame.writeUInt16BE(data.length, 2);
-		data.copy(frame, 4);
-	} else {
-		frame[1] = 127;
-		frame.writeBigUInt64BE(BigInt(data.length), 2);
-		data.copy(frame, 10);
-	}
-	return frame;
-}
-function listen(server, port, host) {
-	return new Promise((resolve) => {
-		server.listen(port, host, resolve);
-	});
-}
-async function fetchEditorHost(input, init) {
-	const url = typeof input === "string" ? new URL(input) : input;
-	if (!isLocalVizHost(url.toString())) return fetch(url, init);
-	const body = typeof init?.body === "string" ? init.body : init?.body instanceof URLSearchParams ? init.body.toString() : void 0;
-	return new Promise((resolve, reject) => {
-		const request = https.request(url, {
-			method: init?.method ?? "GET",
-			headers: init?.headers,
-			rejectUnauthorized: false
-		}, (response) => {
-			const chunks = [];
-			response.on("data", (chunk) => {
-				chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-			});
-			response.on("end", () => {
-				const text = Buffer.concat(chunks).toString("utf8");
-				resolve({
-					ok: typeof response.statusCode === "number" && response.statusCode >= 200 && response.statusCode < 300,
-					status: response.statusCode ?? 0,
-					async json() {
-						return JSON.parse(text);
-					}
-				});
-			});
-		});
-		request.on("error", reject);
-		if (body !== void 0) request.write(body);
-		request.end();
-	});
-}
-async function assertEditorHostAvailable(editorUrl) {
-	const baseUrl = normalizedBaseUrl(editorUrl);
-	const embedUrl = new URL("/embed", baseUrl);
-	let response;
-	try {
-		response = await fetchEditorHost(embedUrl, { redirect: "manual" });
-	} catch (error) {
-		throw new Error(formatEditorHostError(baseUrl, void 0, error));
-	}
-	if (response.status === 404) throw new Error(formatEditorHostError(baseUrl, response.status));
-}
-function formatEditorHostError(baseUrl, status, cause) {
-	const hint = isLocalVizHost(baseUrl) ? " Start the local editor app with `pnpm dev` on https://viz.localhost, or pass `--editor-url https://viz.localhost`." : " Start the editor host, set `STATELY_EDITOR_URL`, or pass `--editor-url <url>`.";
-	return `Cannot reach a usable editor host at ${baseUrl}.${status ? ` HTTP ${status} from /embed.` : ""}${cause instanceof Error && cause.message ? ` ${cause.message}` : ""} The CLI loads editor URL defaults from your environment, including \`.env.local\`.${hint}`;
-}
-function isLocalVizHost(value) {
-	try {
-		const url = new URL(value);
-		return url.protocol === "https:" && url.hostname === "viz.localhost";
-	} catch {
-		return false;
-	}
-}
-function openBrowser(url) {
-	spawn(process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open", process.platform === "win32" ? [
-		"/c",
-		"start",
-		"",
-		url
-	] : [url], {
-		detached: true,
-		stdio: "ignore"
-	}).unref();
-}
-function getValidationErrors(validations) {
-	return (validations ?? []).filter((validation) => validation.level === "error");
-}
-function formatValidationErrorMessage(errors) {
-	const [firstError] = errors;
-	if (!firstError) return "Cannot save Viz changes because the graph has validation errors.";
-	if (errors.length === 1) return `Cannot save Viz changes: ${firstError.message}`;
-	return `Cannot save Viz changes: ${errors.length} validation errors. First: ${firstError.message}`;
-}
-function sourceLocationUris(sourceLocations) {
-	return [
-		...sourceLocations?.root ? [sourceLocations.root.uri] : [],
-		...(sourceLocations?.states ?? []).map((state) => state.uri),
-		...(sourceLocations?.staticValues ?? []).map((value) => value.uri)
-	];
-}
-function fileNameToUri(fileName) {
-	return pathToFileURL(path$1.resolve(fileName)).toString();
-}
-function sourceUriToFileName(uriOrPath) {
-	if (uriOrPath.startsWith("file://")) return fileURLToPath(uriOrPath);
-	if (/^[a-z][a-z\d+.-]*:/i.test(uriOrPath)) throw new Error(`Unsupported non-file URI: ${uriOrPath}`);
-	return path$1.resolve(uriOrPath);
-}
-function getLineStarts(text) {
-	const lineStarts = [0];
-	for (let index = 0; index < text.length; index += 1) if (text.charCodeAt(index) === 10) lineStarts.push(index + 1);
-	return lineStarts;
-}
-function offsetAt(lineStarts, line, character) {
-	const lineStart = lineStarts[line];
-	if (lineStart === void 0) return lineStarts[lineStarts.length - 1] + character;
-	return lineStart + character;
-}
-function compareReplacementRangesDescending(left, right) {
-	if (left.range.startLine !== right.range.startLine) return right.range.startLine - left.range.startLine;
-	return right.range.startChar - left.range.startChar;
-}
-function normalizedBaseUrl(value) {
-	return value.replace(/\/+$/, "");
-}
-function formatError(error, fallback) {
-	if (!(error instanceof Error)) return fallback;
-	const details = collectErrorDetails(error);
-	return details.length > 0 ? `${error.message} (${details.join(" | ")})` : error.message;
-}
-function collectErrorDetails(error) {
-	const details = [];
-	const seen = /* @__PURE__ */ new Set();
-	let current = error;
-	while (current && typeof current === "object" && !seen.has(current)) {
-		seen.add(current);
-		const code = "code" in current && typeof current.code === "string" ? current.code : void 0;
-		const message = "message" in current && typeof current.message === "string" ? current.message : void 0;
-		if (code && message) details.push(`${code}: ${message}`);
-		else if (code) details.push(code);
-		current = "cause" in current ? current.cause : void 0;
-	}
-	return details;
-}
-function escapeAttribute(value) {
-	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-
-//#endregion
-//#region src/credentials.ts
-const execFile$1 = promisify(execFile);
-const SERVICE_NAME = "statelyai";
-const ACCOUNT_NAME = "api-key";
-const CREDENTIALS_FILE_NAME = "credentials.json";
-function getConfigDir() {
-	const override = process.env.STATELYAI_CONFIG_DIR;
-	if (override) return path.resolve(override);
-	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", SERVICE_NAME);
-	if (process.platform === "win32") return path.join(process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"), SERVICE_NAME);
-	return path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"), SERVICE_NAME);
-}
-function getCredentialsFilePath() {
-	return path.join(getConfigDir(), CREDENTIALS_FILE_NAME);
-}
-function shouldUseFileBackendOnly() {
-	return process.env.STATELYAI_CREDENTIALS_BACKEND === "file";
-}
-async function readFileCredentials() {
-	try {
-		const raw = await promises.readFile(getCredentialsFilePath(), "utf8");
-		const parsed = JSON.parse(raw);
-		if (typeof parsed.apiKey !== "string" || parsed.apiKey.length === 0) return;
-		return {
-			apiKey: parsed.apiKey,
-			backend: "file",
-			location: getCredentialsFilePath()
-		};
-	} catch {
-		return;
-	}
-}
-async function writeFileCredentials(apiKey) {
-	const configDir = getConfigDir();
-	const credentialsPath = getCredentialsFilePath();
-	await promises.mkdir(configDir, {
-		recursive: true,
-		mode: 448
-	});
-	await promises.writeFile(credentialsPath, `${JSON.stringify({ apiKey }, null, 2)}\n`, {
-		encoding: "utf8",
-		mode: 384
-	});
-	await promises.chmod(credentialsPath, 384);
-	return {
-		apiKey,
-		backend: "file",
-		location: credentialsPath
-	};
-}
-async function deleteFileCredentials() {
-	try {
-		await promises.unlink(getCredentialsFilePath());
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function readMacOSKeychain() {
-	if (process.platform !== "darwin") return;
-	try {
-		const { stdout } = await execFile$1("security", [
-			"find-generic-password",
-			"-s",
-			SERVICE_NAME,
-			"-a",
-			ACCOUNT_NAME,
-			"-w"
-		]);
-		const apiKey = stdout.trim();
-		if (!apiKey) return;
-		return {
-			apiKey,
-			backend: "macos-keychain",
-			location: "macOS Keychain"
-		};
-	} catch {
-		return;
-	}
-}
-async function writeMacOSKeychain(apiKey) {
-	if (process.platform !== "darwin") return;
-	try {
-		await execFile$1("security", [
-			"add-generic-password",
-			"-U",
-			"-s",
-			SERVICE_NAME,
-			"-a",
-			ACCOUNT_NAME,
-			"-w",
-			apiKey
-		]);
-		return {
-			apiKey,
-			backend: "macos-keychain",
-			location: "macOS Keychain"
-		};
-	} catch {
-		return;
-	}
-}
-async function deleteMacOSKeychain() {
-	if (process.platform !== "darwin") return false;
-	try {
-		await execFile$1("security", [
-			"delete-generic-password",
-			"-s",
-			SERVICE_NAME,
-			"-a",
-			ACCOUNT_NAME
-		]);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function readLinuxSecretTool() {
-	if (process.platform !== "linux") return;
-	try {
-		const { stdout } = await execFile$1("secret-tool", [
-			"lookup",
-			"service",
-			SERVICE_NAME,
-			"account",
-			ACCOUNT_NAME
-		]);
-		const apiKey = stdout.trim();
-		if (!apiKey) return;
-		return {
-			apiKey,
-			backend: "linux-secret-tool",
-			location: "Secret Service (secret-tool)"
-		};
-	} catch {
-		return;
-	}
-}
-async function writeLinuxSecretTool(apiKey) {
-	if (process.platform !== "linux") return;
-	try {
-		execFileSync("secret-tool", [
-			"store",
-			"--label",
-			"statelyai API key",
-			"service",
-			SERVICE_NAME,
-			"account",
-			ACCOUNT_NAME
-		], { input: apiKey });
-		return {
-			apiKey,
-			backend: "linux-secret-tool",
-			location: "Secret Service (secret-tool)"
-		};
-	} catch {
-		return;
-	}
-}
-async function deleteLinuxSecretTool() {
-	if (process.platform !== "linux") return false;
-	try {
-		await execFile$1("secret-tool", [
-			"clear",
-			"service",
-			SERVICE_NAME,
-			"account",
-			ACCOUNT_NAME
-		]);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function getStoredApiKey() {
-	if (shouldUseFileBackendOnly()) return readFileCredentials();
-	return await readMacOSKeychain() ?? await readLinuxSecretTool() ?? await readFileCredentials();
-}
-async function setStoredApiKey(apiKey) {
-	if (shouldUseFileBackendOnly()) return writeFileCredentials(apiKey);
-	return await writeMacOSKeychain(apiKey) ?? await writeLinuxSecretTool(apiKey) ?? await writeFileCredentials(apiKey);
-}
-async function deleteStoredApiKey() {
-	if (shouldUseFileBackendOnly()) {
-		const deleted = await deleteFileCredentials();
-		return {
-			deleted,
-			locations: deleted ? [getCredentialsFilePath()] : []
-		};
-	}
-	const locations = [];
-	if (await deleteMacOSKeychain()) locations.push("macOS Keychain");
-	if (await deleteLinuxSecretTool()) locations.push("Secret Service (secret-tool)");
-	if (await deleteFileCredentials()) locations.push(getCredentialsFilePath());
-	return {
-		deleted: locations.length > 0,
-		locations
-	};
-}
-function describeCredentialBackend(backend, location) {
-	switch (backend) {
-		case "macos-keychain": return location;
-		case "linux-secret-tool": return location;
-		case "file": return `file (${location})`;
-	}
-}
-
-//#endregion
-//#region src/projectConfig.ts
-const STATELY_CONFIG_FILE = "statelyai.json";
-const STATELY_CONFIG_SCHEMA_URL = "https://stately.ai/schemas/statelyai.json";
-const STATELY_CONFIG_VERSION = "1.0.0";
-const DEFAULT_SOURCE_EXCLUDES = [
-	"**/*.test.*",
-	"**/*.spec.*",
-	"**/dist/**",
-	"**/node_modules/**"
-];
-const CODE_SOURCE_EXTENSIONS = new Set([
-	".ts",
-	".tsx",
-	".js",
-	".jsx",
-	".mts",
-	".cts",
-	".mjs",
-	".cjs"
-]);
-const execFileAsync$1 = promisify(execFile);
-function createStatelyProjectConfig(options) {
-	const defaultXStateVersion = options.defaultXStateVersion ?? 5;
-	return {
-		$schema: STATELY_CONFIG_SCHEMA_URL,
-		version: STATELY_CONFIG_VERSION,
-		projectId: options.projectId,
-		studioUrl: options.studioUrl,
-		defaultXStateVersion,
-		sources: []
-	};
-}
-function normalizeSourceConfig(source) {
-	return {
-		include: [...source.include ?? []],
-		exclude: source.exclude == null ? [...DEFAULT_SOURCE_EXCLUDES] : [...source.exclude],
-		format: source.format ?? "xstate",
-		...source.xstateVersion == null ? {} : { xstateVersion: source.xstateVersion }
-	};
-}
-function normalizeProjectConfig(config) {
-	return {
-		...config,
-		sources: (config.sources ?? []).map((source) => normalizeSourceConfig(source))
-	};
-}
-async function readStatelyProjectConfig(options = {}) {
-	const rootDir = path.resolve(options.cwd ?? process.cwd());
-	const configPath = path.resolve(rootDir, options.configPath ?? STATELY_CONFIG_FILE);
-	const raw = await fs.readFile(configPath, "utf8");
-	return {
-		config: normalizeProjectConfig(JSON.parse(raw)),
-		configPath,
-		rootDir
-	};
-}
-async function walkFiles(rootDir, currentDir = rootDir) {
-	const entries = await fs.readdir(currentDir, { withFileTypes: true });
-	const files = [];
-	for (const entry of entries) {
-		if (entry.name === ".git") continue;
-		const absolutePath = path.join(currentDir, entry.name);
-		if (entry.isDirectory()) {
-			files.push(...await walkFiles(rootDir, absolutePath));
-			continue;
-		}
-		if (!entry.isFile()) continue;
-		files.push(path.relative(rootDir, absolutePath).replace(/\\/g, "/"));
-	}
-	return files;
-}
-async function filterGitIgnoredPaths(rootDir, relativeFiles) {
-	try {
-		const { stdout } = await execFileAsync$1("git", [
-			"ls-files",
-			"--others",
-			"--ignored",
-			"--exclude-standard",
-			"--directory"
-		], { cwd: rootDir });
-		const ignoredEntries = stdout.split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean);
-		if (ignoredEntries.length === 0) return relativeFiles;
-		return relativeFiles.filter((relativePath) => {
-			return !ignoredEntries.some((ignoredEntry) => {
-				if (ignoredEntry.endsWith("/")) return relativePath.startsWith(ignoredEntry);
-				return relativePath === ignoredEntry;
-			});
-		});
-	} catch {
-		return relativeFiles;
-	}
-}
-function isCodeSourceFile(relativePath) {
-	return CODE_SOURCE_EXTENSIONS.has(path.extname(relativePath).toLowerCase());
-}
-function expandBraces(pattern) {
-	const match = pattern.match(/\{([^{}]+)\}/);
-	if (!match || match.index == null) return [pattern];
-	const [token, inner] = match;
-	return inner.split(",").flatMap((variant) => expandBraces(`${pattern.slice(0, match.index)}${variant}${pattern.slice(match.index + token.length)}`));
-}
-function globToRegExp(pattern) {
-	let regex = "^";
-	for (let index = 0; index < pattern.length; index += 1) {
-		const char = pattern[index];
-		const next = pattern[index + 1];
-		if (char === "*") {
-			if (next === "*") {
-				const slashAfterGlobstar = pattern[index + 2] === "/";
-				regex += slashAfterGlobstar ? "(?:.*/)?" : ".*";
-				index += slashAfterGlobstar ? 2 : 1;
-				continue;
-			}
-			regex += "[^/]*";
-			continue;
-		}
-		if (char === "?") {
-			regex += "[^/]";
-			continue;
-		}
-		if ("\\.[]{}()+-^$|".includes(char)) {
-			regex += `\\${char}`;
-			continue;
-		}
-		regex += char;
-	}
-	regex += "$";
-	return new RegExp(regex);
-}
-function matchesGlob(relativePath, pattern) {
-	return expandBraces(pattern).some((expanded) => globToRegExp(expanded).test(relativePath));
-}
-function matchesAny(patterns, relativePath) {
-	return (patterns ?? []).some((pattern) => matchesGlob(relativePath, pattern));
-}
-async function discoverCodeSourceFiles(options = {}) {
-	const rootDir = path.resolve(options.cwd ?? process.cwd());
-	return (await filterGitIgnoredPaths(rootDir, await walkFiles(rootDir))).filter((relativePath) => isCodeSourceFile(relativePath)).filter((relativePath) => !matchesAny(DEFAULT_SOURCE_EXCLUDES, relativePath)).sort((left, right) => left.localeCompare(right));
-}
-function createSuggestedSource(include) {
-	return {
-		include: [include],
-		exclude: [...DEFAULT_SOURCE_EXCLUDES],
-		format: "xstate",
-		xstateVersion: 5
-	};
-}
-function suggestStatelySourceConfigs(relativePaths, defaultXStateVersion = 5) {
-	const pending = new Set(relativePaths.map((relativePath) => relativePath.replace(/\\/g, "/")).filter(Boolean));
-	const suggestions = [];
-	const addSuggestion = (include, predicate) => {
-		const matched = [...pending].filter(predicate);
-		if (matched.length === 0) return;
-		suggestions.push({
-			...createSuggestedSource(include),
-			xstateVersion: defaultXStateVersion
-		});
-		for (const matchedPath of matched) pending.delete(matchedPath);
-	};
-	addSuggestion("**/*.machine.ts", (relativePath) => relativePath.endsWith(".machine.ts"));
-	addSuggestion("src/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}", (relativePath) => relativePath.startsWith("src/"));
-	addSuggestion("packages/*/src/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}", (relativePath) => /^packages\/[^/]+\/src\//.test(relativePath));
-	addSuggestion("apps/*/src/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}", (relativePath) => /^apps\/[^/]+\/src\//.test(relativePath));
-	const byDirectory = /* @__PURE__ */ new Map();
-	for (const relativePath of pending) {
-		const directory = path.posix.dirname(relativePath);
-		const key = directory === "." ? relativePath : directory;
-		const bucket = byDirectory.get(key) ?? [];
-		bucket.push(relativePath);
-		byDirectory.set(key, bucket);
-	}
-	for (const [key, matchedPaths] of [...byDirectory.entries()].sort((left, right) => left[0].localeCompare(right[0]))) {
-		if (matchedPaths.length > 1 && key !== "." && key !== matchedPaths[0]) {
-			addSuggestion(`${key}/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}`, (relativePath) => relativePath.startsWith(`${key}/`));
-			continue;
-		}
-		const exactPath = matchedPaths[0];
-		addSuggestion(exactPath, (relativePath) => relativePath === exactPath);
-	}
-	return suggestions;
-}
-async function discoverStatelySourceFiles(options = {}) {
-	const { config, rootDir } = options.config ? {
-		config: options.config,
-		rootDir: path.resolve(options.cwd ?? process.cwd())
-	} : await readStatelyProjectConfig(options);
-	const relativeFiles = await filterGitIgnoredPaths(rootDir, await walkFiles(rootDir));
-	const discovered = /* @__PURE__ */ new Map();
-	for (const source of config.sources) for (const relativePath of relativeFiles) {
-		if (!matchesAny(source.include, relativePath)) continue;
-		if (matchesAny(source.exclude, relativePath)) continue;
-		const filePath = path.join(rootDir, relativePath);
-		if (!discovered.has(filePath)) discovered.set(filePath, {
-			filePath,
-			relativePath,
-			source
-		});
-	}
-	return [...discovered.values()].sort((left, right) => left.relativePath.localeCompare(right.relativePath));
-}
-
-//#endregion
-//#region src/cli.ts
-const execFileAsync = promisify(execFile);
-const STATELY_API_KEY_SETTINGS_URL = "https://stately.ai/registry/user/my-settings?tab=API+Key";
-function loadLocalEnv() {
-	if (typeof process.loadEnvFile !== "function") return;
-	const cwdEnvPath = path.join(process.cwd(), ".env.local");
-	try {
-		process.loadEnvFile(cwdEnvPath);
-	} catch {}
-}
-loadLocalEnv();
-function getEnvApiKey() {
-	const statelyApiKey = process.env.STATELY_API_KEY;
-	if (statelyApiKey) return {
-		apiKey: statelyApiKey,
-		variable: "STATELY_API_KEY"
-	};
-	const publicApiKey = process.env.NEXT_PUBLIC_STATELY_API_KEY;
-	if (publicApiKey) return {
-		apiKey: publicApiKey,
-		variable: "NEXT_PUBLIC_STATELY_API_KEY"
-	};
-}
-async function resolveApiKey(explicitApiKey) {
-	if (explicitApiKey) return {
-		apiKey: explicitApiKey,
-		source: "flag",
-		detail: "--api-key"
-	};
-	const envApiKey = getEnvApiKey();
-	if (envApiKey) return {
-		apiKey: envApiKey.apiKey,
-		source: "env",
-		detail: envApiKey.variable
-	};
-	const storedApiKey = await getStoredApiKey();
-	if (storedApiKey) return {
-		apiKey: storedApiKey.apiKey,
-		source: "stored",
-		detail: describeCredentialBackend(storedApiKey.backend, storedApiKey.location)
-	};
-	return { source: "missing" };
-}
-function getDefaultBaseUrl() {
-	return process.env.STATELY_API_URL ?? process.env.NEXT_PUBLIC_BASE_URL ?? process.env.NEXT_PUBLIC_STATELY_API_URL;
-}
-function getDefaultEditorUrl() {
-	return process.env.STATELY_EDITOR_URL ?? process.env.NEXT_PUBLIC_BETA_EDITOR_URL ?? process.env.NEXT_PUBLIC_BASE_URL ?? "https://viz.localhost";
-}
-function getResolvedStudioUrl(baseUrl) {
-	return baseUrl ?? getDefaultBaseUrl() ?? "https://stately.ai";
-}
-function parseGitHubRemote(remoteUrl) {
-	const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
-	if (httpsMatch) {
-		const [, owner, repo] = httpsMatch;
-		if (!owner || !repo) return null;
-		return {
-			url: `https://github.com/${owner}/${repo}`,
-			owner,
-			repo,
-			branch: "",
-			treeSha: ""
-		};
-	}
-	const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
-	if (sshMatch) {
-		const [, owner, repo] = sshMatch;
-		if (!owner || !repo) return null;
-		return {
-			url: `https://github.com/${owner}/${repo}`,
-			owner,
-			repo,
-			branch: "",
-			treeSha: ""
-		};
-	}
-	return null;
-}
-async function inferConnectedRepoFromCwd(cwd) {
-	try {
-		const [{ stdout: remoteStdout }, { stdout: branchStdout }, { stdout: treeShaStdout }] = await Promise.all([
-			execFileAsync("git", [
-				"remote",
-				"get-url",
-				"origin"
-			], { cwd }),
-			execFileAsync("git", ["branch", "--show-current"], { cwd }),
-			execFileAsync("git", ["rev-parse", "HEAD"], { cwd })
-		]);
-		const parsedRemote = parseGitHubRemote(remoteStdout.trim());
-		if (!parsedRemote) return;
-		return {
-			...parsedRemote,
-			branch: branchStdout.trim(),
-			treeSha: treeShaStdout.trim()
-		};
-	} catch {
-		return;
-	}
-}
-function inferInitProjectName(cwd, repo) {
-	if (repo?.repo) return repo.repo;
-	return path.basename(cwd);
-}
-async function readApiKeyFromStdin() {
-	const chunks = [];
-	for await (const chunk of process.stdin) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-	return Buffer.concat(chunks).toString("utf8").trim();
-}
-async function promptForApiKey() {
-	if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("No interactive terminal available. Pass --api-key or pipe the key on stdin.");
-	const maskedOutput = new Writable({ write(chunk, _encoding, callback) {
-		if (!maskedOutput.muted) process.stdout.write(chunk);
-		callback();
-	} });
-	maskedOutput.muted = false;
-	const rl = createInterface({
-		input: process.stdin,
-		output: maskedOutput,
-		terminal: true
-	});
-	try {
-		process.stdout.write("Enter your Stately API key: ");
-		maskedOutput.muted = true;
-		const apiKey = (await rl.question("")).trim();
-		maskedOutput.muted = false;
-		process.stdout.write("\n");
-		return apiKey;
-	} finally {
-		rl.close();
-	}
-}
-async function promptYesNo(question, defaultValue = true) {
-	if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("No interactive terminal available.");
-	const rl = createInterface({
-		input: process.stdin,
-		output: process.stdout,
-		terminal: true
-	});
-	try {
-		const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
-		const answer = (await rl.question(`${question}${suffix}`)).trim().toLowerCase();
-		if (!answer) return defaultValue;
-		return answer === "y" || answer === "yes";
-	} finally {
-		rl.close();
-	}
-}
-function normalizeApiKey(value) {
-	const trimmed = value?.trim();
-	return trimmed ? trimmed : void 0;
-}
-function pluralize(count, singular, plural = `${singular}s`) {
-	return count === 1 ? singular : plural;
-}
-function getMissingApiKeyMessage() {
-	return `No API key configured. Use \`statelyai login\`, set \`STATELY_API_KEY\`, or pass \`--api-key\`.\nGet or create an API key at ${STATELY_API_KEY_SETTINGS_URL}`;
-}
-async function fileExists(filePath) {
-	try {
-		await fs.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function initProject(options) {
-	const cwd = path.resolve(options.cwd ?? process.cwd());
-	const studioUrl = getResolvedStudioUrl(options.baseUrl);
-	const configPath = path.resolve(cwd, options.configPath ?? STATELY_CONFIG_FILE);
-	const defaultXStateVersion = Math.max(5, options.defaultXStateVersion ?? 5);
-	if (!options.force && await fileExists(configPath)) throw new Error(`${configPath} already exists. Pass --force to overwrite it.`);
-	const client = options.client ?? createStatelyClient({
-		apiKey: options.apiKey,
-		baseUrl: studioUrl
-	});
-	const inferredRepo = options.project?.repo ?? await inferConnectedRepoFromCwd(cwd);
-	const projectInput = {
-		name: options.project?.name ?? inferInitProjectName(cwd, inferredRepo),
-		visibility: options.project?.visibility ?? "Private",
-		...options.project?.description ? { description: options.project.description } : {},
-		...options.project?.keywords ? { keywords: options.project.keywords } : {},
-		...inferredRepo ? { repo: inferredRepo } : {}
-	};
-	const project = await client.projects.ensure(projectInput);
-	const config = createStatelyProjectConfig({
-		projectId: project.projectId,
-		studioUrl,
-		defaultXStateVersion
-	});
-	await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
-	return {
-		config,
-		configPath,
-		project
-	};
-}
-async function scanProjectSources(options) {
-	const cwd = path.resolve(options.cwd ?? process.cwd());
-	const candidateRelativePaths = await discoverCodeSourceFiles({ cwd });
-	const machineRelativePaths = [];
-	for (const relativePath of candidateRelativePaths) {
-		const filePath = path.join(cwd, relativePath);
-		if (looksLikeXStateMachineSource(await fs.readFile(filePath, "utf8"))) machineRelativePaths.push(relativePath);
-	}
-	return suggestStatelySourceConfigs(machineRelativePaths, Math.max(5, options.defaultXStateVersion ?? 5));
-}
-function looksLikeXStateMachineSource(source) {
-	const hasXStateImport = /from\s+['"]xstate(?:\/[^'"]+)?['"]/.test(source) || /require\(\s*['"]xstate(?:\/[^'"]+)?['"]\s*\)/.test(source);
-	const hasMachineFactory = /\bcreateMachine\s*\(/.test(source) || /\.createMachine\s*\(/.test(source);
-	return hasXStateImport && hasMachineFactory;
-}
-function supportsMachineDiscovery(file) {
-	return file.source.format === "xstate" || file.source.format === "auto";
-}
-async function resolveConfiguredProject(options) {
-	const { config, configPath, rootDir } = await readStatelyProjectConfig({
-		cwd: options.cwd,
-		configPath: options.configPath
-	});
-	const studioUrl = options.baseUrl ?? config.studioUrl;
-	return {
-		client: options.client ?? createStatelyClient({
-			apiKey: options.apiKey,
-			baseUrl: studioUrl
-		}),
-		config,
-		configPath,
-		files: await discoverStatelySourceFiles({
-			cwd: rootDir,
-			config
-		})
-	};
-}
-const sharedFlags = {
-	help: Flags.help({ char: "h" }),
-	"fail-on-changes": Flags.boolean({
-		default: false,
-		description: "Exit with a nonzero code when differences are found"
-	}),
-	"api-key": Flags.string({ description: "Stately API key used for remote source or target resolution" }),
-	"base-url": Flags.string({ description: "Base URL for Stately Studio or a self-hosted deployment" })
-};
-function formatChangeList(label, items) {
-	if (items.length === 0) return null;
-	return `${label}: ${items.map((item) => item.id).join(", ")}`;
-}
-function formatPlanSummary(plan) {
-	const lines = [
-		`Plan: ${plan.source.locator} -> ${plan.target.locator}`,
-		`Source: ${plan.source.kind} (${plan.source.format})`,
-		`Target: ${plan.target.kind} (${plan.target.format})`,
-		`Has changes: ${plan.summary.hasChanges ? "yes" : "no"}`,
-		`Node changes: ${plan.summary.nodeChanges}`,
-		`Edge changes: ${plan.summary.edgeChanges}`
-	];
-	const nodeSections = [
-		formatChangeList("Added nodes", plan.diff.nodes.added),
-		formatChangeList("Removed nodes", plan.diff.nodes.removed),
-		formatChangeList("Updated nodes", plan.diff.nodes.updated)
-	].filter(Boolean);
-	const edgeSections = [
-		formatChangeList("Added edges", plan.diff.edges.added),
-		formatChangeList("Removed edges", plan.diff.edges.removed),
-		formatChangeList("Updated edges", plan.diff.edges.updated)
-	].filter(Boolean);
-	lines.push(...nodeSections, ...edgeSections);
-	if (plan.warnings.length > 0) lines.push(`Warnings: ${plan.warnings.join("; ")}`);
-	return lines.join("\n");
-}
-var BaseSyncCommand = class extends Command {
-	static enableJsonFlag = false;
-	static flags = sharedFlags;
-};
-const sharedArgs = {
-	source: Args.string({
-		required: true,
-		description: "Source locator. Supports local file paths, URLs, or machine IDs."
-	}),
-	target: Args.string({
-		required: true,
-		description: "Target locator. Supports local file paths, URLs, or machine IDs."
-	})
-};
-var ParsedSyncCommand = class extends BaseSyncCommand {
-	async parseSync(command) {
-		return this.parse(command);
-	}
-};
-var PlanCommand = class PlanCommand extends ParsedSyncCommand {
-	static summary = "Plan semantic sync changes between a source and target.";
-	static description = "Resolves the source and target, normalizes both into graph form, and prints a semantic change summary.";
-	static args = sharedArgs;
-	async run() {
-		const { args, flags } = await this.parseSync(PlanCommand);
-		const apiKey = (await resolveApiKey(flags["api-key"])).apiKey;
-		const plan = await planSync({
-			source: args.source,
-			target: args.target,
-			apiKey,
-			baseUrl: flags["base-url"] ?? getDefaultBaseUrl()
-		});
-		this.log(formatPlanSummary(plan));
-		this.exit(flags["fail-on-changes"] && plan.summary.hasChanges ? 1 : 0);
-	}
-};
-var DiffCommand = class DiffCommand extends ParsedSyncCommand {
-	static summary = "Diff a source and target using semantic graph comparison.";
-	static description = "Like plan, but intended for diff-style usage and exit codes in scripts.";
-	static args = sharedArgs;
-	async run() {
-		const { args, flags } = await this.parseSync(DiffCommand);
-		const apiKey = (await resolveApiKey(flags["api-key"])).apiKey;
-		const plan = await planSync({
-			source: args.source,
-			target: args.target,
-			apiKey,
-			baseUrl: flags["base-url"] ?? getDefaultBaseUrl()
-		});
-		this.log(formatPlanSummary(plan));
-		this.exit(flags["fail-on-changes"] && plan.summary.hasChanges ? 1 : 0);
-	}
-};
-var PullCommand = class PullCommand extends ParsedSyncCommand {
-	static summary = "Pull a source locator into a local target file.";
-	static description = "Resolves the source, materializes it in the target format inferred from the target file, and writes the result locally.";
-	static args = {
-		source: Args.string({
-			required: true,
-			description: "Source locator. Supports a local linked file, machine ID, URL, or local file path."
-		}),
-		target: Args.string({
-			required: false,
-			description: "Optional local target path. Defaults to the source file when pulling a linked local file."
-		})
-	};
-	async run() {
-		const { args, flags } = await this.parseSync(PullCommand);
-		const apiKey = (await resolveApiKey(flags["api-key"])).apiKey;
-		const localCandidate = path.resolve(process.cwd(), args.source);
-		let source = args.source;
-		let target = args.target;
-		if (!target && await fileExists(localCandidate)) {
-			const pragma = getStatelyPragma(await fs.readFile(localCandidate, "utf8"), localCandidate);
-			if (!pragma?.id) this.error(`No @statelyai id found in ${localCandidate}. Pass an explicit source machine ID or URL and target path.`);
-			source = pragma.id;
-			target = localCandidate;
-		}
-		if (!target) this.error("Missing target path. Pass `statelyai pull <machine-id|url> <file>` or `statelyai pull <linked-file>`.");
-		this.log(`Pulling ${source} into ${target}...`);
-		const result = await pullSync({
-			source,
-			target,
-			apiKey,
-			baseUrl: flags["base-url"] ?? getDefaultBaseUrl()
-		});
-		this.log(`Pulled: ${result.source.locator} -> ${result.outputPath}\nTarget: ${result.target.kind} (${result.target.format})`);
-	}
-};
-var PushCommand = class PushCommand extends Command {
-	static enableJsonFlag = false;
-	static summary = "Create or update remote machines for local source files.";
-	static description = "Uses statelyai.json source discovery by default, creates remote machines for unlabeled local machine sources, updates already-linked machines, and writes returned @statelyai ids back into source files.";
-	static args = { file: Args.string({
-		required: false,
-		description: "Optional local source file to push instead of scanning statelyai.json."
-	}) };
-	static flags = {
-		help: Flags.help({ char: "h" }),
-		"api-key": Flags.string({ description: "Stately API key used to create or update remote machines" }),
-		"base-url": Flags.string({ description: "Base URL for Stately Studio or a self-hosted deployment" }),
-		config: Flags.string({ description: "Path to statelyai.json" })
-	};
-	async run() {
-		const { args, flags } = await this.parse(PushCommand);
-		const resolvedApiKey = await resolveApiKey(flags["api-key"]);
-		if (!resolvedApiKey.apiKey) this.error(getMissingApiKeyMessage());
-		this.log("Resolving configured project and source files...");
-		const { client, config, files } = await resolveConfiguredProject({
-			apiKey: resolvedApiKey.apiKey,
-			baseUrl: flags["base-url"],
-			configPath: flags.config
-		});
-		const candidateFiles = args.file ? [{
-			filePath: path.resolve(args.file),
-			relativePath: path.relative(process.cwd(), path.resolve(args.file)),
-			source: {
-				include: [args.file],
-				format: "xstate",
-				xstateVersion: config.defaultXStateVersion
-			}
-		}] : files.filter(supportsMachineDiscovery);
-		if (candidateFiles.length === 0) {
-			this.log("No matching local machine source files were discovered.");
-			return;
-		}
-		this.log(`Processing ${candidateFiles.length} ${pluralize(candidateFiles.length, "source file")}...`);
-		const linked = [];
-		const refreshed = [];
-		const skipped = [];
-		for (const file of candidateFiles) {
-			this.log(`Pushing ${file.relativePath}...`);
-			if (!supportsMachineDiscovery(file)) {
-				skipped.push(`${file.relativePath}: unsupported format ${file.source.format}`);
-				continue;
-			}
-			const result = await pushLocalMachineLinks({
-				source: file.filePath,
-				apiKey: resolvedApiKey.apiKey,
-				baseUrl: flags["base-url"] ?? config.studioUrl,
-				client,
-				project: { projectId: config.projectId },
-				xstateVersion: Math.max(5, file.source.xstateVersion ?? config.defaultXStateVersion)
-			});
-			if (result.created.length > 0) linked.push(`${file.relativePath}: ${result.created.map(({ machineIndex, machine }) => `${machine.id} [${machineIndex}]`).join(", ")}`);
-			if (result.updated.length > 0) refreshed.push(`${file.relativePath}: ${result.updated.map(({ machineIndex, machine }) => `${machine.id} [${machineIndex}]`).join(", ")}`);
-			for (const entry of result.skipped) skipped.push(`${file.relativePath} [${entry.machineIndex}]: ${entry.reason}`);
-		}
-		if (linked.length > 0) this.log(`Linked:\n${linked.join("\n")}`);
-		if (refreshed.length > 0) this.log(`Updated:\n${refreshed.join("\n")}`);
-		if (skipped.length > 0) this.log(`Skipped:\n${skipped.join("\n")}`);
-	}
-};
-var OpenCommand = class OpenCommand extends Command {
-	static enableJsonFlag = false;
-	static summary = "Open a local file in the Stately visual editor.";
-	static description = "Starts a local browser-backed editor session. Saved file changes update the visual editor, and saved visual edits are written back to the source file.";
-	static args = { file: Args.string({
-		required: true,
-		description: "Local source file to edit visually."
-	}) };
-	static flags = {
-		help: Flags.help({ char: "h" }),
-		"api-key": Flags.string({ description: "Stately API key used when the editor server requires auth" }),
-		"editor-url": Flags.string({ description: "Base URL for the Stately editor embed" }),
-		host: Flags.string({
-			description: "Local server host",
-			default: "127.0.0.1"
-		}),
-		port: Flags.integer({
-			description: "Local server port. Defaults to a random available port.",
-			default: 0,
-			min: 0
-		}),
-		open: Flags.boolean({
-			description: "Open the local editor URL in the default browser",
-			default: true,
-			allowNo: true
-		}),
-		debug: Flags.boolean({
-			description: "Log editor protocol messages",
-			default: false
-		})
-	};
-	async run() {
-		const { args, flags } = await this.parse(OpenCommand);
-		const apiKey = (await resolveApiKey(flags["api-key"])).apiKey;
-		await openEditor({
-			fileName: path.resolve(args.file),
-			editorUrl: flags["editor-url"] ?? getDefaultEditorUrl(),
-			host: flags.host,
-			port: flags.port,
-			shouldOpen: flags.open,
-			apiKey,
-			debug: flags.debug
-		});
-	}
-};
-var InitCommand = class InitCommand extends Command {
-	static enableJsonFlag = false;
-	static summary = "Create a Stately project and write statelyai.json.";
-	static description = "Creates or reuses a remote Studio project for the current working directory and writes a local statelyai.json configuration file.";
-	static flags = {
-		help: Flags.help({ char: "h" }),
-		"api-key": Flags.string({ description: "Stately API key used to create the remote project" }),
-		"base-url": Flags.string({ description: "Base URL for Stately Studio or a self-hosted deployment" }),
-		name: Flags.string({ description: "Project name to create remotely" }),
-		visibility: Flags.string({
-			description: "Remote project visibility",
-			options: [
-				"Private",
-				"Public",
-				"Unlisted"
-			],
-			default: "Private"
-		}),
-		force: Flags.boolean({
-			description: "Overwrite an existing statelyai.json file",
-			default: false
-		}),
-		scan: Flags.boolean({
-			description: "Scan the repo for machine-bearing files and suggest source globs to save into statelyai.json",
-			default: false
-		})
-	};
-	async run() {
-		const { flags } = await this.parse(InitCommand);
-		const resolvedApiKey = await resolveApiKey(flags["api-key"]);
-		if (!resolvedApiKey.apiKey) this.error(getMissingApiKeyMessage());
-		this.log("Creating or reusing remote project...");
-		const result = await initProject({
-			apiKey: resolvedApiKey.apiKey,
-			baseUrl: flags["base-url"],
-			force: flags.force,
-			project: {
-				...flags.name ? { name: flags.name } : {},
-				visibility: flags.visibility
-			}
-		});
-		if (flags.scan) {
-			this.log("Scanning local source files...");
-			const suggestions = await scanProjectSources({
-				cwd: path.dirname(result.configPath),
-				defaultXStateVersion: result.config.defaultXStateVersion
-			});
-			if (suggestions.length === 0) {
-				this.log(`Initialized project ${result.project.projectId} and wrote ${result.configPath}.\nNo machine source globs were suggested. Edit statelyai.json before running statelyai push.`);
-				return;
-			}
-			this.log(`Initialized project ${result.project.projectId} and wrote ${result.configPath}.`);
-			this.log(`Suggested source globs:\n${suggestions.map((source) => `- ${source.include.join(", ")}`).join("\n")}`);
-			if (await promptYesNo("Save these source globs to statelyai.json?", true)) {
-				const nextConfig = {
-					...result.config,
-					sources: suggestions
-				};
-				await fs.writeFile(result.configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf8");
-				this.log("Saved scanned source globs to statelyai.json.");
-			} else this.log("Left statelyai.json with an empty sources array. Edit it before running statelyai push.");
-			return;
-		}
-		this.log(`Initialized project ${result.project.projectId} and wrote ${result.configPath}.\nNo source globs configured yet. Edit statelyai.json before running statelyai push, or rerun with --scan.`);
-	}
-};
-var LoginCommand = class LoginCommand extends Command {
-	static enableJsonFlag = false;
-	static summary = "Store a Stately API key for future CLI use.";
-	static description = "Stores a Stately API key in the OS credential store when available, with a private file fallback.";
-	static flags = {
-		help: Flags.help({ char: "h" }),
-		"api-key": Flags.string({ description: "API key to store without an interactive prompt" }),
-		stdin: Flags.boolean({
-			description: "Read the API key from standard input",
-			default: false
-		})
-	};
-	async run() {
-		const { flags } = await this.parse(LoginCommand);
-		if (flags.stdin && flags["api-key"]) this.error("Pass either --api-key or --stdin, not both.");
-		if (!flags["api-key"] && !flags.stdin && process.stdin.isTTY && process.stdout.isTTY) this.log(`Get or create an API key at ${STATELY_API_KEY_SETTINGS_URL}`);
-		const apiKey = normalizeApiKey(flags["api-key"] ?? (!process.stdin.isTTY || flags.stdin ? await readApiKeyFromStdin() : await promptForApiKey()));
-		if (!apiKey) this.error(`API key cannot be empty.\nGet or create an API key at ${STATELY_API_KEY_SETTINGS_URL}`);
-		const stored = await setStoredApiKey(apiKey);
-		this.log(`Stored API key in ${describeCredentialBackend(stored.backend, stored.location)}.`);
-	}
-};
-var LogoutCommand = class extends Command {
-	static enableJsonFlag = false;
-	static summary = "Remove any API key stored by the CLI.";
-	static description = "Deletes the locally stored API key. Environment variables are not changed.";
-	static flags = { help: Flags.help({ char: "h" }) };
-	async run() {
-		const result = await deleteStoredApiKey();
-		if (!result.deleted) {
-			this.log("No stored API key found.");
-			return;
-		}
-		this.log(`Removed stored API key from ${result.locations.join(", ")}.`);
-	}
-};
-var AuthStatusCommand = class extends Command {
-	static enableJsonFlag = false;
-	static summary = "Show how the CLI would resolve its API key.";
-	static description = "Reports whether the CLI would use a flag, environment variable, or stored credential.";
-	static flags = { help: Flags.help({ char: "h" }) };
-	async run() {
-		const envApiKey = getEnvApiKey();
-		const storedApiKey = await getStoredApiKey();
-		if (envApiKey) {
-			this.log(`API key source: environment (${envApiKey.variable}).`);
-			if (storedApiKey) this.log(`Stored credential also available in ${describeCredentialBackend(storedApiKey.backend, storedApiKey.location)}.`);
-			return;
-		}
-		if (storedApiKey) {
-			this.log(`API key source: stored credential (${describeCredentialBackend(storedApiKey.backend, storedApiKey.location)}).`);
-			return;
-		}
-		this.log(getMissingApiKeyMessage());
-	}
-};
-const COMMANDS = {
-	plan: PlanCommand,
-	diff: DiffCommand,
-	pull: PullCommand,
-	push: PushCommand,
-	open: OpenCommand,
-	init: InitCommand,
-	login: LoginCommand,
-	logout: LogoutCommand,
-	"auth:status": AuthStatusCommand
-};
-async function run(argv = process.argv.slice(2), entryUrl = import.meta.url) {
-	const normalizedArgv = argv.length === 1 && argv[0] === "-h" ? ["--help"] : argv;
-	try {
-		await run$1(normalizedArgv, entryUrl);
-		await flush();
-	} catch (error) {
-		await handle(error);
-	}
-}
-function isDirectExecution() {
-	const entryPath = process.argv[1];
-	if (!entryPath) return false;
-	const modulePath = fileURLToPath(import.meta.url);
-	try {
-		return fs$1.realpathSync(entryPath) === fs$1.realpathSync(modulePath);
-	} catch {
-		return path.resolve(entryPath) === modulePath;
-	}
-}
-if (isDirectExecution()) run();
-
-//#endregion
-export { COMMANDS, createStatelyProjectConfig, formatPlanSummary, getEnvApiKey, inferInitProjectName, initProject, resolveApiKey, run, scanProjectSources };