@statelyai/sdk 0.5.1 → 0.6.0

package/dist/embed.d.mts

@@ -1,4 +1,4 @@
-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-CEbWQPYe.mjs";
 
 //#region src/embed.d.ts
 interface AssetConfig {
@@ -21,10 +21,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 +59,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 +82,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 ?? "*";
@@ -52,6 +78,7 @@ function createStatelyEmbed(options) {
 				options.onLoaded?.(loaded.graph);
 				events.emit("loaded", {
 					graph: loaded.graph,
+					machineId: loaded.machineId,
 					sourceLocations: loaded.sourceLocations
 				});
 				break;
@@ -62,6 +89,7 @@ function createStatelyEmbed(options) {
 				events.emit("change", {
 					graph: change.graph,
 					machineConfig: change.machineConfig,
+					machineId: change.machineId,
 					patches: change.patches,
 					sourceLocations: change.sourceLocations
 				});
@@ -73,12 +101,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);
@@ -151,7 +183,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 +222,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 +282,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-CB-ALrdk.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,9 @@ import { createFormatConverter, createGraph } from "@statelyai/graph";
 
 //#region src/graph.ts
 const EXPR_ACTION_TYPE = "xstate.expr";
+function stripExportDefault(code) {
+	return code.match(/^export\s+default\s+(.+)/s)?.[1]?.trim() ?? code.trim();
+}
 function toJsonObject(value) {
 	return value;
 }
@@ -126,7 +129,7 @@ function toStudioAction(action) {
 		}
 	};
 }
