@statelyai/sdk 0.6.1 → 0.7.1

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createStatelyClient } from "./studio.mjs";
-import "./graphToXStateTS-Gzh0ZqbN.mjs";
-import { planSync, pullSync } from "./sync.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";
@@ -931,24 +931,27 @@ function describeCredentialBackend(backend, location) {
 }
 
 //#endregion
-//#region src/cli.ts
-const execFileAsync = promisify(execFile);
+//#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";
-function getDefaultSources(defaultXStateVersion) {
-	return [{
-		include: ["**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}"],
-		exclude: [
-			"**/*.test.*",
-			"**/*.spec.*",
-			"**/dist/**",
-			"**/node_modules/**"
-		],
-		format: "xstate",
-		xstateVersion: defaultXStateVersion
-	}];
-}
+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 {
@@ -957,9 +960,182 @@ function createStatelyProjectConfig(options) {
 		projectId: options.projectId,
 		studioUrl: options.studioUrl,
 		defaultXStateVersion,
-		sources: getDefaultSources(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");
@@ -1090,10 +1266,32 @@ async function promptForApiKey() {
 		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);
@@ -1133,6 +1331,43 @@ async function initProject(options) {
 		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({
@@ -1225,19 +1460,103 @@ var DiffCommand = class DiffCommand extends ParsedSyncCommand {
 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 = sharedArgs;
+	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: args.source,
-			target: args.target,
+			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.";
@@ -1304,12 +1623,17 @@ var InitCommand = class InitCommand extends Command {
 		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("No API key configured. Use `statelyai login`, set `STATELY_API_KEY`, or pass `--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"],
@@ -1319,7 +1643,29 @@ var InitCommand = class InitCommand extends Command {
 				visibility: flags.visibility
 			}
 		});
-		this.log(`Initialized project ${result.project.projectId} and wrote ${result.configPath}.`);
+		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 {
@@ -1337,8 +1683,9 @@ var LoginCommand = class LoginCommand extends Command {
 	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.");
+		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)}.`);
 	}
@@ -1374,13 +1721,14 @@ var AuthStatusCommand = class extends Command {
 			this.log(`API key source: stored credential (${describeCredentialBackend(storedApiKey.backend, storedApiKey.location)}).`);
 			return;
 		}
-		this.log("No API key configured. Use `statelyai login`, set `STATELY_API_KEY`, or pass `--api-key`.");
+		this.log(getMissingApiKeyMessage());
 	}
 };
 const COMMANDS = {
 	plan: PlanCommand,
 	diff: DiffCommand,
 	pull: PullCommand,
+	push: PushCommand,
 	open: OpenCommand,
 	init: InitCommand,
 	login: LoginCommand,
@@ -1409,4 +1757,4 @@ function isDirectExecution() {
 if (isDirectExecution()) run();
 
 //#endregion
-export { COMMANDS, createStatelyProjectConfig, formatPlanSummary, getEnvApiKey, inferInitProjectName, initProject, resolveApiKey, run };
+export { COMMANDS, createStatelyProjectConfig, formatPlanSummary, getEnvApiKey, inferInitProjectName, initProject, resolveApiKey, run, scanProjectSources };

package/dist/embed.d.mts

@@ -1,4 +1,4 @@
-import { a as EmbedMode, c as ExportFormatMap, d as MachineSourceLocations, f as ProjectEmbedMachine, i as EmbedEventName, l as InitOptions, m as UploadResult, n as EmbedEventHandler, o as ExportCallOptions, r as EmbedEventMap, s as ExportFormat, t as CommentsConfig, u as MachineInitOptions } from "./protocol-CDoCcaIP.mjs";
+import { a as EmbedMode, c as ExportFormatMap, d as MachineSourceLocations, f as ProjectEmbedMachine, i as EmbedEventName, l as InitOptions, m as UploadResult, n as EmbedEventHandler, o as ExportCallOptions, r as EmbedEventMap, s as ExportFormat, t as CommentsConfig, u as MachineInitOptions } from "./protocol-s9zwsiCW.mjs";
 import { AssetUploadAdapter } from "./assetStorage.mjs";
 
 //#region src/embed.d.ts

package/dist/embed.mjs

@@ -1,4 +1,4 @@
-import { a as toInitMessage, i as createPendingExportManager, r as createEventRegistry, t as createPostMessageTransport } from "./transport-C0eTgNNu.mjs";
+import { a as toInitMessage, i as createPendingExportManager, r as createEventRegistry, t as createPostMessageTransport } from "./transport-C8UTS3Fa.mjs";
 
 //#region src/embed.ts
 function buildEmbedUrl(options) {

package/dist/graph.d.mts

@@ -1,2 +1,2 @@
-import { _ as studioMachineConverter, a as StatelyGraphData, c as StatelyInvoke, d as StudioAction, f as StudioEdge, g as fromStudioMachine, h as StudioNode, i as StatelyGraph, l as StatelyNodeData, m as StudioMachine, n as StatelyActorImplementation, o as StatelyGuard, p as StudioEventTypeData, r as StatelyEdgeData, s as StatelyImplementation, t as StatelyAction, u as StatelyTagImplementation, v as toStudioMachine } from "./graph-DpBGHZwl.mjs";
+import { _ as studioMachineConverter, a as StatelyGraphData, c as StatelyInvoke, d as StudioAction, f as StudioEdge, g as fromStudioMachine, h as StudioNode, i as StatelyGraph, l as StatelyNodeData, m as StudioMachine, n as StatelyActorImplementation, o as StatelyGuard, p as StudioEventTypeData, r as StatelyEdgeData, s as StatelyImplementation, t as StatelyAction, u as StatelyTagImplementation, v as toStudioMachine } from "./graph-zuNj3kfa.mjs";
 export { StatelyAction, StatelyActorImplementation, StatelyEdgeData, StatelyGraph, StatelyGraphData, StatelyGuard, StatelyImplementation, StatelyInvoke, StatelyNodeData, StatelyTagImplementation, StudioAction, StudioEdge, StudioEventTypeData, StudioMachine, StudioNode, fromStudioMachine, studioMachineConverter, toStudioMachine };

package/dist/index.d.mts

@@ -1,14 +1,14 @@
 import { StatelyApiClientOptions, StatelyApiError, StatelyApiUrlOptions, createStatelyApiClient, createStatelyApiUrl } from "./api.mjs";
-import { a as EmbedMode, c as ExportFormatMap, f as ProjectEmbedMachine, i as EmbedEventName, l as InitOptions, m as UploadResult, n as EmbedEventHandler, o as ExportCallOptions, r as EmbedEventMap, s as ExportFormat, t as CommentsConfig } from "./protocol-CDoCcaIP.mjs";
+import { a as EmbedMode, c as ExportFormatMap, f as ProjectEmbedMachine, i as EmbedEventName, l as InitOptions, m as UploadResult, n as EmbedEventHandler, o as ExportCallOptions, r as EmbedEventMap, s as ExportFormat, t as CommentsConfig } from "./protocol-s9zwsiCW.mjs";
 import { AssetUploadAdapter, AssetUploadContext, AssetUploadRequest, CreateS3AssetUploadAdapterOptions, CreateSupabaseAssetUploadAdapterOptions, S3UploadTarget, SupabaseStorageClient, createS3AssetUploadAdapter, createSupabaseAssetUploadAdapter } from "./assetStorage.mjs";
-import { ConnectedRepo, CreateMachineFromDefinitionInput, CreateMachineFromTemplateInput, CreateMachineInput, CreateMachineTemplate, CreateProjectInput, EnsureProjectInput, ExtractMachinesResponse, ExtractedMachine, GetMachineOptions, ProjectData, ProjectMachine, ProjectVisibility, RepoType, StudioApiError, StudioClient, StudioClientOptions, StudioMachineRecord, VerifyApiKeyResponse, XStateVersion, createStatelyClient } from "./studio.mjs";
-import { C as EventTypeData, S as DigraphNodeConfig, _ as studioMachineConverter, a as StatelyGraphData, b as DigraphConfig, c as StatelyInvoke, d as StudioAction, f as StudioEdge, g as fromStudioMachine, h as StudioNode, i as StatelyGraph, l as StatelyNodeData, m as StudioMachine, o as StatelyGuard, r as StatelyEdgeData, t as StatelyAction, v as toStudioMachine, w as StateNodeJSONData, x as DigraphEdgeConfig, y as DigraphAction } from "./graph-DpBGHZwl.mjs";
-import { PlanSyncOptions, PullSyncResult, PushSyncOptions, PushSyncProjectOptions, PushSyncResult, ResolvedSyncInput, SyncInputFormat, SyncPlan, SyncPlanSummary } from "./sync.mjs";
+import { ConnectedRepo, CreateMachineFromDefinitionInput, CreateMachineFromTemplateInput, CreateMachineInput, CreateMachineTemplate, CreateProjectInput, EnsureProjectInput, ExtractMachinesResponse, ExtractedMachine, GetMachineOptions, ProjectData, ProjectMachine, ProjectVisibility, RepoType, StudioApiError, StudioClient, StudioClientOptions, StudioMachineRecord, UpdateMachineInput, VerifyApiKeyResponse, XStateVersion, createStatelyClient } from "./studio.mjs";
+import { C as EventTypeData, S as DigraphNodeConfig, _ as studioMachineConverter, a as StatelyGraphData, b as DigraphConfig, c as StatelyInvoke, d as StudioAction, f as StudioEdge, g as fromStudioMachine, h as StudioNode, i as StatelyGraph, l as StatelyNodeData, m as StudioMachine, o as StatelyGuard, r as StatelyEdgeData, t as StatelyAction, v as toStudioMachine, w as StateNodeJSONData, x as DigraphEdgeConfig, y as DigraphAction } from "./graph-zuNj3kfa.mjs";
+import { PlanSyncOptions, PullSyncResult, PushLocalMachineLinksResult, PushSyncOptions, PushSyncProjectOptions, PushSyncResult, ResolvedSyncInput, SyncInputFormat, SyncPlan, SyncPlanSummary } from "./sync.mjs";
 import { AssetConfig, StatelyEmbed, StatelyEmbedOptions, createStatelyEmbed } from "./embed.mjs";
-import { a as ManualActorOptions, c as createPostMessageTransport, i as InspectorEvents, l as createWebSocketTransport, n as CreateInspectorOptions, o as createStatelyInspector, r as Inspector, s as Transport, t as AdoptedActor } from "./inspect-BMIJcsFh.mjs";
+import { a as ManualActorOptions, c as createPostMessageTransport, i as InspectorEvents, l as createWebSocketTransport, n as CreateInspectorOptions, o as createStatelyInspector, r as Inspector, s as Transport, t as AdoptedActor } from "./inspect-YoEwfiKb.mjs";
 import { ActionLocation, GraphPatch } from "./patchTypes.mjs";
-import { JSONSchema7 } from "json-schema";
 import { UnknownMachineConfig } from "xstate";
+import { JSONSchema7 } from "json-schema";
 
 //#region src/statelyPragma.d.ts
 interface StatelyPragma {
@@ -185,4 +185,4 @@ declare function contextSchemaToTSType(context: Record<string, JSONSchema7> | nu
  */
 declare function eventsSchemaToTSType(events: Record<string, JSONSchema7> | null | undefined): string | null;
 //#endregion
-export { type ActionLocation, type AdoptedActor, type AssetConfig, type AssetUploadAdapter, type AssetUploadContext, type AssetUploadRequest, type CodeGenGraph, type CommentsConfig, type ConnectedRepo, type CreateInspectorOptions, type CreateMachineFromDefinitionInput, type CreateMachineFromTemplateInput, type CreateMachineInput, type CreateMachineTemplate, type CreateProjectInput, type CreateS3AssetUploadAdapterOptions, type CreateSupabaseAssetUploadAdapterOptions, type DigraphAction, type DigraphConfig, type DigraphEdgeConfig, type DigraphNodeConfig, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type EnsureProjectInput, type EventTypeData, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type ExtractMachinesResponse, type ExtractedMachine, type GetMachineOptions, type GraphPatch, type InitOptions, type Inspector, type InspectorEvents, type MachineConfigOptions, type ManualActorOptions, type PlanSyncOptions, type ProjectData, type ProjectEmbedMachine, type ProjectMachine, type ProjectVisibility, type PullSyncResult, type PushSyncOptions, type PushSyncProjectOptions, type PushSyncResult, RawCode, type RepoType, type ResolvedSyncInput, type S3UploadTarget, type StateNodeJSONData, type StatelyAction, type StatelyApiClientOptions, StatelyApiError, type StatelyApiUrlOptions, type StatelyEdgeData, type StatelyEmbed, type StatelyEmbedOptions, type StatelyGraph, type StatelyGraphData, type StatelyGuard, type StatelyInvoke, type StatelyNodeData, type StatelyPragma, type StatelyPragmaAttachment, type StudioAction, StudioApiError, type StudioClient, type StudioClientOptions, type StudioEdge, type StudioMachine, type StudioMachineRecord, type StudioNode, type SupabaseStorageClient, type SyncInputFormat, type SyncPlan, type SyncPlanSummary, type Transport, type UploadResult, type UpsertStatelyPragmaOptions, type VerifyApiKeyResponse, type XStateTSOptions, type XStateVersion, contextSchemaToTSType, createPostMessageTransport, createS3AssetUploadAdapter, createStatelyApiClient, createStatelyApiUrl, createStatelyClient, createStatelyEmbed, createStatelyInspector, createSupabaseAssetUploadAdapter, createWebSocketTransport, eventsSchemaToTSType, findStatelyPragmaAttachments, fromStudioMachine, getStatelyPragma, graphToMachineConfig, graphToXStateTS, jsonSchemaToTSType, raw, serializeJS, studioMachineConverter, toStudioMachine, upsertStatelyPragma };
+export { type ActionLocation, type AdoptedActor, type AssetConfig, type AssetUploadAdapter, type AssetUploadContext, type AssetUploadRequest, type CodeGenGraph, type CommentsConfig, type ConnectedRepo, type CreateInspectorOptions, type CreateMachineFromDefinitionInput, type CreateMachineFromTemplateInput, type CreateMachineInput, type CreateMachineTemplate, type CreateProjectInput, type CreateS3AssetUploadAdapterOptions, type CreateSupabaseAssetUploadAdapterOptions, type DigraphAction, type DigraphConfig, type DigraphEdgeConfig, type DigraphNodeConfig, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type EnsureProjectInput, type EventTypeData, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type ExtractMachinesResponse, type ExtractedMachine, type GetMachineOptions, type GraphPatch, type InitOptions, type Inspector, type InspectorEvents, type MachineConfigOptions, type ManualActorOptions, type PlanSyncOptions, type ProjectData, type ProjectEmbedMachine, type ProjectMachine, type ProjectVisibility, type PullSyncResult, type PushLocalMachineLinksResult, type PushSyncOptions, type PushSyncProjectOptions, type PushSyncResult, RawCode, type RepoType, type ResolvedSyncInput, type S3UploadTarget, type StateNodeJSONData, type StatelyAction, type StatelyApiClientOptions, StatelyApiError, type StatelyApiUrlOptions, type StatelyEdgeData, type StatelyEmbed, type StatelyEmbedOptions, type StatelyGraph, type StatelyGraphData, type StatelyGuard, type StatelyInvoke, type StatelyNodeData, type StatelyPragma, type StatelyPragmaAttachment, type StudioAction, StudioApiError, type StudioClient, type StudioClientOptions, type StudioEdge, type StudioMachine, type StudioMachineRecord, type StudioNode, type SupabaseStorageClient, type SyncInputFormat, type SyncPlan, type SyncPlanSummary, type Transport, type UpdateMachineInput, type UploadResult, type UpsertStatelyPragmaOptions, type VerifyApiKeyResponse, type XStateTSOptions, type XStateVersion, contextSchemaToTSType, createPostMessageTransport, createS3AssetUploadAdapter, createStatelyApiClient, createStatelyApiUrl, createStatelyClient, createStatelyEmbed, createStatelyInspector, createSupabaseAssetUploadAdapter, createWebSocketTransport, eventsSchemaToTSType, findStatelyPragmaAttachments, fromStudioMachine, getStatelyPragma, graphToMachineConfig, graphToXStateTS, jsonSchemaToTSType, raw, serializeJS, studioMachineConverter, toStudioMachine, upsertStatelyPragma };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { n as createWebSocketTransport, t as createPostMessageTransport } from "./transport-C0eTgNNu.mjs";
+import { n as createWebSocketTransport, t as createPostMessageTransport } from "./transport-C8UTS3Fa.mjs";
 import { createStatelyEmbed } from "./embed.mjs";
 import { createS3AssetUploadAdapter, createSupabaseAssetUploadAdapter } from "./assetStorage.mjs";
 import { createStatelyInspector } from "./inspect.mjs";

package/dist/{inspect-BMIJcsFh.d.mts → inspect-YoEwfiKb.d.mts}

@@ -1,4 +1,4 @@
-import { c as ExportFormatMap, o as ExportCallOptions, p as ProtocolMessage, r as EmbedEventMap, s as ExportFormat } from "./protocol-CDoCcaIP.mjs";
+import { c as ExportFormatMap, o as ExportCallOptions, p as ProtocolMessage, r as EmbedEventMap, s as ExportFormat } from "./protocol-s9zwsiCW.mjs";
 
 //#region src/transport.d.ts
 interface Transport {

package/dist/inspect.d.mts

@@ -1,3 +1,3 @@
-import { a as EmbedMode, c as ExportFormatMap, i as EmbedEventName, n as EmbedEventHandler, o as ExportCallOptions, r as EmbedEventMap, s as ExportFormat } from "./protocol-CDoCcaIP.mjs";
-import { a as ManualActorOptions, i as InspectorEvents, n as CreateInspectorOptions, o as createStatelyInspector, r as Inspector, s as Transport, t as AdoptedActor } from "./inspect-BMIJcsFh.mjs";
+import { a as EmbedMode, c as ExportFormatMap, i as EmbedEventName, n as EmbedEventHandler, o as ExportCallOptions, r as EmbedEventMap, s as ExportFormat } from "./protocol-s9zwsiCW.mjs";
+import { a as ManualActorOptions, i as InspectorEvents, n as CreateInspectorOptions, o as createStatelyInspector, r as Inspector, s as Transport, t as AdoptedActor } from "./inspect-YoEwfiKb.mjs";
 export { AdoptedActor, CreateInspectorOptions, EmbedEventHandler, EmbedEventMap, EmbedEventName, EmbedMode, ExportCallOptions, ExportFormat, ExportFormatMap, Inspector, InspectorEvents, ManualActorOptions, Transport, createStatelyInspector };

package/dist/inspect.mjs

@@ -1,4 +1,4 @@
-import { i as createPendingExportManager, n as createWebSocketTransport, r as createEventRegistry } from "./transport-C0eTgNNu.mjs";
+import { i as createPendingExportManager, n as createWebSocketTransport, r as createEventRegistry } from "./transport-C8UTS3Fa.mjs";
 
 //#region src/inspect.ts
 const defaultSerializeSnapshot = (snapshot) => ({

package/dist/{protocol-CDoCcaIP.d.mts → protocol-s9zwsiCW.d.mts}

@@ -60,9 +60,8 @@ interface ExportFormatMap {
     };
     result: string;
   };
-  json: {
+  'xstate-json': {
     options: {
-      simplifyArrays?: boolean;
       version?: 4 | 5;
     };
     result: Record<string, unknown>;

package/dist/studio.d.mts

@@ -75,6 +75,11 @@ interface CreateMachineFromTemplateInput {
   xstateVersion?: XStateVersion;
 }
 type CreateMachineInput<TDefinition = Record<string, unknown>> = CreateMachineFromDefinitionInput<TDefinition> | CreateMachineFromTemplateInput;
+interface UpdateMachineInput<TDefinition = Record<string, unknown>> {
+  id: string;
+  name?: string;
+  definition?: TDefinition;
+}
 interface StudioMachineRecord<TDefinition = Record<string, unknown>> {
   id: string;
   name: string;
@@ -99,6 +104,7 @@ interface StudioClient {
   machines: {
     create<TMachine = Record<string, unknown>>(input: CreateMachineInput<TMachine>): Promise<StudioMachineRecord<TMachine>>;
     createMany<TMachine = Record<string, unknown>>(input: CreateMachineInput<TMachine>): Promise<Array<StudioMachineRecord<TMachine>>>;
+    update<TMachine = Record<string, unknown>>(input: UpdateMachineInput<TMachine>): Promise<StudioMachineRecord<TMachine>>;
     get<TMachine = Record<string, unknown>>(machineId: string, options?: GetMachineOptions): Promise<TMachine>;
   };
   code: {
@@ -109,4 +115,4 @@ interface StudioClient {
 }
 declare function createStatelyClient(options?: StudioClientOptions): StudioClient;
 //#endregion
-export { ConnectedRepo, CreateMachineFromDefinitionInput, CreateMachineFromTemplateInput, CreateMachineInput, CreateMachineTemplate, CreateProjectInput, EnsureProjectInput, ExtractMachinesResponse, ExtractedMachine, GetMachineOptions, ProjectData, ProjectMachine, ProjectVisibility, RepoType, StudioApiError, StudioClient, StudioClientOptions, StudioMachineRecord, VerifyApiKeyResponse, XStateVersion, createStatelyClient };
+export { ConnectedRepo, CreateMachineFromDefinitionInput, CreateMachineFromTemplateInput, CreateMachineInput, CreateMachineTemplate, CreateProjectInput, EnsureProjectInput, ExtractMachinesResponse, ExtractedMachine, GetMachineOptions, ProjectData, ProjectMachine, ProjectVisibility, RepoType, StudioApiError, StudioClient, StudioClientOptions, StudioMachineRecord, UpdateMachineInput, VerifyApiKeyResponse, XStateVersion, createStatelyClient };