@statelyai/sdk 0.6.0 → 0.6.1

package/dist/index.d.mts

@@ -1,13 +1,14 @@
 import { StatelyApiClientOptions, StatelyApiError, StatelyApiUrlOptions, createStatelyApiClient, createStatelyApiUrl } from "./api.mjs";
+import { a as EmbedMode, c as ExportFormatMap, f as ProjectEmbedMachine, i as EmbedEventName, l as InitOptions, m as UploadResult, n as EmbedEventHandler, o as ExportCallOptions, r as EmbedEventMap, s as ExportFormat, t as CommentsConfig } from "./protocol-CDoCcaIP.mjs";
+import { AssetUploadAdapter, AssetUploadContext, AssetUploadRequest, CreateS3AssetUploadAdapterOptions, CreateSupabaseAssetUploadAdapterOptions, S3UploadTarget, SupabaseStorageClient, createS3AssetUploadAdapter, createSupabaseAssetUploadAdapter } from "./assetStorage.mjs";
 import { ConnectedRepo, CreateMachineFromDefinitionInput, CreateMachineFromTemplateInput, CreateMachineInput, CreateMachineTemplate, CreateProjectInput, EnsureProjectInput, ExtractMachinesResponse, ExtractedMachine, GetMachineOptions, ProjectData, ProjectMachine, ProjectVisibility, RepoType, StudioApiError, StudioClient, StudioClientOptions, StudioMachineRecord, VerifyApiKeyResponse, XStateVersion, createStatelyClient } from "./studio.mjs";
-import { C as EventTypeData, S as DigraphNodeConfig, _ as studioMachineConverter, a as StatelyGraphData, b as DigraphConfig, c as StatelyInvoke, d as StudioAction, f as StudioEdge, g as fromStudioMachine, h as StudioNode, i as StatelyGraph, l as StatelyNodeData, m as StudioMachine, o as StatelyGuard, r as StatelyEdgeData, t as StatelyAction, v as toStudioMachine, w as StateNodeJSONData, x as DigraphEdgeConfig, y as DigraphAction } from "./graph-CB-ALrdk.mjs";
+import { C as EventTypeData, S as DigraphNodeConfig, _ as studioMachineConverter, a as StatelyGraphData, b as DigraphConfig, c as StatelyInvoke, d as StudioAction, f as StudioEdge, g as fromStudioMachine, h as StudioNode, i as StatelyGraph, l as StatelyNodeData, m as StudioMachine, o as StatelyGuard, r as StatelyEdgeData, t as StatelyAction, v as toStudioMachine, w as StateNodeJSONData, x as DigraphEdgeConfig, y as DigraphAction } from "./graph-DpBGHZwl.mjs";
 import { PlanSyncOptions, PullSyncResult, PushSyncOptions, PushSyncProjectOptions, PushSyncResult, ResolvedSyncInput, SyncInputFormat, SyncPlan, SyncPlanSummary } from "./sync.mjs";
-import { a as EmbedMode, c as ExportFormatMap, f as ProjectEmbedMachine, i as EmbedEventName, l as InitOptions, m as UploadResult, n as EmbedEventHandler, o as ExportCallOptions, r as EmbedEventMap, s as ExportFormat, t as CommentsConfig } from "./protocol-CEbWQPYe.mjs";
 import { AssetConfig, StatelyEmbed, StatelyEmbedOptions, createStatelyEmbed } from "./embed.mjs";
-import { a as ManualActorOptions, c as createPostMessageTransport, i as InspectorEvents, l as createWebSocketTransport, n as CreateInspectorOptions, o as createStatelyInspector, r as Inspector, s as Transport, t as AdoptedActor } from "./inspect-DIxB2Tr3.mjs";
+import { a as ManualActorOptions, c as createPostMessageTransport, i as InspectorEvents, l as createWebSocketTransport, n as CreateInspectorOptions, o as createStatelyInspector, r as Inspector, s as Transport, t as AdoptedActor } from "./inspect-BMIJcsFh.mjs";
 import { ActionLocation, GraphPatch } from "./patchTypes.mjs";
-import { CodeGenGraph, MachineConfigOptions, RawCode, graphToMachineConfig, raw, serializeJS } from "@statelyai/graph-tools";
 import { JSONSchema7 } from "json-schema";
