@statelyai/sdk 0.3.1 → 0.4.1

package/dist/graphToXStateTS-Cfp_fxSH.mjs

@@ -0,0 +1,530 @@
+//#region src/serializeJS.ts
+/**
+* Serializes JavaScript values as JS source code (not JSON).
+* - Unquoted keys for valid identifiers
+* - Single-quoted strings
+* - Omits undefined values
+* - Supports RawCode for verbatim expressions
+*/
+const VALID_IDENT = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+var RawCode = class {
+	constructor(code) {
+		this.code = code;
+	}
+};
+function raw(code) {
+	return new RawCode(code);
+}
+function serializeJS(value, indent = 0, step = 2) {
+	if (value instanceof RawCode) return value.code;
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (typeof value === "string") return `'${escapeString(value)}'`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return serializeArray(value, indent, step);
+	if (typeof value === "object") return serializeObject(value, indent, step);
+	return String(value);
+}
+function escapeString(s) {
+	return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function serializeArray(arr, indent, step) {
+	const filtered = arr.filter((v) => v !== void 0);
+	if (filtered.length === 0) return "[]";
+	const inner = indent + step;
+	const pad = " ".repeat(inner);
+	const closePad = " ".repeat(indent);
+	return `[\n${filtered.map((v) => `${pad}${serializeJS(v, inner, step)}`).join(",\n")},\n${closePad}]`;
+}
+function serializeObject(obj, indent, step) {
+	const entries = Object.entries(obj).filter(([, v]) => v !== void 0);
+	if (entries.length === 0) return "{}";
+	const inner = indent + step;
+	const pad = " ".repeat(inner);
+	const closePad = " ".repeat(indent);
+	return `{\n${entries.map(([key, val]) => {
+		const k = VALID_IDENT.test(key) ? key : `'${escapeString(key)}'`;
+		const serialized = serializeJS(val, inner, step);
+		if (val instanceof RawCode && serialized.includes("\n")) return `${pad}${k}: ${indentRawCode(serialized, inner)}`;
+		return `${pad}${k}: ${serialized}`;
+	}).join(",\n")},\n${closePad}}`;
+}
+function indentRawCode(code, indent) {
+	const lines = code.split("\n");
+	if (lines.length <= 1) return code;
+	const pad = " ".repeat(indent);
+	return [lines[0], ...lines.slice(1).map((line) => line.trim() === "" ? "" : `${pad}${line}`)].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/graphToMachineConfig.ts
+function getNodePath(graph, node) {
+	const path = [];
+	let currentNode = node;
+	while (currentNode) {
+		path.unshift(currentNode.data.key);
+		currentNode = graph.nodes.find((n) => n.id === currentNode.parentId);
+	}
+	return path;
+}
+/** Unwrap single-element arrays to a single value (XState single-or-array convention) */
+function singleOrArray(arr) {
+	return arr.length === 1 ? arr[0] : arr;
+}
+/** Unwrap each value in a record of arrays */
+function singleOrArrayRecord(record) {
+	const result = {};
+	for (const [key, arr] of Object.entries(record)) result[key] = singleOrArray(arr);
+	return result;
+}
+/**
+* Remove empty arrays/objects/strings, unwrap single-element arrays.
+* Matches studio's simplifyAttributes behavior.
+*/
+function simplifyAttributes(obj) {
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		if (value === void 0 || value === null) delete obj[key];
+		else if (Array.isArray(value)) {
+			if (value.length === 0) delete obj[key];
+			else if (value.length === 1) obj[key] = value[0];
+		} else if (typeof value === "object" && Object.keys(value).length === 0) delete obj[key];
+		else if (typeof value === "string" && value === "") delete obj[key];
+	}
+	return obj;
+}
+/**
+* Recursively apply simplifyAttributes to a config tree.
+* Cleans up the config and all nested state nodes, transitions, and invokes.
+*/
+function deepSimplify(config) {
+	for (const mapKey of ["on", "after"]) {
+		const map = config[mapKey];
+		if (map && typeof map === "object" && !Array.isArray(map)) {
+			for (const [, val] of Object.entries(map)) if (val && typeof val === "object" && !Array.isArray(val)) simplifyAttributes(val);
+			else if (Array.isArray(val)) {
+				for (const item of val) if (item && typeof item === "object") simplifyAttributes(item);
+			}
+		}
+	}
+	for (const key of ["always", "onDone"]) {
+		const val = config[key];
+		if (val && typeof val === "object" && !Array.isArray(val)) simplifyAttributes(val);
+		else if (Array.isArray(val)) {
+			for (const item of val) if (item && typeof item === "object") simplifyAttributes(item);
+		}
+	}
+	const invoke = config.invoke;
+	if (invoke && typeof invoke === "object" && !Array.isArray(invoke)) simplifyAttributes(invoke);
+	else if (Array.isArray(invoke)) {
+		for (const item of invoke) if (item && typeof item === "object") simplifyAttributes(item);
+	}
+	simplifyAttributes(config);
+	if (config.states && typeof config.states === "object") for (const stateConfig of Object.values(config.states)) deepSimplify(stateConfig);
+	return config;
+}
+function buildMeta(meta, color) {
+	const result = {};
+	if (meta) {
+		for (const [k, v] of Object.entries(meta)) if (v !== void 0 && v !== null) result[k] = v;
+	}
+	if (color) result["@statelyai.color"] = color;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/** Format event param — supports { type: string } (new) and plain string (legacy) */
+function formatEventParam(event) {
+	if (event && typeof event === "object" && "type" in event) return `{ type: '${event.type}' }`;
+	if (typeof event === "string") return `{ type: '${event}' }`;
+	return "{ type: \"unknown\" }";
+}
+/**
+* Converts a built-in xstate ActionItem to a raw function call expression,
+* or returns a plain { type, params } object for user-defined actions.
+*/
+function serializeActionItem(action) {
+	const { type, params } = action;
+	switch (type) {
+		case "xstate.raise": {
+			const eventStr = formatEventParam(params?.event);
+			const opts = [];
+			if (params?.id) opts.push(`id: '${params.id}'`);
+			if (params?.delay != null) opts.push(`delay: ${JSON.stringify(params.delay)}`);
+			return raw(`raise(${eventStr}${opts.length > 0 ? `, { ${opts.join(", ")} }` : ""})`);
+		}
+		case "xstate.sendTo": {
+			const to = params?.to ? `'${params.to}'` : `'unknown'`;
+			const eventStr = formatEventParam(params?.event);
+			const opts = [];
+			if (params?.id) opts.push(`id: '${params.id}'`);
+			if (params?.delay != null) opts.push(`delay: ${JSON.stringify(params.delay)}`);
+			return raw(`sendTo(${to}, ${eventStr}${opts.length > 0 ? `, { ${opts.join(", ")} }` : ""})`);
+		}
+		case "xstate.cancel": return raw(`cancel(${params?.sendId ? `'${params.sendId}'` : `'unknown'`})`);
+		case "xstate.emit": return raw(`emit(${formatEventParam(params?.event)})`);
+		case "xstate.spawnChild": {
+			const src = params?.src ? `'${params.src}'` : `'unknown'`;
+			const opts = [];
+			if (params?.id) opts.push(`id: '${params.id}'`);
+			if (params?.systemId) opts.push(`systemId: '${params.systemId}'`);
+			return raw(`spawnChild(${src}${opts.length > 0 ? `, { ${opts.join(", ")} }` : ""})`);
+		}
+		case "xstate.stopChild": return raw(`stopChild(${params?.actorRef ? `'${params.actorRef}'` : `'unknown'`})`);
+		case "xstate.log": return raw(`log(${(params?.label ? `'${params.label}'` : void 0) ?? ""})`);
+		case "xstate.assign": return raw(`assign({ /* ... */ })`);
+		default:
+			if (action.code) return raw(stripExportDefault(action.code));
+			if (!params || Object.keys(params).length === 0) return { type };
+			return {
+				type,
+				params
+			};
+	}
+}
+/** Normalize tag to string — handles both `string` and `{ name: string }` */
+function tagToString(tag) {
+	return typeof tag === "string" ? tag : tag.name;
+}
+function graphToMachineConfig(graph, options = {}) {
+	const { showDescriptions = true, showMeta = true } = options;
+	const config = {};
+	function getNodeConfig(node) {
+		const nodeConfig = node.parentId ? {} : config;
+		const nodePath = getNodePath(graph, node);
+		const resolvedNodeId = !node.parentId ? node.id : nodePath.join(".") === node.id ? void 0 : node.id;
+		const initialNode = node.data.initialId ? graph.nodes.find((n) => n.id === node.data.initialId) : null;
+		const nodeType = [
+			"final",
+			"history",
+			"parallel"
+		].includes(node.data.type) ? node.data.type : void 0;
+		const tags = node.data.tags;
+		Object.assign(nodeConfig, {
+			id: resolvedNodeId,
+			type: nodeType === "normal" ? void 0 : nodeType ?? void 0,
+			initial: initialNode?.data.key,
+			...node.data.entry?.length ? { entry: node.data.entry.map(serializeActionItem) } : void 0,
+			...node.data.exit?.length ? { exit: node.data.exit.map(serializeActionItem) } : void 0,
+			...node.data.invokes?.length ? { invoke: node.data.invokes.map((inv) => ({
+				src: inv.src,
+				id: inv.id,
+				...inv.input ? { input: inv.input } : void 0
+			})) } : void 0,
+			...tags?.length ? { tags: tags.map(tagToString) } : void 0,
+			...showDescriptions && node.data.description ? { description: node.data.description } : void 0,
+			...showMeta && node.data.meta && Object.keys(node.data.meta).length > 0 ? { meta: node.data.meta } : void 0,
+			...node.data.history ? { history: node.data.history } : void 0
+		});
+		const childNodes = graph.nodes.filter((n) => n.parentId === node.id && !n.data.temp);
+		const edges = graph.edges.filter((edge) => edge.sourceId === node.id && !edge.data.temp);
+		if (edges.length > 0) {
+			const on = {};
+			const after = {};
+			const alwaysArr = [];
+			const onDone = {};
+			const invokeMap = {};
+			for (const edge of edges) {
+				const targetNode = graph.nodes.find((n) => n.id === edge.targetId);
+				const resolvedTarget = targetNode ? targetNode.parentId === node.parentId ? targetNode.data.key : `#${targetNode.id}` : "";
+				const type = edge.data.eventType ?? "";
+				const transitionMeta = showMeta ? buildMeta(edge.data.meta, edge.data.color) : void 0;
+				const transitionObject = {
+					target: `${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,
+					actions: edge.data.actions?.length ? edge.data.actions.map(serializeActionItem) : void 0,
+					description: edge.data.description ?? void 0,
+					...transitionMeta ? { meta: transitionMeta } : void 0
+				};
+				if (type === "") alwaysArr.push(transitionObject);
+				else if (type.startsWith("xstate.after.")) {
+					const delayKey = type.slice(13).split(".")[0];
+					if (!after[delayKey]) after[delayKey] = [];
+					after[delayKey].push(transitionObject);
+				} else if (type === "*") {
+					if (!on["*"]) on["*"] = [];
+					on["*"].push(transitionObject);
+				} else if (type.startsWith("xstate.done.state")) {
+					if (!onDone[type]) onDone[type] = [];
+					onDone[type].push(transitionObject);
+				} else if (type.startsWith("xstate.done.actor.")) {
+					const actorId = type.slice(18);
+					invokeMap[actorId] = {
+						...invokeMap[actorId],
+						onDone: (invokeMap[actorId]?.onDone ?? []).concat(transitionObject)
+					};
+				} else if (type.startsWith("xstate.error.actor.")) {
+					const actorId = type.slice(19);
+					invokeMap[actorId] = {
+						...invokeMap[actorId],
+						onError: (invokeMap[actorId]?.onError ?? []).concat(transitionObject)
+					};
+				} else {
+					if (!on[type]) on[type] = [];
+					on[type].push(transitionObject);
+				}
+			}
+			if (Object.keys(on).length > 0) nodeConfig.on = singleOrArrayRecord(on);
+			if (Object.keys(after).length > 0) nodeConfig.after = singleOrArrayRecord(after);
+			if (alwaysArr.length > 0) nodeConfig.always = singleOrArray(alwaysArr);
+			if (Object.keys(onDone).length > 0) nodeConfig.onDone = singleOrArray(Object.values(onDone).flat());
+			if (Object.keys(invokeMap).length > 0 && Array.isArray(nodeConfig.invoke)) nodeConfig.invoke = nodeConfig.invoke.map((inv) => {
+				const mapped = invokeMap[inv.id];
+				if (!mapped) return inv;
+				return {
+					...inv,
+					...mapped.onDone ? { onDone: singleOrArray(mapped.onDone) } : void 0,
+					...mapped.onError ? { onError: singleOrArray(mapped.onError) } : void 0
+				};
+			});
+		}
+		if (childNodes.length > 0) {
+			nodeConfig.states = {};
+			for (const childState of childNodes) nodeConfig.states[childState.data.key] = getNodeConfig(childState);
+		}
+		return nodeConfig;
+	}
+	const rootNode = graph.nodes.find((node) => node.data.parentId === null || node.parentId == null);
+	if (!rootNode) throw new Error("No root node found");
+	getNodeConfig(rootNode);
+	return deepSimplify(config);
+}
+
+//#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/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 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);
+		if (action.code) scanInlineCodeForBuiltins(action.code, 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);
+		if (action.code) scanInlineCodeForBuiltins(action.code, 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 action of actions) if (action.code?.body) {
+		const params = hasSchemaProperties(action.paramsSchema) ? `, params: ${jsonSchemaToTSType(action.paramsSchema)}` : "";
+		block[action.name] = raw(`function ({ context, event }${params ? params : ""}) {\n  ${dedent(action.code.body)}\n}`);
+	} else block[action.name] = raw(`function ({ context, event }) {\n  // TODO: implement ${action.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 { graphToMachineConfig as a, serializeJS as c, jsonSchemaToTSType as i, contextSchemaToTSType as n, RawCode as o, eventsSchemaToTSType as r, raw as s, graphToXStateTS as t };