@statelyai/sdk 0.3.0 → 0.4.0

package/dist/index.d.mts

@@ -1,9 +1,11 @@
-import { a as ExportCallOptions, c as InitOptions, i as EmbedMode, l as ProtocolMessage, n as EmbedEventMap, o as ExportFormat, r as EmbedEventName, s as ExportFormatMap, t as EmbedEventHandler } from "./protocol-BC-_s3if.mjs";
-import { StatelyEmbed, StatelyEmbedOptions, createStatelyEmbed } from "./embed.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-C-7ZK_nK.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-BfezxFKJ.mjs";
+import { a as ProjectMachine, c as StudioClientOptions, i as ProjectData, l as VerifyApiKeyResponse, n as ExtractedMachine, o as StudioApiError, r as GetMachineOptions, s as StudioClient, t as ExtractMachinesResponse, u as createStatelyClient } from "./studio-D2uQhrvX.mjs";
+import { PlanSyncOptions, PullSyncResult, ResolvedSyncInput, SyncInputFormat, SyncPlan, SyncPlanSummary } from "./sync.mjs";
+import { a as EmbedMode, c as ExportFormatMap, d 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 ProtocolMessage } from "./protocol-BgXSkIuc.mjs";
+import { AssetConfig, StatelyEmbed, StatelyEmbedOptions, createStatelyEmbed } from "./embed.mjs";
 import { CreateInspectorOptions, InspectOptions, Inspector, createStatelyInspector } from "./inspect.mjs";
