@statelyai/sdk 0.5.1 → 0.6.1

package/dist/embed.d.mts

@@ -1,4 +1,5 @@
-import { a as EmbedMode, c as ExportFormatMap, f as UploadResult, i as EmbedEventName, l as InitOptions, n as EmbedEventHandler, o as ExportCallOptions, r as EmbedEventMap, s as ExportFormat, t as CommentsConfig, u as MachineSourceLocations } from "./protocol-BPuwbNCz.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-CDoCcaIP.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/*']
@@ -21,10 +28,24 @@ interface AssetConfig {
    */
   maxFileSize?: number;
 }
-interface StatelyEmbedOptions {
+interface StatelyEmbedOptions extends Partial<MachineInitOptions> {
   baseUrl: string;
   apiKey?: string;
   origin?: string;
+  /**
+   * Optional iframe to attach to immediately. Equivalent to calling
+   * `embed.attach(iframe)` after construction.
+   */
+  iframe?: HTMLIFrameElement;
+  /**
+   * Project mode: pass machines instead of `machine`. If set, an init is
+   * auto-sent on attach using these machines.
+   */
+  machines?: ProjectEmbedMachine[];
+  /** Project mode only — initially selected machine id. */
+  currentMachineId?: string;
+  /** Project mode only — initial comments keyed by machine id. */
+  commentsByMachineId?: Record<string, CommentsConfig>;
   /** Asset upload configuration. If omitted, files are stored as base64 data URLs. */
   assets?: AssetConfig;
   onReady?: () => void;
@@ -45,6 +66,10 @@ interface StatelyEmbed {
   init(options: InitOptions): void;
   /** Update the machine (shorthand for update message). */
   updateMachine(machine: unknown, format?: string, sourceLocations?: MachineSourceLocations): void;
+  /** Update the project machine list without re-creating the iframe. */
+  updateProject(machines: ProjectEmbedMachine[], currentMachineId?: string, commentsByMachineId?: Record<string, CommentsConfig>): void;
+  /** Select the active machine in project mode. */
+  selectMachine(machineId: string): void;
   /** Change the embed mode. */
   setMode(mode: EmbedMode): void;
   /** Change the embed theme. */
@@ -64,4 +89,4 @@ interface StatelyEmbed {
 }
 declare function createStatelyEmbed(options: StatelyEmbedOptions): StatelyEmbed;
 //#endregion
-export { AssetConfig, type CommentsConfig, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type InitOptions, type MachineSourceLocations, StatelyEmbed, StatelyEmbedOptions, type UploadResult, createStatelyEmbed };
+export { AssetConfig, type CommentsConfig, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type InitOptions, type MachineInitOptions, type MachineSourceLocations, type ProjectEmbedMachine, StatelyEmbed, StatelyEmbedOptions, type UploadResult, createStatelyEmbed };

package/dist/embed.mjs

@@ -1,4 +1,4 @@
-import { a as toInitMessage, i as createPendingExportManager, r as createEventRegistry, t as createPostMessageTransport } from "./transport-DoCHBLTu.mjs";
+import { a as toInitMessage, i as createPendingExportManager, r as createEventRegistry, t as createPostMessageTransport } from "./transport-C0eTgNNu.mjs";
 
 //#region src/embed.ts
 function buildEmbedUrl(options) {
@@ -7,6 +7,32 @@ function buildEmbedUrl(options) {
 	if (options.apiKey) url.searchParams.set("api_key", options.apiKey);
 	return url.toString();
 }
+function extractInitOptions(options) {
+	if (options.machines) return {
+		machines: options.machines,
+		currentMachineId: options.currentMachineId,
+		mode: options.mode,
+		theme: options.theme,
+		readOnly: options.readOnly,
+		depth: options.depth,
+		panels: options.panels,
+		commentsByMachineId: options.commentsByMachineId,
+		unsavedIndicator: options.unsavedIndicator
+	};
+	if (options.machine !== void 0) return {
+		machine: options.machine,
+		format: options.format,
+		mode: options.mode,
+		theme: options.theme,
+		readOnly: options.readOnly,
+		depth: options.depth,
+		panels: options.panels,
+		comments: options.comments,
+		sourceLocations: options.sourceLocations,
+		unsavedIndicator: options.unsavedIndicator
+	};
+	return null;
+}
 function createStatelyEmbed(options) {
 	const embedUrl = buildEmbedUrl(options);
 	const targetOrigin = options.origin ?? "*";
@@ -17,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);
@@ -37,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 });
@@ -52,6 +85,7 @@ function createStatelyEmbed(options) {
 				options.onLoaded?.(loaded.graph);
 				events.emit("loaded", {
 					graph: loaded.graph,
+					machineId: loaded.machineId,
 					sourceLocations: loaded.sourceLocations
 				});
 				break;
@@ -62,6 +96,7 @@ function createStatelyEmbed(options) {
 				events.emit("change", {
 					graph: change.graph,
 					machineConfig: change.machineConfig,
+					machineId: change.machineId,
 					patches: change.patches,
 					sourceLocations: change.sourceLocations
 				});
@@ -73,12 +108,16 @@ function createStatelyEmbed(options) {
 				events.emit("save", {
 					graph: save.graph,
 					machineConfig: save.machineConfig,
+					machineId: save.machineId,
 					patches: save.patches,
 					validations: save.validations,
 					sourceLocations: save.sourceLocations
 				});
 				break;
 			}
+			case "@statelyai.project.machineSelected":
+				events.emit("machineSelected", { machineId: String(data.machineId) });
+				break;
 			case "@statelyai.retrieved": {
 				const retrieved = data;
 				exportManager.resolve(retrieved.requestId, retrieved.data);
@@ -97,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,
@@ -106,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",
@@ -119,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,
@@ -151,7 +189,7 @@ function createStatelyEmbed(options) {
 		nextTransport.onMessage(handleMessage);
 		nextTransport.onReady(flush);
 	}
-	return {
+	const embed = {
 		attach(el) {
 			if (destroyed) return;
 			const currentSrc = el.getAttribute("src");
@@ -190,6 +228,20 @@ function createStatelyEmbed(options) {
 				sourceLocations
 			});
 		},
+		updateProject(machines, currentMachineId, commentsByMachineId) {
+			send({
+				type: "@statelyai.project.update",
+				machines,
+				currentMachineId,
+				commentsByMachineId
+			});
+		},
+		selectMachine(machineId) {
+			send({
+				type: "@statelyai.project.selectMachine",
+				machineId
+			});
+		},
 		setMode(mode) {
 			send({
 				type: "@statelyai.setMode",
@@ -236,6 +288,10 @@ function createStatelyEmbed(options) {
 			iframe = null;
 		}
 	};
+	if (options.iframe) embed.attach(options.iframe);
+	const autoInit = extractInitOptions(options);
+	if (autoInit) embed.init(autoInit);
+	return embed;
 }
 
 //#endregion

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-BfezxFKJ.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,6 +2,13 @@ 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) {
+	const normalized = stripMarkdownLinks(code).trim();
+	return normalized.match(/^export\s+default\s+(.+)/s)?.[1]?.trim() ?? normalized;
+}
 function toJsonObject(value) {
 	return value;
 }
@@ -126,7 +133,7 @@ function toStudioAction(action) {
 		}
 	};
 }
-function fromStudioAction(action) {
+function fromStudioAction(action, actionImplementations) {
 	if (action.kind === "inline") return {
 		type: EXPR_ACTION_TYPE,
 		params: {
@@ -134,6 +141,16 @@ function fromStudioAction(action) {
 			lang: "ts"
 		}
 	};
+	if (action.action.type.startsWith("inline:") && actionImplementations?.[action.action.type]?.code) {
+		const implementation = actionImplementations[action.action.type];
+		return {
+			type: EXPR_ACTION_TYPE,
+			params: {
+				code: stripExportDefault(implementation.code),
+				lang: "ts"
+			}
+		};
+	}
 	if ("params" in action.action && action.action.params) return {
 		type: action.action.type,
 		params: toUnknownRecord(action.action.params)
@@ -204,7 +221,7 @@ function toStudioNode(graph, nodeId, pathIds, parentPath) {
 		nodes: childNodes
 	};
 }
-function flattenStudioNodes(studioNode, parentId, nodes, pathIdToNodeId) {
+function flattenStudioNodes(studioNode, parentId, nodes, pathIdToNodeId, actionImplementations) {
 	const nodeId = studioNode.id;
 	pathIdToNodeId.set(studioNode.id, nodeId);
 	const initialId = studioNode.data.initial ? `${studioNode.id}.${studioNode.data.initial}` : void 0;
@@ -227,8 +244,8 @@ function flattenStudioNodes(studioNode, parentId, nodes, pathIdToNodeId) {
 			...normalizeStudioNodeType(studioNode.data.type) ? { type: normalizeStudioNodeType(studioNode.data.type) } : {},
 			...studioNode.data.history ? { history: studioNode.data.history } : {},
 			...initialId ? { initialId } : {},
-			entry: studioNode.data.entry.map(fromStudioAction),
-			exit: studioNode.data.exit.map(fromStudioAction),
+			entry: studioNode.data.entry.map((action) => fromStudioAction(action, actionImplementations)),
+			exit: studioNode.data.exit.map((action) => fromStudioAction(action, actionImplementations)),
 			invokes: studioNode.data.invoke.map((invoke) => ({
 				src: invoke.src,
 				id: invoke.id,
@@ -240,7 +257,7 @@ function flattenStudioNodes(studioNode, parentId, nodes, pathIdToNodeId) {
 			...studioNode.data.metaEntries ? { meta: Object.fromEntries(studioNode.data.metaEntries) } : {}
 		}
 	});
-	studioNode.nodes.forEach((child) => flattenStudioNodes(child, nodeId, nodes, pathIdToNodeId));
+	studioNode.nodes.forEach((child) => flattenStudioNodes(child, nodeId, nodes, pathIdToNodeId, actionImplementations));
 }
 function toStudioMachine(graph) {
 	const rootNode = graph.nodes.find((node) => node.parentId == null);
@@ -298,7 +315,7 @@ function toStudioMachine(graph) {
 function fromStudioMachine(studioMachine) {
 	const nodes = [];
 	const pathIdToNodeId = /* @__PURE__ */ new Map();
-	flattenStudioNodes(studioMachine.rootNode, null, nodes, pathIdToNodeId);
+	flattenStudioNodes(studioMachine.rootNode, null, nodes, pathIdToNodeId, studioMachine.implementations?.actions);
 	const edges = studioMachine.edges.map((edge) => ({
 		type: "edge",
 		id: edge.id,
@@ -319,9 +336,9 @@ 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(fromStudioAction),
+			actions: edge.data.actions.map((action) => fromStudioAction(action, studioMachine.implementations?.actions)),
 			...edge.data.description ? { description: edge.data.description } : {},
 			...edge.data.color ? { color: edge.data.color } : {},
 			...edge.data.metaEntries ? { meta: Object.fromEntries(edge.data.metaEntries) } : {}
@@ -337,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: []
 			} } : {}

package/dist/{graphToXStateTS-CtecEESq.mjs → graphToXStateTS-Gzh0ZqbN.mjs}

@@ -1,4 +1,104 @@
-//#region src/serializeJS.ts
+import ts from "typescript";
+
+//#region src/statelyPragma.ts
+function findStatelyPragmaAttachments(sourceText, fileName = "machine.ts") {
+	const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(fileName));
+	const attachments = [];
+	const visit = (node) => {
+		if (ts.isCallExpression(node) && isCreateMachineExpression(node.expression)) {
+			const attachNode = findAttachNode(node);
+			if (attachNode) attachments.push({
+				machineStart: getMachineExpressionStart(node.expression, sourceFile),
+				attachStart: attachNode.getStart(sourceFile),
+				pragma: findAttachedStatelyPragma(sourceText, attachNode)
+			});
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return attachments;
+}
+function getStatelyPragma(sourceText, fileName = "machine.ts", machineIndex = 0) {
+	return findStatelyPragmaAttachments(sourceText, fileName)[machineIndex]?.pragma;
+}
+function upsertStatelyPragma(sourceText, id, options = {}) {
+	const attachment = findStatelyPragmaAttachments(sourceText, options.fileName ?? "machine.ts")[options.machineIndex ?? 0];
+	if (!attachment) return sourceText;
+	const lineEnding = options.lineEnding ?? detectLineEnding(sourceText);
+	const canonicalComment = `// @statelyai id=${id}`;
+	if (attachment.pragma) return sourceText.slice(0, attachment.pragma.start) + canonicalComment + sourceText.slice(attachment.pragma.end);
+	const insertText = `${getIndentationAtOffset(sourceText, attachment.attachStart)}${canonicalComment}${lineEnding}`;
+	return sourceText.slice(0, attachment.attachStart) + insertText + sourceText.slice(attachment.attachStart);
+}
+function findAttachedStatelyPragma(sourceText, node) {
+	const comments = ts.getLeadingCommentRanges(sourceText, node.getFullStart()) ?? [];
+	for (let index = comments.length - 1; index >= 0; index -= 1) {
+		const comment = comments[index];
+		const parsed = parseStatelyPragma(sourceText, comment.pos, comment.end);
+		if (parsed) return parsed;
+	}
+}
+function parseStatelyPragma(sourceText, start, end) {
+	const match = normalizeCommentContent(sourceText.slice(start, end)).match(/^@statelyai(?:\s+(.*))?$/s);
+	if (!match) return;
+	const fields = parseFields(match[1] ?? "");
+	return {
+		tag: "@statelyai",
+		id: fields.id,
+		fields,
+		start,
+		end
+	};
+}
+function normalizeCommentContent(rawComment) {
+	if (rawComment.startsWith("//")) return rawComment.slice(2).trim();
+	if (rawComment.startsWith("/*")) return rawComment.slice(2, rawComment.endsWith("*/") ? -2 : void 0).split(/\r?\n/).map((line) => line.replace(/^\s*\*\s?/, "")).join(" ").trim();
+	return rawComment.trim();
+}
+function parseFields(input) {
+	const fields = {};
+	for (const token of input.split(/\s+/)) {
+		if (!token) continue;
+		const equalsIndex = token.indexOf("=");
+		if (equalsIndex <= 0) continue;
+		const key = token.slice(0, equalsIndex);
+		const value = token.slice(equalsIndex + 1);
+		if (!key || !value) continue;
+		fields[key] = value;
+	}
+	return fields;
+}
+function findAttachNode(node) {
+	let current = node;
+	while (current?.parent) {
+		if (ts.isVariableStatement(current.parent) || ts.isExpressionStatement(current.parent) || ts.isExportAssignment(current.parent)) return current.parent;
+		current = current.parent;
+	}
+	return current;
+}
+function isCreateMachineExpression(expression) {
+	return ts.isIdentifier(expression) && expression.text === "createMachine" || ts.isPropertyAccessExpression(expression) && expression.name.text === "createMachine";
+}
+function getMachineExpressionStart(expression, sourceFile) {
+	if (ts.isPropertyAccessExpression(expression)) return expression.name.getStart(sourceFile);
+	return expression.getStart(sourceFile);
+}
+function getIndentationAtOffset(sourceText, offset) {
+	const lineStart = sourceText.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
+	return sourceText.slice(lineStart, offset).match(/^[ \t]*/)?.[0] ?? "";
+}
+function detectLineEnding(sourceText) {
+	return sourceText.includes("\r\n") ? "\r\n" : "\n";
+}
+function getScriptKind(fileName) {
+	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (fileName.endsWith(".js")) return ts.ScriptKind.JS;
+	return ts.ScriptKind.TS;
+}
+
+//#endregion
+//#region ../graph-tools/src/serializeJS.ts
 /**
 * Serializes JavaScript values as JS source code (not JSON).
 * - Unquoted keys for valid identifiers
@@ -67,33 +167,19 @@ function indentRawCode(code, indent) {
 }
 
 //#endregion
-//#region src/textUtils.ts
-/**
-* Pure string utilities used by codegen.
-*/
-/**
-* Removes common leading whitespace from all non-empty lines.
-*/
-function dedent(text) {
-	const lines = text.split("\n");
-	const nonEmptyLines = lines.filter((l) => l.trim().length > 0);
-	if (nonEmptyLines.length === 0) return text;
-	const minIndent = Math.min(...nonEmptyLines.map((l) => l.match(/^(\s*)/)[1].length));
-	if (minIndent === 0) return text;
-	return lines.map((l) => l.trim().length > 0 ? l.slice(minIndent) : l).join("\n");
-}
+//#region ../graph-tools/src/textUtils.ts
 /**
 * Strips `export default` wrapper from an expression string.
 * E.g. `"export default assign({ ... })"` → `"assign({ ... })"`
 */
-function stripExportDefault(code) {
+function stripExportDefault$1(code) {
 	const trimmed = code.trim();
 	if (trimmed.startsWith("export default ")) return trimmed.slice(15).replace(/;$/, "");
 	return trimmed;
 }
 
 //#endregion
-//#region src/graphToMachineConfig.ts
+//#region ../graph-tools/src/graphToMachineConfig.ts
 function isAutoGeneratedId(id) {
 	return !!id && id.startsWith("$auto-");
 }
@@ -217,7 +303,7 @@ function serializeActionItem(action) {
 			return raw(`assign({ ${entries.map(([k, v]) => `${JSON.stringify(k)}: ${formatAssignValue(v)}`).join(", ")} })`);
 		}
 		default:
-			if (exprCode) return raw(stripExportDefault(exprCode));
+			if (exprCode) return raw(stripExportDefault$1(exprCode));
 			if (!params || Object.keys(params).length === 0) return { type };
 			return {
 				type,
@@ -282,9 +368,9 @@ function graphToMachineConfig(graph, options = {}) {
 				const type = edge.data.eventType ?? "";
 				const transitionMeta = showMeta ? buildMeta(edge.data.meta, edge.data.color) : void 0;
 				const transitionObject = {
-					target: `${resolvedTarget}`,
+					target: edge.data.transitionType === "targetless" ? void 0 : `${resolvedTarget}`,
 					...edge.data.transitionType === "reenter" ? { reenter: true } : void 0,
-					guard: edge.data.guard ? edge.data.guard.code ? raw(stripExportDefault(edge.data.guard.code)) : edge.data.guard : void 0,
+					guard: edge.data.guard ? edge.data.guard.code ? raw(stripExportDefault$1(edge.data.guard.code)) : edge.data.guard : void 0,
 					actions: edge.data.actions?.length ? edge.data.actions.map(serializeActionItem) : void 0,
 					description: edge.data.description ?? void 0,
 					...transitionMeta ? { meta: transitionMeta } : void 0
@@ -420,12 +506,38 @@ function eventsSchemaToTSType(events) {
 	}).join("\n  | ");
 }
 
+//#endregion
+//#region src/textUtils.ts
+/**
+* Pure string utilities used by codegen.
+*/
+/**
+* Removes common leading whitespace from all non-empty lines.
+*/
+function dedent(text) {
+	const lines = text.split("\n");
+	const nonEmptyLines = lines.filter((l) => l.trim().length > 0);
+	if (nonEmptyLines.length === 0) return text;
+	const minIndent = Math.min(...nonEmptyLines.map((l) => l.match(/^(\s*)/)[1].length));
+	if (minIndent === 0) return text;
+	return lines.map((l) => l.trim().length > 0 ? l.slice(minIndent) : l).join("\n");
+}
+/**
+* Strips `export default` wrapper from an expression string.
+* E.g. `"export default assign({ ... })"` → `"assign({ ... })"`
+*/
+function stripExportDefault(code) {
+	const trimmed = code.trim();
+	if (trimmed.startsWith("export default ")) return trimmed.slice(15).replace(/;$/, "");
+	return trimmed;
+}
+
 //#endregion
 //#region src/graphToXStateTS.ts
 function graphToXStateTS(graph, options = {}) {
 	const { exportStyle = "named", ...configOptions } = options;
 	const schemas = graph.data.schemas;
-	const impls = graph.data.implementations;
+	const impls = filterInlineImplementations(graph.data.implementations);
 	const hasSchemas = !!(schemas && (schemas.context || schemas.events || schemas.input || schemas.output));
 	const hasActions = !!impls?.actions.length;
 	const hasGuards = !!impls?.guards.length;
@@ -459,6 +571,15 @@ function graphToXStateTS(graph, options = {}) {
 	}
 	return lines.join("\n") + "\n";
 }
+function filterInlineImplementations(impls) {
+	if (!impls) return impls;
+	return {
+		...impls,
+		actions: impls.actions.filter((action) => !action.name.startsWith("inline:")),
+		guards: impls.guards.filter((guard) => !guard.name.startsWith("inline:")),
+		delays: impls.delays.filter((delay) => !delay.name.startsWith("inline:"))
+	};
+}
 /** Map from xstate action type to the import name */
 const BUILTIN_ACTION_IMPORTS = {
 	"xstate.raise": "raise",
@@ -536,6 +657,11 @@ function hasSchemaProperties(schema) {
 function buildActionsBlock(actions) {
 	const block = {};
 	for (const implementation of actions) if (implementation.code?.body) {
+		const exportedExpression = getExportDefaultExpression(implementation.code.body);
+		if (exportedExpression) {
+			block[implementation.name] = raw(exportedExpression);
+			continue;
+		}
 		const params = hasSchemaProperties(implementation.paramsSchema) ? `, params: ${jsonSchemaToTSType(implementation.paramsSchema)}` : "";
 		block[implementation.name] = raw(`function ({ context, event }${params ? params : ""}) {\n  ${dedent(implementation.code.body)}\n}`);
 	} else block[implementation.name] = raw(`function ({ context, event }) {\n  // TODO: implement ${implementation.name}\n}`);
@@ -544,6 +670,11 @@ function buildActionsBlock(actions) {
 function buildGuardsBlock(guards) {
 	const block = {};
 	for (const guard of guards) if (guard.code?.body) {
+		const exportedExpression = getExportDefaultExpression(guard.code.body);
+		if (exportedExpression) {
+			block[guard.name] = raw(exportedExpression);
+			continue;
+		}
 		const params = hasSchemaProperties(guard.paramsSchema) ? `, params: ${jsonSchemaToTSType(guard.paramsSchema)}` : "";
 		block[guard.name] = raw(`function ({ context, event }${params ? params : ""}) {\n  ${dedent(guard.code.body)}\n}`);
 	} else block[guard.name] = raw(`function ({ context, event }) {\n  // TODO: implement ${guard.name}\n  return false;\n}`);
@@ -559,10 +690,20 @@ function buildActorsBlock(actors) {
 }
 function buildDelaysBlock(delays) {
 	const block = {};
-	for (const delay of delays) if (delay.code?.body) block[delay.name] = raw(`function ({ context, event }) {\n  ${dedent(delay.code.body)}\n}`);
-	else block[delay.name] = raw(`function () {\n  // TODO: implement ${delay.name}\n  return 1000;\n}`);
+	for (const delay of delays) if (delay.code?.body) {
+		const exportedExpression = getExportDefaultExpression(delay.code.body);
+		if (exportedExpression) {
+			block[delay.name] = raw(exportedExpression);
+			continue;
+		}
+		block[delay.name] = raw(`function ({ context, event }) {\n  ${dedent(delay.code.body)}\n}`);
+	} else block[delay.name] = raw(`function () {\n  // TODO: implement ${delay.name}\n  return 1000;\n}`);
 	return block;
 }
+function getExportDefaultExpression(code) {
+	const stripped = stripExportDefault(code);
+	return stripped === code.trim() ? void 0 : stripped;
+}
 
 //#endregion
-export { graphToMachineConfig as a, serializeJS as c, jsonSchemaToTSType as i, contextSchemaToTSType as n, RawCode as o, eventsSchemaToTSType as r, raw as s, graphToXStateTS as t };
+export { graphToMachineConfig as a, serializeJS as c, upsertStatelyPragma as d, jsonSchemaToTSType as i, findStatelyPragmaAttachments as l, contextSchemaToTSType as n, RawCode as o, eventsSchemaToTSType as r, raw as s, graphToXStateTS as t, getStatelyPragma as u };