-function fromStudioAction(action) {
+function fromStudioAction(action, actionImplementations) {
 	if (action.kind === "inline") return {
 		type: EXPR_ACTION_TYPE,
 		params: {
@@ -134,6 +137,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 +217,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 +240,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 +253,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 +311,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,
@@ -321,7 +334,7 @@ function fromStudioMachine(studioMachine) {
 				params: toUnknownRecord(edge.data.guard.params),
 				...edge.data.guard.kind === "inline" ? { 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) } : {}

package/dist/graphToXStateTS-CvXM8wHL.mjs

@@ -0,0 +1,344 @@
+import ts from "typescript";
+import { RawCode, graphToMachineConfig, raw, serializeJS } from "@statelyai/graph-tools";
+
+//#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 src/jsonSchemaToTSType.ts
+function jsonSchemaToTSType(schema) {
+	if (!schema) return "unknown";
+	if (schema.enum) return schema.enum.map((v) => typeof v === "string" ? `'${v}'` : String(v)).join(" | ");
+	if (schema.const !== void 0) return typeof schema.const === "string" ? `'${schema.const}'` : String(schema.const);
+	if (schema.oneOf) return schema.oneOf.map((s) => jsonSchemaToTSType(resolveDef(s))).join(" | ");
+	if (schema.anyOf) return schema.anyOf.map((s) => jsonSchemaToTSType(resolveDef(s))).join(" | ");
+	if (schema.allOf) return schema.allOf.map((s) => jsonSchemaToTSType(resolveDef(s))).join(" & ");
+	if (schema.type === "array") return `Array<${jsonSchemaToTSType(resolveDef(schema.items))}>`;
+	if (Array.isArray(schema.type)) return schema.type.map((t) => primitiveType(t)).join(" | ");
+	if (schema.type === "object" || schema.properties) return objectType(schema);
+	if (schema.type) return primitiveType(schema.type);
+	return "unknown";
+}
+function primitiveType(type) {
+	switch (type) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		default: return "unknown";
+	}
+}
+function objectType(schema) {
+	const props = schema.properties;
+	if (!props || Object.keys(props).length === 0) {
+		if (schema.additionalProperties) return `Record<string, ${jsonSchemaToTSType(resolveDef(schema.additionalProperties))}>`;
+		return "Record<string, unknown>";
+	}
+	const required = new Set(schema.required ?? []);
+	return `{ ${Object.entries(props).map(([key, def]) => {
+		const type = jsonSchemaToTSType(resolveDef(def));
+		return `${key}${required.has(key) ? "" : "?"}: ${type}`;
+	}).join("; ")} }`;
+}
+function resolveDef(def) {
+	if (!def) return void 0;
+	if (Array.isArray(def)) return resolveDef(def[0]);
+	if (typeof def === "boolean") return void 0;
+	return def;
+}
+/**
+* Build an inline context type string from the schemas.context record.
+* Each key is a context property name, value is its JSONSchema7.
+*/
+function contextSchemaToTSType(context) {
+	if (!context || Object.keys(context).length === 0) return null;
+	return `{ ${Object.entries(context).map(([key, schema]) => {
+		return `${key}: ${jsonSchemaToTSType(schema)}`;
+	}).join("; ")} }`;
+}
+/**
+* Build an event union type from the schemas.events record.
+* Each key is the event type name, value describes the payload properties.
+*/
+function eventsSchemaToTSType(events) {
+	if (!events || Object.keys(events).length === 0) return null;
+	return Object.entries(events).map(([eventType, schema]) => {
+		const props = schema.properties;
+		if (!props || Object.keys(props).length === 0) return `{ type: '${eventType}' }`;
+		const required = new Set(schema.required ?? []);
+		const extraProps = Object.entries(props).filter(([k]) => k !== "type").map(([key, def]) => {
+			const type = jsonSchemaToTSType(resolveDef(def));
+			return `${key}${required.has(key) ? "" : "?"}: ${type}`;
+		});
+		if (extraProps.length === 0) return `{ type: '${eventType}' }`;
+		return `{ type: '${eventType}'; ${extraProps.join("; ")} }`;
+	}).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 hasSchemas = !!(schemas && (schemas.context || schemas.events || schemas.input || schemas.output));
+	const hasActions = !!impls?.actions.length;
+	const hasGuards = !!impls?.guards.length;
+	const hasActors = !!impls?.actors.length;
+	const hasDelays = !!impls?.delays.length;
+	const hasSetup = hasSchemas || hasActions || hasGuards || hasActors || hasDelays;
+	const builtInActions = getUsedBuiltInActions(graph);
+	const imports = buildImports({
+		hasSetup,
+		hasActors,
+		actors: impls?.actors ?? [],
+		builtInActions
+	});
+	const machineConfig = graphToMachineConfig(graph, configOptions);
+	let machineExpr;
+	if (hasSetup) {
+		const setupObj = buildSetupObject(schemas, impls);
+		const configStr = serializeJS(machineConfig, 2);
+		machineExpr = `setup(${serializeJS(setupObj, 0)}).createMachine(${configStr})`;
+	} else machineExpr = `createMachine(${serializeJS(machineConfig, 0)})`;
+	const lines = [];
+	lines.push(imports);
+	lines.push("");
+	lines.push(`const machine = ${machineExpr};`);
+	if (exportStyle === "named") {
+		lines.push("");
+		lines.push("export { machine };");
+	} else if (exportStyle === "default") {
+		lines.push("");
+		lines.push("export default machine;");
+	}
+	return lines.join("\n") + "\n";
+}
+/** Map from xstate action type to the import name */
+const BUILTIN_ACTION_IMPORTS = {
+	"xstate.raise": "raise",
+	"xstate.sendTo": "sendTo",
+	"xstate.cancel": "cancel",
+	"xstate.emit": "emit",
+	"xstate.spawnChild": "spawnChild",
+	"xstate.stopChild": "stopChild",
+	"xstate.log": "log",
+	"xstate.assign": "assign"
+};
+/** Check inline action/entry/exit code for references to xstate builtins */
+function scanInlineCodeForBuiltins(code, used) {
+	const expr = stripExportDefault(code);
+	for (const importName of Object.values(BUILTIN_ACTION_IMPORTS)) if (new RegExp(`\\b${importName}\\b`).test(expr)) used.add(importName);
+}
+function getExprActionCode(action) {
+	return action.type === "xstate.expr" && typeof action.params?.code === "string" ? action.params.code : void 0;
+}
+function getUsedBuiltInActions(graph) {
+	const used = /* @__PURE__ */ new Set();
+	for (const node of graph.nodes) for (const action of [...node.data.entry ?? [], ...node.data.exit ?? []]) {
+		const imp = BUILTIN_ACTION_IMPORTS[action.type];
+		if (imp) used.add(imp);
+		const exprCode = getExprActionCode(action);
+		if (exprCode) scanInlineCodeForBuiltins(exprCode, used);
+	}
+	for (const edge of graph.edges) for (const action of edge.data.actions ?? []) {
+		const imp = BUILTIN_ACTION_IMPORTS[action.type];
+		if (imp) used.add(imp);
+		const exprCode = getExprActionCode(action);
+		if (exprCode) scanInlineCodeForBuiltins(exprCode, used);
+	}
+	return used;
+}
+function buildImports({ hasSetup, hasActors, actors, builtInActions }) {
+	const xstateImports = [];
+	if (hasSetup) xstateImports.push("setup");
+	else xstateImports.push("createMachine");
+	for (const name of builtInActions) xstateImports.push(name);
+	if (hasActors) {
+		if (actors.some((a) => a.code?.body)) xstateImports.push("fromPromise");
+	}
+	return `import { ${xstateImports.join(", ")} } from 'xstate';`;
+}
+function buildSetupObject(schemas, impls) {
+	const setup = {};
+	const types = buildTypesBlock(schemas);
+	if (types) setup.types = types;
+	if (impls?.actions.length) setup.actions = buildActionsBlock(impls.actions);
+	if (impls?.guards.length) setup.guards = buildGuardsBlock(impls.guards);
+	if (impls?.actors.length) setup.actors = buildActorsBlock(impls.actors);
+	if (impls?.delays.length) setup.delays = buildDelaysBlock(impls.delays);
+	return setup;
+}
+function buildTypesBlock(schemas) {
+	if (!schemas) return void 0;
+	const types = {};
+	const contextType = contextSchemaToTSType(schemas.context);
+	if (contextType) types.context = raw(`{} as ${contextType}`);
+	const eventsType = eventsSchemaToTSType(schemas.events);
+	if (eventsType) types.events = raw(`{} as\n    | ${eventsType}`);
+	if (schemas.input) types.input = raw(`{} as ${jsonSchemaToTSType(schemas.input)}`);
+	if (schemas.output) types.output = raw(`{} as ${jsonSchemaToTSType(schemas.output)}`);
+	return Object.keys(types).length > 0 ? types : void 0;
+}
+function hasSchemaProperties(schema) {
+	if (!schema) return false;
+	if (schema.type === "object" || schema.properties) {
+		const props = schema.properties;
+		return !!props && Object.keys(props).length > 0;
+	}
+	return true;
+}
+function buildActionsBlock(actions) {
+	const block = {};
+	for (const implementation of actions) if (implementation.code?.body) {
+		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}`);
+	return block;
+}
+function buildGuardsBlock(guards) {
+	const block = {};
+	for (const guard of guards) if (guard.code?.body) {
+		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}`);
+	return block;
+}
+function buildActorsBlock(actors) {
+	const block = {};
+	for (const actor of actors) if (actor.code?.body) {
+		const inputType = hasSchemaProperties(actor.inputSchema) ? `: ${jsonSchemaToTSType(actor.inputSchema)}` : "";
+		block[actor.name] = raw(`fromPromise(async ({ input }${inputType ? `: { input${inputType} }` : ""}) => {\n  ${dedent(actor.code.body)}\n})`);
+	} else block[actor.name] = raw(`fromPromise(async ({ input }) => {\n  // TODO: implement ${actor.name}\n})`);
+	return block;
+}
+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}`);
+	return block;
+}
+
+//#endregion
+export { RawCode as a, graphToMachineConfig as c, upsertStatelyPragma as d, jsonSchemaToTSType as i, findStatelyPragmaAttachments as l, contextSchemaToTSType as n, raw as o, eventsSchemaToTSType as r, serializeJS as s, graphToXStateTS as t, getStatelyPragma as u };