-import { ExtractMachinesResponse, ExtractedMachine, GetMachineOptions, ProjectData, ProjectMachine, StudioApiError, StudioClient, StudioClientOptions, VerifyApiKeyResponse, createStatelyClient } from "./studio.mjs";
-import { PlanSyncOptions, PullSyncResult, ResolvedSyncInput, SyncInputFormat, SyncPlan, SyncPlanSummary, planSync, pullSync } from "./sync.mjs";
+import { JSONSchema7 } from "json-schema";
+import { UnknownMachineConfig } from "xstate";
 
 //#region src/transport.d.ts
 interface Transport {
@@ -35,4 +37,143 @@ interface WebSocketTransportOptions {
 }
 declare function createWebSocketTransport(options: WebSocketTransportOptions): Transport;
 //#endregion
-export { type CreateInspectorOptions, type DigraphAction, type DigraphConfig, type DigraphEdgeConfig, type DigraphNodeConfig, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type EventTypeData, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type ExtractMachinesResponse, type ExtractedMachine, type GetMachineOptions, type InitOptions, type InspectOptions, type Inspector, type PlanSyncOptions, type ProjectData, type ProjectMachine, type PullSyncResult, type ResolvedSyncInput, type StateNodeJSONData, type StatelyAction, type StatelyEdgeData, type StatelyEmbed, type StatelyEmbedOptions, type StatelyGraph, type StatelyGraphData, type StatelyGuard, type StatelyInvoke, type StatelyNodeData, type StudioAction, StudioApiError, type StudioClient, type StudioClientOptions, type StudioEdge, type StudioMachine, type StudioNode, type SyncInputFormat, type SyncPlan, type SyncPlanSummary, type Transport, type VerifyApiKeyResponse, createPostMessageTransport, createStatelyClient, createStatelyEmbed, createStatelyInspector, createWebSocketTransport, fromStudioMachine, planSync, pullSync, studioMachineConverter, toStudioMachine };
+//#region src/codegenTypes.d.ts
+interface CodeGenAction {
+  type: string;
+  params?: Record<string, unknown>;
+  code?: string;
+}
+interface CodeGenGuard {
+  type: string;
+  code?: string;
+  params?: Record<string, unknown>;
+}
+interface CodeGenInvoke {
+  src: string;
+  id: string;
+  input?: unknown;
+}
+interface CodeGenNodeData {
+  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 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 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
+ */
+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;
+/**
+ * Build an inline context type string from the schemas.context record.
+ * Each key is a context property name, value is its JSONSchema7.
+ */
+declare function contextSchemaToTSType(context: Record<string, JSONSchema7> | null | undefined): string | null;
+/**
+ * Build an event union type from the schemas.events record.
+ * Each key is the event type name, value describes the payload properties.
+ */
+declare function eventsSchemaToTSType(events: Record<string, JSONSchema7> | null | undefined): string | null;
+//#endregion
+export { type AssetConfig, type CodeGenGraph, type CommentsConfig, type CreateInspectorOptions, type DigraphAction, type DigraphConfig, type DigraphEdgeConfig, type DigraphNodeConfig, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type EventTypeData, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type ExtractMachinesResponse, type ExtractedMachine, type GetMachineOptions, type InitOptions, type InspectOptions, type Inspector, type MachineConfigOptions, type PlanSyncOptions, type ProjectData, type ProjectMachine, type PullSyncResult, RawCode, type ResolvedSyncInput, type StateNodeJSONData, type StatelyAction, type StatelyEdgeData, type StatelyEmbed, type StatelyEmbedOptions, type StatelyGraph, type StatelyGraphData, type StatelyGuard, type StatelyInvoke, type StatelyNodeData, type StudioAction, StudioApiError, type StudioClient, type StudioClientOptions, type StudioEdge, type StudioMachine, type StudioNode, type SyncInputFormat, type SyncPlan, type SyncPlanSummary, type Transport, type UploadResult, type VerifyApiKeyResponse, type XStateTSOptions, contextSchemaToTSType, createPostMessageTransport, createStatelyClient, createStatelyEmbed, createStatelyInspector, createWebSocketTransport, eventsSchemaToTSType, fromStudioMachine, graphToMachineConfig, graphToXStateTS, jsonSchemaToTSType, raw, serializeJS, studioMachineConverter, toStudioMachine };

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { n as createWebSocketTransport, t as createPostMessageTransport } from "./transport-D352iKKa.mjs";
+import { n as createWebSocketTransport, t as createPostMessageTransport } from "./transport-C1fRAuv-.mjs";
 import { createStatelyEmbed } from "./embed.mjs";
 import { createStatelyInspector } from "./inspect.mjs";
 import { StudioApiError, createStatelyClient } from "./studio.mjs";
 import { fromStudioMachine, studioMachineConverter, toStudioMachine } from "./graph.mjs";
-import { n as pullSync, t as planSync } from "./sync-CzEOizjx.mjs";
+import { a as graphToMachineConfig, c as serializeJS, i as jsonSchemaToTSType, n as contextSchemaToTSType, o as RawCode, r as eventsSchemaToTSType, s as raw, t as graphToXStateTS } from "./graphToXStateTS-C6HQUrBB.mjs";
 
-export { StudioApiError, createPostMessageTransport, createStatelyClient, createStatelyEmbed, createStatelyInspector, createWebSocketTransport, fromStudioMachine, planSync, pullSync, studioMachineConverter, toStudioMachine };
+export { RawCode, StudioApiError, contextSchemaToTSType, createPostMessageTransport, createStatelyClient, createStatelyEmbed, createStatelyInspector, createWebSocketTransport, eventsSchemaToTSType, fromStudioMachine, graphToMachineConfig, graphToXStateTS, jsonSchemaToTSType, raw, serializeJS, studioMachineConverter, toStudioMachine };

package/dist/inspect.d.mts

@@ -1,4 +1,4 @@
-import { a as ExportCallOptions, c as InitOptions, i as EmbedMode, n as EmbedEventMap, o as ExportFormat, r as EmbedEventName, s as ExportFormatMap, t as EmbedEventHandler } from "./protocol-BC-_s3if.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-BgXSkIuc.mjs";
 
 //#region src/inspect.d.ts
 interface CreateInspectorOptions {
@@ -38,8 +38,12 @@ interface InspectOptions {
   theme?: 'light' | 'dark';
   readOnly?: boolean;
   depth?: number;
-  panels?: InitOptions['panels'];
+  panels?: {
+    leftPanels?: string[];
+    rightPanels?: string[];
+    activePanels?: string[];
+  };
 }
 declare function createStatelyInspector(options?: CreateInspectorOptions): Inspector;
 //#endregion
-export { CreateInspectorOptions, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type ExportCallOptions, type ExportFormat, type ExportFormatMap, type InitOptions, InspectOptions, Inspector, createStatelyInspector };
+export { CreateInspectorOptions, type EmbedEventHandler, type EmbedEventMap, type EmbedEventName, type EmbedMode, type ExportCallOptions, type ExportFormat, type ExportFormatMap, InspectOptions, Inspector, createStatelyInspector };

package/dist/inspect.mjs

@@ -1,4 +1,4 @@
-import { a as createRequestId, i as createPendingExportManager, n as createWebSocketTransport, o as toInitMessage, r as createEventRegistry } from "./transport-D352iKKa.mjs";
+import { a as createRequestId, i as createPendingExportManager, n as createWebSocketTransport, o as toInitMessage, r as createEventRegistry } from "./transport-C1fRAuv-.mjs";
 
 //#region src/inspect.ts
 function generateId() {

package/dist/{protocol-BC-_s3if.d.mts → protocol-BgXSkIuc.d.mts}

@@ -1,5 +1,12 @@
 //#region src/protocol.d.ts
 type EmbedMode = 'editing' | 'viewing' | 'simulating' | 'inspecting';
+interface CommentsConfig {
+  roomId: string;
+  userId?: string | null;
+  publicApiKey?: string;
+  authEndpoint?: string;
+  baseUrl?: string;
+}
 interface ExportFormatMap {
   xstate: {
     options: {
@@ -72,6 +79,7 @@ interface InitOptions {
     rightPanels?: string[];
     activePanels?: string[];
   };
+  comments?: CommentsConfig;
 }
 interface InitMessage {
   type: '@statelyai.init';
@@ -84,6 +92,7 @@ interface InitMessage {
   leftPanels?: string[];
   rightPanels?: string[];
   activePanels?: string[];
+  comments?: CommentsConfig;
 }
 interface UpdateMessage {
   type: '@statelyai.update';
@@ -114,8 +123,6 @@ interface InspectSnapshotMessage {
   snapshot: unknown;
   event: unknown | null;
 }
-/** All messages a client (embed/inspector) can send to the viz. */
-type ClientMessage = InitMessage | UpdateMessage | SetModeMessage | SetThemeMessage | RetrieveMessage | ToastMessage | InspectSnapshotMessage;
 interface ReadyMessage {
   type: '@statelyai.ready';
   version: string;
@@ -145,8 +152,50 @@ interface ErrorMessage {
   message: string;
   requestId?: string;
 }
+/** File metadata sent from viz to SDK when a file needs uploading. */
+interface UploadFileInfo {
+  /** Original filename (e.g. "screenshot.png") */
+  name: string;
+  /** MIME type (e.g. "image/png") */
+  mimeType: string;
+  /** File size in bytes */
+  size: number;
+  /** File content as base64-encoded string */
+  data: string;
+}
+/** The result the consumer returns after uploading. */
+interface UploadResult {
+  /** The publicly accessible URL of the uploaded file */
+  url: string;
+  /** Optional display name (defaults to original filename) */
+  name?: string;
+  /** Optional metadata stored on the asset */
+  metadata?: Record<string, unknown>;
+}
+/** Viz requests the parent to upload a file. */
+interface UploadRequestMessage {
+  type: '@statelyai.uploadRequest';
+  requestId: string;
+  file: UploadFileInfo;
+  stateNodeId: string;
+}
+/** Parent tells the viz the upload capabilities on init. */
+interface UploadCapabilitiesMessage {
+  type: '@statelyai.uploadCapabilities';
+  enabled: boolean;
+  accept?: string[];
+  maxFileSize?: number;
+}
+/** Parent sends the upload result back to the viz. */
+interface UploadResponseMessage {
+  type: '@statelyai.uploadResponse';
+  requestId: string;
+  result: UploadResult;
+}
+/** All messages a client (embed/inspector) can send to the viz. */
+type ClientMessage = InitMessage | UpdateMessage | SetModeMessage | SetThemeMessage | RetrieveMessage | ToastMessage | InspectSnapshotMessage | UploadCapabilitiesMessage | UploadResponseMessage | ErrorMessage;
 /** All messages the viz can send back to a client. */
-type VizMessage = ReadyMessage | LoadedMessage | ChangeMessage | SaveMessage | RetrievedMessage | ErrorMessage;
+type VizMessage = ReadyMessage | LoadedMessage | ChangeMessage | SaveMessage | RetrievedMessage | ErrorMessage | UploadRequestMessage;
 interface RegisterMessage {
   type: '@statelyai.register';
   role: 'client' | 'viz';
@@ -169,4 +218,4 @@ type SessionMessage = RegisterMessage | RegisteredMessage | RequestOpenMessage;
 /** Any valid protocol message. */
 type ProtocolMessage = ClientMessage | VizMessage | SessionMessage;
 //#endregion
-export { ExportCallOptions as a, InitOptions as c, EmbedMode as i, ProtocolMessage as l, EmbedEventMap as n, ExportFormat as o, EmbedEventName as r, ExportFormatMap as s, EmbedEventHandler as t };
+export { EmbedMode as a, ExportFormatMap as c, UploadResult as d, EmbedEventName as i, InitOptions as l, EmbedEventHandler as n, ExportCallOptions as o, EmbedEventMap as r, ExportFormat as s, CommentsConfig as t, ProtocolMessage as u };

package/dist/studio-D2uQhrvX.d.mts

@@ -0,0 +1,54 @@
+//#region src/studio.d.ts
+interface StudioClientOptions {
+  baseUrl?: string;
+  apiKey?: string;
+  fetch?: typeof fetch;
+}
+interface VerifyApiKeyResponse {
+  valid: boolean;
+}
+interface ProjectMachine {
+  machineId: string;
+  name: string;
+}
+interface ProjectData {
+  projectId: string;
+  machines: ProjectMachine[];
+}
+interface ExtractedMachine {
+  id?: string;
+  config: Record<string, unknown>;
+  setupConfig?: Record<string, unknown>;
+  implementations?: Record<string, unknown>;
+  _type: 'setup.createMachine' | 'createMachine';
+}
+interface ExtractMachinesResponse {
+  machines: ExtractedMachine[];
+  error?: string;
+}
+interface GetMachineOptions {
+  version?: string;
+}
+declare class StudioApiError extends Error {
+  readonly status: number;
+  constructor(message: string, status: number);
+}
+interface StudioClient {
+  auth: {
+    verify(apiKey?: string): Promise<VerifyApiKeyResponse>;
+  };
+  projects: {
+    get(projectId: string): Promise<ProjectData>;
+  };
+  machines: {
+    get<TMachine = Record<string, unknown>>(machineId: string, options?: GetMachineOptions): Promise<TMachine>;
+  };
+  code: {
+    extractMachines(code: string, options?: {
+      apiKey?: string | null;
+    }): Promise<ExtractMachinesResponse>;
+  };
+}
+declare function createStatelyClient(options?: StudioClientOptions): StudioClient;
+//#endregion
+export { ProjectMachine as a, StudioClientOptions as c, ProjectData as i, VerifyApiKeyResponse as l, ExtractedMachine as n, StudioApiError as o, GetMachineOptions as r, StudioClient as s, ExtractMachinesResponse as t, createStatelyClient as u };

package/dist/studio.d.mts

@@ -1,54 +1,2 @@
-//#region src/studio.d.ts
-interface StudioClientOptions {
-  baseUrl?: string;
-  apiKey?: string;
-  fetch?: typeof fetch;
-}
-interface VerifyApiKeyResponse {
-  valid: boolean;
-}
-interface ProjectMachine {
-  machineId: string;
-  name: string;
-}
-interface ProjectData {
-  projectId: string;
-  machines: ProjectMachine[];
-}
-interface ExtractedMachine {
-  id?: string;
-  config: Record<string, unknown>;
-  setupConfig?: Record<string, unknown>;
-  implementations?: Record<string, unknown>;
-  _type: 'setup.createMachine' | 'createMachine';
-}
-interface ExtractMachinesResponse {
-  machines: ExtractedMachine[];
-  error?: string;
-}
-interface GetMachineOptions {
-  version?: string;
-}
-declare class StudioApiError extends Error {
-  readonly status: number;
-  constructor(message: string, status: number);
-}
-interface StudioClient {
-  auth: {
-    verify(apiKey?: string): Promise<VerifyApiKeyResponse>;
-  };
-  projects: {
-    get(projectId: string): Promise<ProjectData>;
-  };
-  machines: {
-    get<TMachine = Record<string, unknown>>(machineId: string, options?: GetMachineOptions): Promise<TMachine>;
-  };
-  code: {
-    extractMachines(code: string, options?: {
-      apiKey?: string | null;
-    }): Promise<ExtractMachinesResponse>;
-  };
-}
-declare function createStatelyClient(options?: StudioClientOptions): StudioClient;
-//#endregion
+import { a as ProjectMachine, c as StudioClientOptions, i as ProjectData, l as VerifyApiKeyResponse, n as ExtractedMachine, o as StudioApiError, r as GetMachineOptions, s as StudioClient, t as ExtractMachinesResponse, u as createStatelyClient } from "./studio-D2uQhrvX.mjs";
 export { ExtractMachinesResponse, ExtractedMachine, GetMachineOptions, ProjectData, ProjectMachine, StudioApiError, StudioClient, StudioClientOptions, VerifyApiKeyResponse, createStatelyClient };

package/dist/sync.d.mts

@@ -1,5 +1,5 @@
-import { i as StatelyGraph } from "./graph-C-7ZK_nK.mjs";
-import { StudioClient } from "./studio.mjs";
+import { i as StatelyGraph } from "./graph-BfezxFKJ.mjs";
+import { s as StudioClient } from "./studio-D2uQhrvX.mjs";
 import { GraphDiff } from "@statelyai/graph";
 
 //#region src/sync.d.ts

package/dist/sync.mjs

@@ -1,5 +1,255 @@
-import "./studio.mjs";
-import "./graph.mjs";
-import { n as pullSync, t as planSync } from "./sync-CzEOizjx.mjs";
+import { createStatelyClient } from "./studio.mjs";
+import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
+import { t as graphToXStateTS } from "./graphToXStateTS-C6HQUrBB.mjs";
+import { getDiff, isEmptyDiff } from "@statelyai/graph";
+import fs from "node:fs/promises";
+import path from "node:path";
 
+//#region src/sync.ts
+function isUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+async function fileExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function normalizeActions(value) {
+	if (value == null) return [];
+	return (Array.isArray(value) ? value : [value]).map((item) => {
+		if (typeof item === "string") return { type: item };
+		if (typeof item === "object" && item !== null && "type" in item) {
+			const type = item.type;
+			const params = "params" in item && typeof item.params === "object" && item.params ? item.params : void 0;
+			return {
+				type,
+				...params ? { params } : {}
+			};
+		}
+		return { type: String(item) };
+	});
+}
+function normalizeTags(value) {
+	if (!value) return [];
+	if (Array.isArray(value)) return value.map((tag) => String(tag));
+	return [String(value)];
+}
+function normalizeInvoke(value) {
+	if (!value) return [];
+	return (Array.isArray(value) ? value : [value]).map((invoke, index) => ({
+		src: invoke.src,
+		id: invoke.id ?? `invoke[${index}]`,
+		...invoke.input ? { input: invoke.input } : {}
+	}));
+}
+function resolveTargetId(sourceParentPath, target) {
+	if (!target) return;
+	if (target.startsWith("#")) {
+		const stripped = target.slice(1);
+		const machineIndex = stripped.indexOf(".");
+		if (machineIndex >= 0) return `(machine).${stripped.slice(machineIndex + 1)}`;
+		return `(machine).${stripped}`;
+	}
+	if (target.startsWith("(machine)")) return target;
+	if (target.includes(".")) return `(machine).${target}`;
+	return `${sourceParentPath}.${target}`;
+}
+function appendTransitionEdges(edges, sourceId, sourceParentPath, eventType, transition, edgeCounts) {
+	const transitions = Array.isArray(transition) ? transition : [transition];
+	for (const item of transitions) {
+		const normalized = typeof item === "string" ? { target: item } : item;
+		const targetId = resolveTargetId(sourceParentPath, Array.isArray(normalized.target) ? normalized.target[0] : normalized.target);
+		const groupKey = `${sourceId}:${eventType}`;
+		const index = edgeCounts.get(groupKey) ?? 0;
+		edgeCounts.set(groupKey, index + 1);
+		edges.push({
+			type: "edge",
+			id: `${sourceId}#${eventType}[${index}]`,
+			sourceId,
+			targetId: targetId ?? sourceId,
+			label: eventType,
+			data: {
+				eventType,
+				transitionType: normalized.reenter === true ? "reenter" : normalized.internal === true || !targetId ? "targetless" : "normal",
+				...normalized.guard ? { guard: typeof normalized.guard === "string" ? { type: normalized.guard } : {
+					type: normalized.guard.type,
+					...normalized.guard.params ? { params: normalized.guard.params } : {}
+				} } : {},
+				actions: normalizeActions(normalized.actions),
+				...normalized.description ? { description: normalized.description } : {}
+			}
+		});
+	}
+}
+function fromXStateConfig(config) {
+	const nodes = [];
+	const edges = [];
+	const edgeCounts = /* @__PURE__ */ new Map();
+	function visitNode(key, nodeConfig, parentId, parentPath) {
+		const nodeId = parentPath ? `${parentPath}.${key}` : "(machine)";
+		const currentPath = parentPath ? nodeId : "(machine)";
+		const initialId = nodeConfig.initial ? `${currentPath}.${nodeConfig.initial}` : void 0;
+		nodes.push({
+			type: "node",
+			id: nodeId,
+			parentId,
+			label: key,
+			...initialId ? { initialNodeId: initialId } : {},
+			data: {
+				key,
+				...nodeConfig.type ? { type: nodeConfig.type } : {},
+				...nodeConfig.history ? { history: nodeConfig.history } : {},
+				...initialId ? { initialId } : {},
+				entry: normalizeActions(nodeConfig.entry),
+				exit: normalizeActions(nodeConfig.exit),
+				invokes: normalizeInvoke(nodeConfig.invoke),
+				tags: normalizeTags(nodeConfig.tags),
+				...nodeConfig.description ? { description: nodeConfig.description } : {}
+			}
+		});
+		for (const [eventType, transition] of Object.entries(nodeConfig.on ?? {})) appendTransitionEdges(edges, nodeId, parentPath ?? "(machine)", eventType, transition, edgeCounts);
+		if (nodeConfig.always) appendTransitionEdges(edges, nodeId, parentPath ?? "(machine)", "", nodeConfig.always, edgeCounts);
+		for (const [childKey, childConfig] of Object.entries(nodeConfig.states ?? {})) visitNode(childKey, childConfig, nodeId, currentPath);
+	}
+	visitNode("(machine)", config, null, null);
+	return {
+		id: config.id ?? "machine",
+		nodes,
+		edges,
+		data: {}
+	};
+}
+async function resolveLocalFile(locator, options) {
+	const filePath = path.resolve(options.cwd ?? process.cwd(), locator);
+	const contents = await fs.readFile(filePath, "utf8");
+	const extension = path.extname(filePath).toLowerCase();
+	if (extension === ".ts" || extension === ".tsx" || extension === ".js" || extension === ".jsx") {
+		const config = (await (options.client ?? createStatelyClient({
+			apiKey: options.apiKey,
+			baseUrl: options.baseUrl,
+			fetch: options.fetch
+		})).code.extractMachines(contents)).machines[0]?.config;
+		if (!config) throw new Error(`No machines extracted from ${filePath}`);
+		return {
+			kind: "local-file",
+			locator: filePath,
+			format: "xstate",
+			graph: fromXStateConfig(config)
+		};
+	}
+	const parsed = JSON.parse(contents);
+	if ("rootNode" in parsed && "edges" in parsed) return {
+		kind: "local-file",
+		locator: filePath,
+		format: "digraph",
+		graph: fromStudioMachine(parsed)
+	};
+	if ("nodes" in parsed && "edges" in parsed) return {
+		kind: "local-file",
+		locator: filePath,
+		format: "graph",
+		graph: parsed
+	};
+	if ("states" in parsed) return {
+		kind: "local-file",
+		locator: filePath,
+		format: "xstate",
+		graph: fromXStateConfig(parsed)
+	};
+	throw new Error(`Unsupported local sync input: ${filePath}`);
+}
+function inferWritableTargetFormat(filePath) {
+	if (filePath.endsWith(".ts") || filePath.endsWith(".tsx") || filePath.endsWith(".js") || filePath.endsWith(".jsx")) return "xstate";
+	if (filePath.endsWith(".digraph.json")) return "digraph";
+	if (filePath.endsWith(".graph.json")) return "graph";
+	return null;
+}
+function serializeGraph(graph, format) {
+	switch (format) {
+		case "digraph": return `${JSON.stringify(toStudioMachine(graph), null, 2)}\n`;
+		case "graph": return `${JSON.stringify(graph, null, 2)}\n`;
+		case "xstate": return graphToXStateTS(graph);
+		default: {
+			const exhaustive = format;
+			throw new Error(`Unsupported sync output format: ${exhaustive}`);
+		}
+	}
+}
+async function resolveRemoteMachine(machineId, baseUrl, kind, locator, options) {
+	return {
+		kind,
+		locator,
+		format: "digraph",
+		graph: fromStudioMachine(await (options.client ?? createStatelyClient({
+			apiKey: options.apiKey,
+			baseUrl,
+			fetch: options.fetch
+		})).machines.get(machineId))
+	};
+}
+async function resolveSyncInput(locator, options) {
+	if (await fileExists(path.resolve(options.cwd ?? process.cwd(), locator))) return resolveLocalFile(locator, options);
+	if (isUrl(locator)) {
+		const url = new URL(locator);
+		const machineId = url.pathname.split("/").filter(Boolean).at(-1);
+		if (!machineId) throw new Error(`Could not resolve machine ID from URL: ${locator}`);
+		return resolveRemoteMachine(machineId, url.origin, "studio-url", locator, options);
+	}
+	return resolveRemoteMachine(locator, options.baseUrl, "studio-machine-id", locator, options);
+}
+function summarizeDiff(diff) {
+	const nodeChanges = diff.nodes.added.length + diff.nodes.removed.length + diff.nodes.updated.length;
+	const edgeChanges = diff.edges.added.length + diff.edges.removed.length + diff.edges.updated.length;
+	return {
+		hasChanges: !isEmptyDiff(diff),
+		nodeChanges,
+		edgeChanges
+	};
+}
+async function planSync(options) {
+	const source = await resolveSyncInput(options.source, options);
+	const target = await resolveSyncInput(options.target, options);
+	const diff = getDiff(source.graph, target.graph);
+	return {
+		source,
+		target,
+		diff,
+		summary: summarizeDiff(diff),
+		warnings: []
+	};
+}
+async function pullSync(options) {
+	const source = await resolveSyncInput(options.source, options);
+	const outputPath = path.resolve(options.cwd ?? process.cwd(), options.target);
+	const fallbackFormat = inferWritableTargetFormat(outputPath);
+	let targetFormat = fallbackFormat;
+	if (await fileExists(outputPath)) try {
+		targetFormat = (await resolveLocalFile(options.target, options)).format;
+	} catch (error) {
+		if (!fallbackFormat) throw error;
+	}
+	if (!targetFormat) throw new Error(`Could not infer a writable target format from ${outputPath}. Use an existing digraph/graph file or a .digraph.json/.graph.json target.`);
+	const serialized = serializeGraph(source.graph, targetFormat);
+	await fs.writeFile(outputPath, serialized, "utf8");
+	return {
+		source,
+		target: {
+			kind: "local-file",
+			locator: outputPath,
+			format: targetFormat,
+			graph: source.graph
+		},
+		outputPath
+	};
+}
+
+//#endregion
 export { planSync, pullSync };