@statelyai/sdk 0.6.0 → 0.7.0

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createStatelyClient } from "./studio.mjs";
-import "./graphToXStateTS-CvXM8wHL.mjs";
-import { planSync, pullSync } from "./sync.mjs";
+import { u as getStatelyPragma } from "./graphToXStateTS-Gzh0ZqbN.mjs";
+import { planSync, pullSync, pushLocalMachineLinks } from "./sync.mjs";
 import fs from "node:fs/promises";
 import * as path$1 from "node:path";
 import path from "node:path";
@@ -931,24 +931,26 @@ 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"
+]);
 function createStatelyProjectConfig(options) {
 	const defaultXStateVersion = options.defaultXStateVersion ?? 5;
 	return {
@@ -957,9 +959,145 @@ function createStatelyProjectConfig(options) {
 		projectId: options.projectId,
 		studioUrl: options.studioUrl,
 		defaultXStateVersion,
-		sources: getDefaultSources(defaultXStateVersion)
+		sources: []
 	};
 }
+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: 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;
+}
+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 = {}) {
+	return (await walkFiles(path.resolve(options.cwd ?? process.cwd()))).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 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);
 function loadLocalEnv() {
 	if (typeof process.loadEnvFile !== "function") return;
 	const cwdEnvPath = path.join(process.cwd(), ".env.local");
@@ -1090,6 +1228,22 @@ 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;
@@ -1133,6 +1287,45 @@ 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);
+		const contents = await fs.readFile(filePath, "utf8");
+		let extracted;
+		try {
+			extracted = await options.client.code.extractMachines(contents);
+		} catch {
+			continue;
+		}
+		if (extracted.machines.length > 0) machineRelativePaths.push(relativePath);
+	}
+	return suggestStatelySourceConfigs(machineRelativePaths, Math.max(5, options.defaultXStateVersion ?? 5));
+}
+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 +1418,99 @@ 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>`.");
 		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("No API key configured. Use `statelyai login`, set `STATELY_API_KEY`, or pass `--api-key`.");
+		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;
+		}
+		const linked = [];
+		const refreshed = [];
+		const skipped = [];
+		for (const file of candidateFiles) {
+			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,6 +1577,10 @@ 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() {
@@ -1319,7 +1596,33 @@ var InitCommand = class InitCommand extends Command {
 				visibility: flags.visibility
 			}
 		});
-		this.log(`Initialized project ${result.project.projectId} and wrote ${result.configPath}.`);
+		if (flags.scan) {
+			const scanClient = createStatelyClient({
+				apiKey: resolvedApiKey.apiKey,
+				baseUrl: flags["base-url"] ?? result.config.studioUrl
+			});
+			const suggestions = await scanProjectSources({
+				cwd: path.dirname(result.configPath),
+				client: scanClient,
+				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 {
@@ -1381,6 +1684,7 @@ const COMMANDS = {
 	plan: PlanCommand,
 	diff: DiffCommand,
 	pull: PullCommand,
+	push: PushCommand,
 	open: OpenCommand,
 	init: InitCommand,
 	login: LoginCommand,
@@ -1409,4 +1713,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,5 @@
-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-CEbWQPYe.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-DN4mH4jR.mjs";
+import { AssetUploadAdapter } from "./assetStorage.mjs";
 
 //#region src/embed.d.ts
 interface AssetConfig {
@@ -7,9 +8,15 @@ interface AssetConfig {
    * Receives a real File object (reconstructed from serialized data).
    * Throwing or rejecting will show an error toast in the embed.
    */
-  onUploadRequest: (file: File, context: {
+  onUploadRequest?: (file: File, context: {
     stateNodeId: string;
   }) => Promise<UploadResult>;
+  /**
+   * Storage adapter used by the embed upload bridge. This keeps the editor
+   * protocol storage-neutral while allowing integrations to plug in S3, R2,
+   * Supabase, or any other backing store.
+   */
+  adapter?: AssetUploadAdapter;
   /**
    * Accepted MIME types. Supports wildcards (e.g. 'image/*').
    * @default ['image/*']

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) {
@@ -43,6 +43,13 @@ function createStatelyEmbed(options) {
 	const pendingMessages = [];
 	const events = createEventRegistry();
 	const exportManager = createPendingExportManager((message) => send(message));
+	const assetUploadAdapter = options.assets?.adapter;
+	const uploadAsset = options.assets?.onUploadRequest ? (file, context) => options.assets.onUploadRequest(file, context) : assetUploadAdapter ? (file, context) => assetUploadAdapter.upload({
+		file,
+		...context
+	}) : void 0;
+	const assetAccept = options.assets?.accept ?? assetUploadAdapter?.accept;
+	const assetMaxFileSize = options.assets?.maxFileSize ?? assetUploadAdapter?.maxFileSize;
 	function send(msg) {
 		if (!transport?.ready) {
 			pendingMessages.push(msg);
@@ -63,11 +70,11 @@ function createStatelyEmbed(options) {
 			case "@statelyai.ready": {
 				const ready = data;
 				flush();
-				if (options.assets?.onUploadRequest) send({
+				if (uploadAsset) send({
 					type: "@statelyai.uploadCapabilities",
 					enabled: true,
-					accept: options.assets.accept,
-					maxFileSize: options.assets.maxFileSize
+					accept: assetAccept,
+					maxFileSize: assetMaxFileSize
 				});
 				options.onReady?.();
 				events.emit("ready", { version: ready.version });
@@ -129,7 +136,7 @@ function createStatelyEmbed(options) {
 			}
 			case "@statelyai.uploadRequest": {
 				const req = data;
-				if (!options.assets?.onUploadRequest) {
+				if (!uploadAsset) {
 					send({
 						type: "@statelyai.error",
 						requestId: req.requestId,
@@ -138,7 +145,7 @@ function createStatelyEmbed(options) {
 					});
 					break;
 				}
-				const maxSize = options.assets.maxFileSize ?? 10485760;
+				const maxSize = assetMaxFileSize ?? 10485760;
 				if (req.file.size > maxSize) {
 					send({
 						type: "@statelyai.error",
@@ -151,8 +158,7 @@ function createStatelyEmbed(options) {
 				const binary = atob(req.file.data);
 				const bytes = new Uint8Array(binary.length);
 				for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-				const file = new File([bytes], req.file.name, { type: req.file.mimeType });
-				options.assets.onUploadRequest(file, { stateNodeId: req.stateNodeId }).then((result) => {
+				uploadAsset(new File([bytes], req.file.name, { type: req.file.mimeType }), { stateNodeId: req.stateNodeId }).then((result) => {
 					send({
 						type: "@statelyai.uploadResponse",
 						requestId: req.requestId,

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-CB-ALrdk.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-DpBGHZwl.mjs";
 export { StatelyAction, StatelyActorImplementation, StatelyEdgeData, StatelyGraph, StatelyGraphData, StatelyGuard, StatelyImplementation, StatelyInvoke, StatelyNodeData, StatelyTagImplementation, StudioAction, StudioEdge, StudioEventTypeData, StudioMachine, StudioNode, fromStudioMachine, studioMachineConverter, toStudioMachine };

package/dist/graph.mjs

@@ -2,8 +2,12 @@ import { createFormatConverter, createGraph } from "@statelyai/graph";
 
 //#region src/graph.ts
 const EXPR_ACTION_TYPE = "xstate.expr";
+function stripMarkdownLinks(code) {
+	return code.replace(/\[([^\]\n]+)\]\(([^)\n]+)\)/g, "$1");
+}
 function stripExportDefault(code) {
-	return code.match(/^export\s+default\s+(.+)/s)?.[1]?.trim() ?? code.trim();
+	const normalized = stripMarkdownLinks(code).trim();
+	return normalized.match(/^export\s+default\s+(.+)/s)?.[1]?.trim() ?? normalized;
 }
 function toJsonObject(value) {
 	return value;
@@ -332,7 +336,7 @@ function fromStudioMachine(studioMachine) {
 			...edge.data.guard ? { guard: {
 				type: edge.data.guard.type,
 				params: toUnknownRecord(edge.data.guard.params),
-				...edge.data.guard.kind === "inline" ? { code: edge.data.guard.type } : {}
+				...edge.data.guard.kind === "inline" ? { code: stripExportDefault(studioMachine.implementations?.guards?.[edge.data.guard.type]?.code ?? edge.data.guard.type) } : {}
 			} } : {},
 			actions: edge.data.actions.map((action) => fromStudioAction(action, studioMachine.implementations?.actions)),
 			...edge.data.description ? { description: edge.data.description } : {},
@@ -350,9 +354,9 @@ function fromStudioMachine(studioMachine) {
 		data: {
 			...studioMachine.schemas ? { schemas: studioMachine.schemas } : {},
 			...studioMachine.implementations ? { implementations: {
-				actions: Object.values(studioMachine.implementations.actions).map(fromActionSource),
-				guards: Object.values(studioMachine.implementations.guards).map(fromGuardSource),
-				actors: Object.values(studioMachine.implementations.actors).map(fromActorSource),
+				actions: Object.entries(studioMachine.implementations.actions).filter(([key]) => !key.startsWith("inline:")).map(([, source]) => fromActionSource(source)),
+				guards: Object.entries(studioMachine.implementations.guards).filter(([key]) => !key.startsWith("inline:")).map(([, guard]) => fromGuardSource(guard)),
+				actors: Object.entries(studioMachine.implementations.actors).filter(([key]) => !key.startsWith("inline:") && !/:invocation\[\d+\]$/.test(key)).map(([, actor]) => fromActorSource(actor)),
 				delays: [],
 				tags: []
 			} } : {}