+import { UnknownMachineConfig } from "xstate";
 
 //#region src/statelyPragma.d.ts
 interface StatelyPragma {
@@ -31,12 +32,146 @@ declare function findStatelyPragmaAttachments(sourceText: string, fileName?: str
 declare function getStatelyPragma(sourceText: string, fileName?: string, machineIndex?: number): StatelyPragma | undefined;
 declare function upsertStatelyPragma(sourceText: string, id: string, options?: UpsertStatelyPragmaOptions): string;
 //#endregion
+//#region ../graph-tools/src/codegenTypes.d.ts
+interface CodeGenAction {
+  type: string;
+  params?: Record<string, unknown>;
+}
+interface CodeGenGuard {
+  type: string;
+  code?: string;
+  params?: Record<string, unknown>;
+}
+/**
+ * Serialized inline expression directive.
+ *
+ * Code generation treats this object as JavaScript/TypeScript source, not as a
+ * machine config object. It is used for fields such as invoke `input` and
+ * `output` where XState accepts mapper expressions.
+ */
+interface CodeExpression {
+  '@type': 'code';
+  lang: 'js' | 'ts';
+  expr: string;
+}
+interface CodeGenInvoke {
+  src: string;
+  id: string;
+  input?: Record<string, unknown> | CodeExpression;
+  output?: Record<string, unknown> | CodeExpression;
+}
+interface CodeGenNodeData {
+  nodeId?: string | null;
+  key: string;
+  type?: 'normal' | 'parallel' | 'final' | 'history' | null;
+  initialId?: string | null;
+  history?: 'shallow' | 'deep' | boolean;
+  entry?: CodeGenAction[];
+  exit?: CodeGenAction[];
+  invokes?: CodeGenInvoke[];
+  tags?: Array<string | {
+    name: string;
+  }>;
+  description?: string | null;
+  meta?: Record<string, unknown> | null;
+  color?: string;
+  parentId?: string | null;
+  temp?: boolean;
+}
+interface CodeGenEdgeData {
+  eventType: string;
+  transitionType?: 'normal' | 'targetless' | 'reenter';
+  guard?: CodeGenGuard | null;
+  actions?: CodeGenAction[];
+  description?: string | null;
+  color?: string;
+  meta?: Record<string, unknown> | null;
+  temp?: boolean;
+}
+interface CodeGenImplementation {
+  id: string;
+  name: string;
+  description?: string | null;
+  icon?: string;
+  paramsSchema?: JSONSchema7 | null;
+  code?: {
+    body: string;
+    lang?: string;
+  } | null;
+}
+interface CodeGenActorImplementation {
+  id: string;
+  name: string;
+  description?: string | null;
+  icon?: string;
+  inputSchema?: JSONSchema7 | null;
+  outputSchema?: JSONSchema7 | null;
+  code?: {
+    body: string;
+    lang?: string;
+  } | null;
+}
+interface CodeGenGraphData {
+  schemas?: {
+    context?: Record<string, JSONSchema7> | null;
+    events?: Record<string, JSONSchema7> | null;
+    input?: JSONSchema7 | null;
+    output?: JSONSchema7 | null;
+  } | null;
+  implementations?: {
+    actions: CodeGenImplementation[];
+    guards: CodeGenImplementation[];
+    actors: CodeGenActorImplementation[];
+    delays: CodeGenImplementation[];
+  } | null;
+}
+interface CodeGenNode {
+  id: string;
+  parentId?: string | null;
+  data: CodeGenNodeData;
+}
+interface CodeGenEdge {
+  id: string;
+  sourceId: string;
+  targetId: string;
+  data: CodeGenEdgeData;
+}
+interface CodeGenGraph {
+  id: string;
+  nodes: CodeGenNode[];
+  edges: CodeGenEdge[];
+  data: CodeGenGraphData;
+}
+//#endregion
+//#region ../graph-tools/src/graphToMachineConfig.d.ts
+interface MachineConfigOptions {
+  showDescriptions?: boolean;
+  showMeta?: boolean;
+}
+declare function graphToMachineConfig(graph: CodeGenGraph, options?: MachineConfigOptions): UnknownMachineConfig;
+//#endregion
 //#region src/graphToXStateTS.d.ts
 interface XStateTSOptions extends MachineConfigOptions {
   exportStyle?: 'named' | 'default' | 'none';
 }
 declare function graphToXStateTS(graph: CodeGenGraph, options?: XStateTSOptions): string;
 //#endregion
+//#region ../graph-tools/src/serializeJS.d.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
+ * - Supports inline expression directives for verbatim expressions
+ */
+declare class RawCode {
+  code: string;
+  constructor(code: string);
+}
+declare function raw(code: string): RawCode;
+declare function serializeJS(value: unknown, indent?: number, step?: number): string;
+//#endregion
 //#region src/jsonSchemaToTSType.d.ts
 declare function jsonSchemaToTSType(schema: JSONSchema7 | undefined | null): string;
 /**
@@ -50,4 +185,4 @@ declare function contextSchemaToTSType(context: Record<string, JSONSchema7> | nu
  */
 declare function eventsSchemaToTSType(events: Record<string, JSONSchema7> | null | undefined): string | null;
 //#endregion
-export { type ActionLocation, type AdoptedActor, type AssetConfig, type CodeGenGraph, type CommentsConfig, type ConnectedRepo, type CreateInspectorOptions, type CreateMachineFromDefinitionInput, type CreateMachineFromTemplateInput, type CreateMachineInput, type CreateMachineTemplate, type CreateProjectInput, type DigraphAction, type DigraphConfig, type DigraphEdgeConfig, type DigraphNodeConfig, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type EnsureProjectInput, type EventTypeData, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type ExtractMachinesResponse, type ExtractedMachine, type GetMachineOptions, type GraphPatch, type InitOptions, type Inspector, type InspectorEvents, type MachineConfigOptions, type ManualActorOptions, type PlanSyncOptions, type ProjectData, type ProjectEmbedMachine, type ProjectMachine, type ProjectVisibility, type PullSyncResult, type PushSyncOptions, type PushSyncProjectOptions, type PushSyncResult, RawCode, type RepoType, type ResolvedSyncInput, type StateNodeJSONData, type StatelyAction, type StatelyApiClientOptions, StatelyApiError, type StatelyApiUrlOptions, type StatelyEdgeData, type StatelyEmbed, type StatelyEmbedOptions, type StatelyGraph, type StatelyGraphData, type StatelyGuard, type StatelyInvoke, type StatelyNodeData, type StatelyPragma, type StatelyPragmaAttachment, type StudioAction, StudioApiError, type StudioClient, type StudioClientOptions, type StudioEdge, type StudioMachine, type StudioMachineRecord, type StudioNode, type SyncInputFormat, type SyncPlan, type SyncPlanSummary, type Transport, type UploadResult, type UpsertStatelyPragmaOptions, type VerifyApiKeyResponse, type XStateTSOptions, type XStateVersion, contextSchemaToTSType, createPostMessageTransport, createStatelyApiClient, createStatelyApiUrl, createStatelyClient, createStatelyEmbed, createStatelyInspector, createWebSocketTransport, eventsSchemaToTSType, findStatelyPragmaAttachments, fromStudioMachine, getStatelyPragma, graphToMachineConfig, graphToXStateTS, jsonSchemaToTSType, raw, serializeJS, studioMachineConverter, toStudioMachine, upsertStatelyPragma };
+export { type ActionLocation, type AdoptedActor, type AssetConfig, type AssetUploadAdapter, type AssetUploadContext, type AssetUploadRequest, type CodeGenGraph, type CommentsConfig, type ConnectedRepo, type CreateInspectorOptions, type CreateMachineFromDefinitionInput, type CreateMachineFromTemplateInput, type CreateMachineInput, type CreateMachineTemplate, type CreateProjectInput, type CreateS3AssetUploadAdapterOptions, type CreateSupabaseAssetUploadAdapterOptions, type DigraphAction, type DigraphConfig, type DigraphEdgeConfig, type DigraphNodeConfig, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type EnsureProjectInput, type EventTypeData, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type ExtractMachinesResponse, type ExtractedMachine, type GetMachineOptions, type GraphPatch, type InitOptions, type Inspector, type InspectorEvents, type MachineConfigOptions, type ManualActorOptions, type PlanSyncOptions, type ProjectData, type ProjectEmbedMachine, type ProjectMachine, type ProjectVisibility, type PullSyncResult, type PushSyncOptions, type PushSyncProjectOptions, type PushSyncResult, RawCode, type RepoType, type ResolvedSyncInput, type S3UploadTarget, type StateNodeJSONData, type StatelyAction, type StatelyApiClientOptions, StatelyApiError, type StatelyApiUrlOptions, type StatelyEdgeData, type StatelyEmbed, type StatelyEmbedOptions, type StatelyGraph, type StatelyGraphData, type StatelyGuard, type StatelyInvoke, type StatelyNodeData, type StatelyPragma, type StatelyPragmaAttachment, type StudioAction, StudioApiError, type StudioClient, type StudioClientOptions, type StudioEdge, type StudioMachine, type StudioMachineRecord, type StudioNode, type SupabaseStorageClient, type SyncInputFormat, type SyncPlan, type SyncPlanSummary, type Transport, type UploadResult, type UpsertStatelyPragmaOptions, type VerifyApiKeyResponse, type XStateTSOptions, type XStateVersion, contextSchemaToTSType, createPostMessageTransport, createS3AssetUploadAdapter, createStatelyApiClient, createStatelyApiUrl, createStatelyClient, createStatelyEmbed, createStatelyInspector, createSupabaseAssetUploadAdapter, createWebSocketTransport, eventsSchemaToTSType, findStatelyPragmaAttachments, fromStudioMachine, getStatelyPragma, graphToMachineConfig, graphToXStateTS, jsonSchemaToTSType, raw, serializeJS, studioMachineConverter, toStudioMachine, upsertStatelyPragma };

package/dist/index.mjs

@@ -1,9 +1,10 @@
 import { n as createWebSocketTransport, t as createPostMessageTransport } from "./transport-C0eTgNNu.mjs";
 import { createStatelyEmbed } from "./embed.mjs";
+import { createS3AssetUploadAdapter, createSupabaseAssetUploadAdapter } from "./assetStorage.mjs";
 import { createStatelyInspector } from "./inspect.mjs";
 import { StudioApiError, createStatelyClient } from "./studio.mjs";
 import { StatelyApiError, createStatelyApiClient, createStatelyApiUrl } from "./api.mjs";
-import { a as RawCode, c as graphToMachineConfig, d as upsertStatelyPragma, i as jsonSchemaToTSType, l as findStatelyPragmaAttachments, n as contextSchemaToTSType, o as raw, r as eventsSchemaToTSType, s as serializeJS, t as graphToXStateTS, u as getStatelyPragma } from "./graphToXStateTS-CvXM8wHL.mjs";
+import { a as graphToMachineConfig, c as serializeJS, d as upsertStatelyPragma, i as jsonSchemaToTSType, l as findStatelyPragmaAttachments, n as contextSchemaToTSType, o as RawCode, r as eventsSchemaToTSType, s as raw, t as graphToXStateTS, u as getStatelyPragma } from "./graphToXStateTS-Gzh0ZqbN.mjs";
 import { fromStudioMachine, studioMachineConverter, toStudioMachine } from "./graph.mjs";
 
-export { RawCode, StatelyApiError, StudioApiError, contextSchemaToTSType, createPostMessageTransport, createStatelyApiClient, createStatelyApiUrl, createStatelyClient, createStatelyEmbed, createStatelyInspector, createWebSocketTransport, eventsSchemaToTSType, findStatelyPragmaAttachments, fromStudioMachine, getStatelyPragma, graphToMachineConfig, graphToXStateTS, jsonSchemaToTSType, raw, serializeJS, studioMachineConverter, toStudioMachine, upsertStatelyPragma };
+export { RawCode, StatelyApiError, StudioApiError, contextSchemaToTSType, createPostMessageTransport, createS3AssetUploadAdapter, createStatelyApiClient, createStatelyApiUrl, createStatelyClient, createStatelyEmbed, createStatelyInspector, createSupabaseAssetUploadAdapter, createWebSocketTransport, eventsSchemaToTSType, findStatelyPragmaAttachments, fromStudioMachine, getStatelyPragma, graphToMachineConfig, graphToXStateTS, jsonSchemaToTSType, raw, serializeJS, studioMachineConverter, toStudioMachine, upsertStatelyPragma };

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

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

package/dist/inspect.d.mts

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

package/dist/sync.d.mts

@@ -1,5 +1,5 @@
 import { CreateProjectInput, ProjectData, StudioClient, StudioMachineRecord, XStateVersion } from "./studio.mjs";
-import { b as DigraphConfig, i as StatelyGraph } from "./graph-CB-ALrdk.mjs";
+import { b as DigraphConfig, i as StatelyGraph } from "./graph-DpBGHZwl.mjs";
 import { GraphDiff } from "@statelyai/graph";
 
 //#region src/sync.d.ts

package/dist/sync.mjs

@@ -1,5 +1,5 @@
 import { createStatelyClient } from "./studio.mjs";
-import { d as upsertStatelyPragma, t as graphToXStateTS } from "./graphToXStateTS-CvXM8wHL.mjs";
+import { d as upsertStatelyPragma, t as graphToXStateTS } from "./graphToXStateTS-Gzh0ZqbN.mjs";
 import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import { getDiff, isEmptyDiff } from "@statelyai/graph";
 import fs from "node:fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/sdk",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "license": "MIT",
   "bin": {
     "statelyai": "./dist/cli.mjs"
@@ -49,6 +49,10 @@
       "types": "./dist/api.d.mts",
       "import": "./dist/api.mjs"
     },
+    "./assetStorage": {
+      "types": "./dist/assetStorage.d.mts",
+      "import": "./dist/assetStorage.mjs"
+    },
     "./statelyai.schema.json": "./schemas/statelyai.schema.json",
     "./schemas/statelyai.schema.json": "./schemas/statelyai.schema.json"
   },
@@ -56,8 +60,7 @@
     "@oclif/core": "^4.10.3",
     "@statelyai/graph": "^0.9.0",
     "typescript": "^5.9.3",
-    "xstate": "^5.0.0",
-    "@statelyai/graph-tools": "0.0.0"
+    "xstate": "^5.0.0"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",

package/dist/graphToXStateTS-CvXM8wHL.mjs

@@ -1,344 +0,0 @@
-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 };