@statelyai/sdk 0.23.1 → 0.25.0

package/README.md

@@ -45,6 +45,10 @@ embed.init({
 });
 ```
 
+The embed `apiKey` is sent to the iframe over `postMessage` after the editor
+handshake; it is not included in the iframe URL. Call `embed.setApiKey(token)`
+when the host refreshes the access token.
+
 Use `viewMode: 'list'` on `createStatelyEmbed` to add `?view=list` to the
 iframe URL, or subscribe to `viewModeChanged` when the user switches views.
 
@@ -99,16 +103,18 @@ status and protocol error code metadata so hosts can refresh credentials and
 retry once without depending on response-message text.
 Hosts keep ownership of files, credentials, UI, and transport adapters.
 
+<!-- supported editor export formats from packages/editor/src/formatConfig.ts -->
+
 Key capabilities:
 
 - **Mount or attach** to any container element or existing iframe
 - **Two-way sync** - push machine configs in, get changes and saves back via event callbacks
-- **Export** to multiple formats: XState v5, XState JSON, Mermaid, Redux, Zustand, ASL, SCXML, and more
+- **Export** to multiple formats: XState v5, XState v6 alpha, XState JSON, Mermaid, Redux, Zustand, ASL, SCXML, and more
 - **Access policies** for read-only, no-export, no-AI, shallow-viewer embeds
 - **Reference documents** supplied as ordered, read-only Markdown, code, or text
 - **Comments** via Liveblocks integration (optional)
 - **Asset uploads** with built-in S3 and Supabase adapters, or bring your own upload handler
-- **Runtime settings** - toggle color mode, grid, snap lines, autolayout, and view mode on the fly
+- **Runtime settings** - toggle color mode, grid, snap lines, and view mode on the fly
 
 ### Resource API client
 

package/dist/embed.d.mts

@@ -1,5 +1,5 @@
-import { i as ProfileManifest } from "./index-D_pO_Pr8.mjs";
-import { i as StatelyGraph } from "./graph-1fwR0Ynl.mjs";
+import { i as ProfileManifest } from "./index-DuvCSThi.mjs";
+import { i as StatelyGraph } from "./graph-BGUND7ZF.mjs";
 import { CapabilityDeniedEvent, CommentsConfig, EditorCapabilities, EmbedDocument, EmbedDocumentLanguage, EmbedEventHandler, EmbedEventMap, EmbedEventName, EmbedExtensionsManifest, EmbedMode, ExportCallOptions, ExportFormat, ExportFormatMap, InitOptions, MachineInitOptions, MachineSourceLocations, ProjectEmbedMachine, ProjectWorkspaceAction, ProjectWorkspaceActionIcon, ProjectWorkspaceCapabilities, ProjectWorkspaceConfig, ProjectWorkspaceMachine, ProjectWorkspaceProject, UploadResult } from "./protocol.mjs";
 import { AssetUploadAdapter } from "./assetStorage.mjs";
 
@@ -71,6 +71,7 @@ type EmbedFormatDefinition = {
 };
 interface StatelyEmbedOptions extends Partial<MachineInitOptions> {
   baseUrl: string;
+  /** Access token sent to the iframe over the embed protocol. */
   apiKey?: string;
   /** Initial canvas view. Also reflected in the iframe URL as `?view=`. */
   viewMode?: 'graph' | 'list';
@@ -115,6 +116,8 @@ interface StatelyEmbed {
   attach(iframe: HTMLIFrameElement): void;
   /** Create an iframe and mount it into a container element. */
   mount(container: HTMLElement): HTMLIFrameElement;
+  /** Update the access token used by the iframe. */
+  setApiKey(apiKey: string): void;
   /** Send init message (queued if iframe not ready yet). */
   init(options: InitOptions): void;
   /** Update the machine (shorthand for update message). */

package/dist/embed.mjs

@@ -1,4 +1,4 @@
-import { a as createEventRegistry, o as createPendingExportManager, r as createPostMessageTransport, s as toInitMessage, t as SDK_VERSION } from "./version-DX-_ZovM.mjs";
+import { a as createEventRegistry, o as createPendingExportManager, r as createPostMessageTransport, s as toInitMessage, t as SDK_VERSION } from "./version-BfcJU2pO.mjs";
 import { t as EDITOR_PROTOCOL_VERSION } from "./editorHostProtocol-Bko7wge8.mjs";
 
 //#region src/embed.ts
@@ -25,10 +25,13 @@ function assertExtensionCall(value) {
 	if ((value.method === "export" || value.method === "validate") && !isEmbedGraph(payload.graph)) throw new Error("Invalid extension graph payload.");
 	if (value.method === "validate" && payload.revision !== void 0 && typeof payload.revision !== "number") throw new Error("Invalid extension revision payload.");
 }
+function normalizeApiKey(apiKey) {
+	return apiKey?.trim() || void 0;
+}
 function buildEmbedUrl(options) {
 	const base = options.baseUrl.replace(/\/+$/, "") + "/embed";
 	const url = new URL(base);
-	if (options.apiKey) url.searchParams.set("api_key", options.apiKey);
+	if (normalizeApiKey(options.apiKey)) url.searchParams.set("auth", "message");
 	if (options.viewMode) url.searchParams.set("view", options.viewMode);
 	return url.toString();
 }
@@ -113,6 +116,7 @@ function createStatelyEmbed(options) {
 	let ownedIframe = false;
 	let destroyed = false;
 	let editorProtocolCompatible;
+	let apiKey = normalizeApiKey(options.apiKey);
 	const pendingMessages = [];
 	const events = createEventRegistry();
 	const profiles = new Map((options.profiles ?? []).map((profile) => [profile.profile, profile]));
@@ -141,6 +145,12 @@ function createStatelyEmbed(options) {
 			transport.send(msg);
 		}
 	}
+	function sendApiKey() {
+		if (apiKey) send({
+			type: "@statelyai.setApiKey",
+			apiKey
+		});
+	}
 	function formatContext(profile) {
 		const namespace = profile.namespace ?? /^(@[^/]+)\//.exec(profile.profile)?.[1];
 		if (!namespace) throw new Error(`Profile ${profile.profile} has no namespace.`);
@@ -231,6 +241,7 @@ function createStatelyEmbed(options) {
 						}
 					});
 				} else editorProtocolCompatible = true;
+				sendApiKey();
 				flush();
 				if (uploadAsset) send({
 					type: "@statelyai.uploadCapabilities",
@@ -411,6 +422,10 @@ function createStatelyEmbed(options) {
 			setupTransport(el);
 			return el;
 		},
+		setApiKey(nextApiKey) {
+			apiKey = normalizeApiKey(nextApiKey);
+			sendApiKey();
+		},
 		init(opts) {
 			send(toInitMessage("machine" in opts ? {
 				...opts,

package/dist/{graph-1fwR0Ynl.d.mts → graph-BGUND7ZF.d.mts}

@@ -1,4 +1,4 @@
-import { t as CodeExpression } from "./index-D_pO_Pr8.mjs";
+import { t as CodeExpression } from "./index-DuvCSThi.mjs";
 import * as _statelyai_graph0 from "@statelyai/graph";
 import { Graph } from "@statelyai/graph";
 

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-1fwR0Ynl.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-BGUND7ZF.mjs";
 export { StatelyAction, StatelyActorImplementation, StatelyEdgeData, StatelyGraph, StatelyGraphData, StatelyGuard, StatelyImplementation, StatelyInvoke, StatelyNodeData, StatelyTagImplementation, StudioAction, StudioEdge, StudioEventTypeData, StudioMachine, StudioNode, fromStudioMachine, studioMachineConverter, toStudioMachine };

package/dist/{index-D_pO_Pr8.d.mts → index-DuvCSThi.d.mts}

@@ -2731,6 +2731,8 @@ interface CodeExpression {
 interface CodeImport {
   package: string;
   import: string;
+  /** Local binding name when it differs from the imported name. */
+  local?: string;
   importKind?: 'named' | 'default' | 'namespace';
   version?: string;
 }
@@ -2791,6 +2793,7 @@ interface CodeGenImplementation {
   code?: {
     body: string;
     lang?: string;
+    imports?: CodeImport[];
   } | null;
 }
 interface CodeGenActorImplementation {
@@ -2803,6 +2806,7 @@ interface CodeGenActorImplementation {
   code?: {
     body: string;
     lang?: string;
+    imports?: CodeImport[];
   } | null;
 }
 interface CodeGenGraphData {
@@ -2938,6 +2942,7 @@ interface XStateTSOptions extends MachineConfigOptions {
   exportStyle?: 'named' | 'default' | 'none';
   targetLanguage?: 'typescript' | 'javascript';
   xstateVersion?: 5 | 6;
+  xstateV6SchemaFormat?: 'types' | 'zod';
 }
 declare function graphToXStateTS(graph: CodeGenGraph, options?: XStateTSOptions): string; //#endregion
 //#region src/jsonSchemaToTSType.d.ts
@@ -2952,6 +2957,6 @@ declare function contextSchemaToTSType(context: Record<string, JSONSchema7> | nu
  * Each key is the event type name, value describes the payload properties.
  */
 declare function eventsSchemaToTSType(events: Record<string, JSONSchema7> | null | undefined): string | null; //#endregion
-//#region src/graphPaths.d.ts
+//#region src/jsonSchemaToZod.d.ts
 //#endregion
 export { output as A, ZodNumber as C, ZodString as D, ZodRecord as E, ZodUnion as O, ZodNullable as S, ZodOptional as T, GraphPatch as _, RawCode as a, ZodEnum as b, eventsSchemaToTSType as c, jsonSchemaToTSType as d, raw as f, EditorStateType as g, CanvasColor as h, ProfileManifest as i, $strip as j, ZodUnknown as k, graphToMachineConfig as l, ActionLocation as m, CodeGenGraph as n, XStateTSOptions as o, serializeJS as p, MachineConfigOptions as r, contextSchemaToTSType as s, CodeExpression as t, graphToXStateTS as u, ImplementationSourceType as v, ZodObject as w, ZodLiteral as x, ZodArray as y };

package/dist/index.d.mts

@@ -1,13 +1,13 @@
 import { StatelyApiClientOptions, StatelyApiError, StatelyApiUrlOptions, createStatelyApiClient, createStatelyApiUrl } from "./api.mjs";
-import { _ as GraphPatch, a as RawCode, c as eventsSchemaToTSType, d as jsonSchemaToTSType, f as raw, l as graphToMachineConfig, m as ActionLocation, n as CodeGenGraph, o as XStateTSOptions, p as serializeJS, r as MachineConfigOptions, s as contextSchemaToTSType, u as graphToXStateTS } from "./index-D_pO_Pr8.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-1fwR0Ynl.mjs";
+import { _ as GraphPatch, a as RawCode, c as eventsSchemaToTSType, d as jsonSchemaToTSType, f as raw, l as graphToMachineConfig, m as ActionLocation, n as CodeGenGraph, o as XStateTSOptions, p as serializeJS, r as MachineConfigOptions, s as contextSchemaToTSType, u as graphToXStateTS } from "./index-DuvCSThi.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-BGUND7ZF.mjs";
 import { CapabilityDeniedCapability, CapabilityDeniedEvent, CommentsConfig, EMBED_DOCUMENT_LANGUAGES, EMBED_DOCUMENT_LIMITS, EditorCapabilities, EmbedDocument, EmbedDocumentLanguage, EmbedEventHandler, EmbedEventMap, EmbedEventName, EmbedMode, ExportCallOptions, ExportFormat, ExportFormatMap, INSPECTION_PROTOCOL_VERSION, INSPECTION_ROOM_QUERY_PARAM, InitOptions, InspectionAction, InspectionSentEvent, InspectionTakenTransition, ProjectEmbedMachine, ProjectWorkspaceAction, ProjectWorkspaceActionIcon, ProjectWorkspaceCapabilities, ProjectWorkspaceConfig, ProjectWorkspaceMachine, ProjectWorkspaceProject, UploadResult, createInspectionActorId, createInspectionRoomUrls, getInspectionRoomId } from "./protocol.mjs";
 import { AssetUploadAdapter, AssetUploadContext, AssetUploadRequest, CreateS3AssetUploadAdapterOptions, CreateSupabaseAssetUploadAdapterOptions, S3UploadTarget, SupabaseStorageClient, createS3AssetUploadAdapter, createSupabaseAssetUploadAdapter } from "./assetStorage.mjs";
 import { i as getCredentialToken, n as StatelyCredential, r as createAuthorizationHeader, t as StatelyAuthMode } from "./auth-B0ZTKri2.mjs";
 import { c as fetchEditorSyncAccess, d as EditorHostInboundMessage, f as EditorHostInitOptions, i as EditorSyncBackend, l as EDITOR_PROTOCOL_VERSION, m as EditorHostValidationIssue, n as EditorHostSessionOptions, o as RemoteEditorSyncBackendOptions, p as EditorHostOutboundMessage, r as EditorSourceHost, s as createRemoteEditorSyncBackend, t as EditorHostSession, u as EditorHostExportFormat } from "./editorHostSession-DTXKcLhR.mjs";
 import { AssetConfig, EmbedEntity, EmbedFormatContext, EmbedFormatDefinition, EmbedGraph, EmbedProfileDefinition, StatelyEmbed, StatelyEmbedOptions, createStatelyEmbed } from "./embed.mjs";
 import { _ as createWebSocketTransport, a as InspectedTransition, c as InspectorDiscoveryEntry, d as ManualActorOptions, f as createInspector, g as createPostMessageTransport, h as TransportFailure, i as InspectedSnapshot, l as InspectorEvents, m as Transport, n as CreateInspectorOptions, o as Inspector, p as createStatelyInspector, r as InspectedEvent, s as InspectorConnection, t as AdoptedActor, u as InspectorInspectionEvent } from "./inspect-Br_vS_lK.mjs";
-import { A as Machine, C as StudioMachineRecord, D as VerifyApiKeyResponse, E as UpdateProjectInput, F as ProjectVisibility, I as VerifyResult, L as XStateVersion, M as Project, N as ProjectMachineSummary, O as createStatelyClient, P as ProjectSummary, R as ResourceErrorCode, S as StudioClientOptions, T as UpdateMachineInput, _ as ProjectMachine, a as CreateMachineTemplate, b as StudioApiErrorOptions, c as EnsureProjectInput, d as ExtractedMachine, f as GetMachineOptions, g as ProjectData, h as LegacyUpdateMachineInput, i as CreateMachineInput, j as MachineVersion, k as ExtractedMachines, l as ExtractMachinesInput, m as LegacyProjectVisibility, n as CreateMachineFromDefinitionInput, o as CreateProjectInput, r as CreateMachineFromTemplateInput, s as DEFAULT_STATELY_BASE_URL, t as ConnectedRepo, u as ExtractMachinesResponse, v as RepoType, w as StudioRequestOptions, x as StudioClient, y as StudioApiError } from "./studio-CkrbMK00.mjs";
+import { A as Machine, C as StudioMachineRecord, D as VerifyApiKeyResponse, E as UpdateProjectInput, F as ProjectVisibility, I as VerifyResult, L as XStateVersion, M as Project, N as ProjectMachineSummary, O as createStatelyClient, P as ProjectSummary, R as ResourceErrorCode, S as StudioClientOptions, T as UpdateMachineInput, _ as ProjectMachine, a as CreateMachineTemplate, b as StudioApiErrorOptions, c as EnsureProjectInput, d as ExtractedMachine, f as GetMachineOptions, g as ProjectData, h as LegacyUpdateMachineInput, i as CreateMachineInput, j as MachineVersion, k as ExtractedMachines, l as ExtractMachinesInput, m as LegacyProjectVisibility, n as CreateMachineFromDefinitionInput, o as CreateProjectInput, r as CreateMachineFromTemplateInput, s as DEFAULT_STATELY_BASE_URL, t as ConnectedRepo, u as ExtractMachinesResponse, v as RepoType, w as StudioRequestOptions, x as StudioClient, y as StudioApiError } from "./studio-erXbdakn.mjs";
 import { OAuthAuthorizationServerMetadata, OAuthClientRegistrationResponse, OAuthProtectedResourceMetadata, OAuthTokenResponse, PkcePair, buildAuthorizeUrl, createPkcePair, discoverAuthorizationServer, discoverProtectedResource, exchangeCodeForToken, refreshToken, registerOAuthClient } from "./oauth.mjs";
 import { PlanSyncOptions, PullSyncResult, PushLocalMachineLinksResult, PushSyncOptions, PushSyncProjectOptions, PushSyncResult, ResolvedSyncInput, SyncInputFormat, SyncPlan, SyncPlanSummary } from "./sync.mjs";
 import { CreateInspectionRelayOptions, InspectionRelay, InspectionRelayEffect, InspectionRelayPeer, InspectionRelayRole, InspectionRelaySnapshot, createInspectionRelay } from "./relay.mjs";

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import "./openapi-BTDjYWXd.mjs";
 import { EMBED_DOCUMENT_LANGUAGES, EMBED_DOCUMENT_LIMITS, INSPECTION_PROTOCOL_VERSION, INSPECTION_ROOM_QUERY_PARAM, createInspectionActorId, createInspectionRoomUrls, getInspectionRoomId } from "./protocol.mjs";
-import { i as createWebSocketTransport, r as createPostMessageTransport } from "./version-DX-_ZovM.mjs";
+import { i as createWebSocketTransport, r as createPostMessageTransport } from "./version-BfcJU2pO.mjs";
 import { t as EDITOR_PROTOCOL_VERSION } from "./editorHostProtocol-Bko7wge8.mjs";
 import { createStatelyEmbed } from "./embed.mjs";
 import { i as fetchEditorSyncAccess, r as createRemoteEditorSyncBackend, t as EditorHostSession } from "./editorHostSession-BwS-EiBJ.mjs";
 import { n as StudioApiError, r as createStatelyClient, t as DEFAULT_STATELY_BASE_URL } from "./studio-iNSHtNmP.mjs";
-import { a as RawCode, c as eventsSchemaToTSType, d as jsonSchemaToTSType, l as graphToMachineConfig, m as serializeJS, n as getStatelyPragma, o as contextSchemaToTSType, p as raw, r as upsertStatelyPragma, t as findStatelyPragmaAttachments, u as graphToXStateTS } from "./statelyPragma-0djA1cnm.mjs";
+import { a as RawCode, c as eventsSchemaToTSType, d as jsonSchemaToTSType, l as graphToMachineConfig, m as serializeJS, n as getStatelyPragma, o as contextSchemaToTSType, p as raw, r as upsertStatelyPragma, t as findStatelyPragmaAttachments, u as graphToXStateTS } from "./statelyPragma-B-axv279.mjs";
 import { createS3AssetUploadAdapter, createSupabaseAssetUploadAdapter } from "./assetStorage.mjs";
-import { n as createStatelyInspector, t as createInspector } from "./inspect-CWFYJT9G.mjs";
+import { n as createStatelyInspector, t as createInspector } from "./inspect-QlXh72hZ.mjs";
 import { createAuthorizationHeader, getCredentialToken } from "./auth.mjs";
 import { buildAuthorizeUrl, createPkcePair, discoverAuthorizationServer, discoverProtectedResource, exchangeCodeForToken, refreshToken, registerOAuthClient } from "./oauth.mjs";
 import { StatelyApiError, createStatelyApiClient, createStatelyApiUrl } from "./api.mjs";

package/dist/{inspect-CWFYJT9G.mjs → inspect-QlXh72hZ.mjs}

@@ -1,5 +1,5 @@
 import { INSPECTION_PROTOCOL_VERSION, createInspectionRoomUrls, getInspectionRoomId } from "./protocol.mjs";
-import { a as createEventRegistry, i as createWebSocketTransport, n as inspectionRuntime, o as createPendingExportManager, t as SDK_VERSION } from "./version-DX-_ZovM.mjs";
+import { a as createEventRegistry, i as createWebSocketTransport, n as inspectionRuntime, o as createPendingExportManager, t as SDK_VERSION } from "./version-BfcJU2pO.mjs";
 
 //#region src/openBrowser.ts
 async function openBrowser(url) {

package/dist/inspect.mjs

@@ -1,4 +1,4 @@
-import "./version-DX-_ZovM.mjs";
-import { n as createStatelyInspector, t as createInspector } from "./inspect-CWFYJT9G.mjs";
+import "./version-BfcJU2pO.mjs";
+import { n as createStatelyInspector, t as createInspector } from "./inspect-QlXh72hZ.mjs";
 
 export { createInspector, createStatelyInspector };

package/dist/patchTypes.d.mts

@@ -1,2 +1,2 @@
-import { _ as GraphPatch, g as EditorStateType, h as CanvasColor, m as ActionLocation, v as ImplementationSourceType } from "./index-D_pO_Pr8.mjs";
+import { _ as GraphPatch, g as EditorStateType, h as CanvasColor, m as ActionLocation, v as ImplementationSourceType } from "./index-DuvCSThi.mjs";
 export { type ActionLocation, type CanvasColor, type EditorStateType, type GraphPatch, type ImplementationSourceType };

package/dist/protocol.d.mts

@@ -1,5 +1,5 @@
-import { i as ProfileManifest } from "./index-D_pO_Pr8.mjs";
-import { i as StatelyGraph } from "./graph-1fwR0Ynl.mjs";
+import { i as ProfileManifest } from "./index-DuvCSThi.mjs";
+import { i as StatelyGraph } from "./graph-BGUND7ZF.mjs";
 import { c as EditorSyncSourceLocation, f as MachineSourceLocations$1, l as EditorSyncSourceRange, t as EditorCapabilities$1, u as EditorSyncStateSourceLocation } from "./editor-sync-types-C-zWaaVk.mjs";
 
 //#region src/protocol.d.ts
@@ -65,12 +65,10 @@ interface ProjectWorkspaceCapabilities {
   deleteMachine?: ProjectWorkspaceAction;
   setRootMachine?: ProjectWorkspaceAction;
 }
-/** Serializable workspace tree rendered by project-mode embeds. */
-interface ProjectWorkspaceConfig {
-  /** Visible projects; pass one entry when embedding a single project. */
-  projects: ProjectWorkspaceProject[];
+interface ProjectWorkspaceConfigBase {
   defaultProjectId?: string;
-  backAction?: ProjectWorkspaceAction;
+  /** Optional navigation action shown above the workspace. Set to null to hide it. */
+  backAction?: ProjectWorkspaceAction | null;
   userAvatarUrl?: string;
   machineSelectionDisabled?: boolean;
   /** Optional host-backed operations for the built-in workspace controls. */
@@ -81,6 +79,14 @@ interface ProjectWorkspaceConfig {
   projectActions?: Record<string, ProjectWorkspaceAction[]>;
   machineActions?: Record<string, ProjectWorkspaceAction[]>;
 }
+/** Serializable workspace tree rendered by project-mode embeds. */
+type ProjectWorkspaceConfig = (ProjectWorkspaceConfigBase & {
+  /** Single-project mode: hides project CRUD and flattens its machines. */project: ProjectWorkspaceProject;
+  projects?: never;
+}) | (ProjectWorkspaceConfigBase & {
+  /** Multi-project mode: renders a collapsible project tree. */projects: ProjectWorkspaceProject[];
+  project?: never;
+});
 declare const EMBED_DOCUMENT_LANGUAGES: readonly ["markdown", "typescript", "javascript", "json", "xml", "mermaid", "text"];
 type EmbedDocumentLanguage = (typeof EMBED_DOCUMENT_LANGUAGES)[number];
 declare const EMBED_DOCUMENT_LIMITS: {
@@ -278,7 +284,7 @@ interface MachineInitOptions {
    * - `enabled` — whether to show the pill at all. Defaults to `false`.
    * - `mode` — `'structural'` (default) only triggers on graph-structural
    *   changes (state/transition/action/invoke/schema edits). Pure visual
-   *   changes like drag-to-position, color, and autolayout are ignored.
+   *   changes like drag-to-position, color, and layout are ignored.
    *   `'all'` triggers on any graph change.
    */
   unsavedIndicator?: {

package/dist/{statelyPragma-0djA1cnm.mjs → statelyPragma-B-axv279.mjs}

@@ -1,5 +1,6 @@
 import { a as discriminatedUnion, c as object, d as union, f as unknown, i as custom, l as record, n as array, o as literal, r as boolean, s as number, t as _enum, u as string } from "./openapi-BTDjYWXd.mjs";
 import ts from "typescript";
+import "xstate";
 import "xstate/graph";
 
 //#region ../../node_modules/.pnpm/js-yaml@4.2.0/node_modules/js-yaml/dist/js-yaml.mjs
@@ -2881,8 +2882,8 @@ function graphToMachineConfig(graph, options = {}) {
 				id: inv.invocationId ?? inv.id,
 				...inv.registryKey ? { registryKey: inv.registryKey } : void 0,
 				...inv.timeout !== void 0 ? { timeout: inv.timeout } : void 0,
-				...inv.input ? { input: inv.input } : void 0,
-				...inv.output ? { output: inv.output } : void 0
+				...inv.input !== void 0 ? { input: inv.input } : void 0,
+				...inv.output !== void 0 ? { output: inv.output } : void 0
 			})) } : void 0,
 			...node.data.output !== void 0 ? { output: node.data.output } : void 0,
 			...tags?.length ? { tags: tags.map(tagToString) } : void 0,
@@ -3436,88 +3437,117 @@ function schemasObjectToValue(node) {
 	return result;
 }
 function propertyContext(parent, key) {
+	const inherited = parent.imports ? { imports: parent.imports } : {};
+	if (parent.machineValue && (key === "actors" || key === "actorSources")) return {
+		...inherited,
+		v6: parent.v6,
+		implementationMap: true
+	};
 	if (parent.setupValue && (key === "actions" || key === "guards" || key === "actors" || key === "delays")) return {
+		...inherited,
 		v6: parent.v6,
 		implementationMap: true
 	};
 	if (parent.implementationMap) return {
+		...inherited,
 		v6: parent.v6,
 		implementationValue: true
 	};
 	if (parent.effectArgumentValue) return {
+		...inherited,
 		v6: parent.v6,
 		effectArgumentValue: true
 	};
 	if (parent.invokeValue && key === "src") return {
+		...inherited,
 		v6: parent.v6,
 		actorSourceValue: true
 	};
 	if (parent.transitionMap) return {
+		...inherited,
 		v6: parent.v6,
 		transitionValue: true
 	};
 	if (parent.transitionValue && key === "actions") return {
+		...inherited,
 		v6: parent.v6,
 		actionValue: true
 	};
 	if (parent.transitionValue && key === "context") return {
+		...inherited,
 		v6: parent.v6,
 		assignmentMap: true,
 		transitionContext: true
 	};
 	if (key === "context") return {
+		...inherited,
 		v6: parent.v6,
 		machineContextValue: true
 	};
 	if (parent.transitionValue && key === "target") return {
+		...inherited,
 		v6: parent.v6,
 		targetValue: true
 	};
 	if (parent.assignmentMap) return {
+		...inherited,
 		v6: parent.v6,
 		assignmentValue: true
 	};
 	if (key === "meta") return {
+		...inherited,
 		v6: parent.v6,
 		metaValue: true
 	};
 	if (parent.transitionValue && key === "to") return {
+		...inherited,
 		v6: parent.v6,
 		transitionValue: true
 	};
 	if (key === "entry" || key === "exit") return {
+		...inherited,
 		v6: parent.v6,
 		actionValue: true
 	};
 	if (key === "input" || key === "output") return {
+		...inherited,
 		v6: parent.v6,
 		ioValue: true
 	};
 	if (parent.ioValue || parent.ioPropertyValue) return {
+		...inherited,
 		v6: parent.v6,
 		ioPropertyValue: true
 	};
 	if (key === "invoke") return {
+		...inherited,
 		v6: parent.v6,
 		invokeValue: true
 	};
 	if (key === "timeout") return {
+		...inherited,
 		v6: parent.v6,
 		timeoutValue: true
 	};
 	if (key === "route") return {
+		...inherited,
 		v6: parent.v6,
 		routeValue: true
 	};
 	if (key === "on" || key === "after") return {
+		...inherited,
 		v6: parent.v6,
 		transitionMap: true
 	};
 	if (key === "always" || key === "choice" || key === "onDone" || key === "onError" || key === "onSnapshot" || key === "onTimeout") return {
+		...inherited,
 		v6: parent.v6,
 		transitionValue: true
 	};
-	return { v6: parent.v6 };
+	return {
+		...inherited,
+		v6: parent.v6
+	};
 }
 function fallbackFunctionTransition(fn) {
 	return { meta: {
@@ -3531,7 +3561,7 @@ function conditionText(cond) {
 function simplifyConditions(conds) {
 	const seen = /* @__PURE__ */ new Set();
 	return conds.filter((cond) => {
-		if (cond.negated) return false;
+		if (cond.negated && !cond.preserveNegation) return false;
 		const key = conditionText(cond);
 		if (seen.has(key)) return false;
 		seen.add(key);
@@ -3755,18 +3785,21 @@ function statementBranches(statements, bindings, enqName, prefixes = [{
 					...prefix,
 					conds: [...prefix.conds, { text: cond }]
 				}]);
+				const thenHasEffectiveTransition = thenBranches.every((branch) => branch.result !== void 0 && branch.result !== null || branch.actions.length > 0);
 				const elseStatements = statement.elseStatement ? ts.isBlock(statement.elseStatement) ? statement.elseStatement.statements : [statement.elseStatement] : [];
 				const elseBranches = elseStatements.length > 0 ? statementBranches(elseStatements, scopedBindings, enqName, [{
 					...prefix,
 					conds: [...prefix.conds, {
 						text: cond,
-						negated: true
+						negated: true,
+						preserveNegation: !thenHasEffectiveTransition
 					}]
 				}]) : [{
 					...prefix,
 					conds: [...prefix.conds, {
 						text: cond,
-						negated: true
+						negated: true,
+						preserveNegation: !thenHasEffectiveTransition
 					}]
 				}];
 				for (const branch of [...thenBranches, ...elseBranches]) if ("result" in branch) done.push(branch);
@@ -3877,13 +3910,34 @@ function enqueueAction(fn) {
 		}
 	};
 }
-function inlineCodeExpression(expr) {
+function inlineCodeExpression(expr, imports) {
 	return {
 		"@type": "code",
 		lang: "ts",
-		expr
+		expr,
+		...imports?.length ? { imports } : {}
 	};
 }
+function codeImportsForExpression(expression, imports) {
+	if (!imports?.size) return void 0;
+	const sourceImports = imports;
+	const file = sourceFile(`(${expression})`);
+	const found = /* @__PURE__ */ new Map();
+	const expressionNode = file.statements[0] && ts.isExpressionStatement(file.statements[0]) ? file.statements[0].expression : void 0;
+	function visit(node) {
+		if (expressionNode && ts.isIdentifier(node) && sourceImports.has(node.text) && !isShadowedWithinExpression(node, expressionNode)) {
+			const parent = node.parent;
+			if (ts.isPropertyAccessExpression(parent) && parent.name === node || ts.isPropertyAssignment(parent) && parent.name === node) {
+				ts.forEachChild(node, visit);
+				return;
+			}
+			found.set(node.text, sourceImports.get(node.text));
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(file);
+	return found.size ? [...found.values()] : void 0;
+}
 function normalizeFunctionAction(fn, _bindings) {
 	return enqueueAction(fn);
 }
@@ -3948,10 +4002,13 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 	if (context.implementationValue) {
 		if (ts.isIdentifier(node)) {
 			const binding = bindings.get(node.text);
-			if (binding) return inlineCodeExpression(ts.isFunctionDeclaration(binding) ? binding.getText() : unwrapExpression(binding).getText());
+			if (binding) {
+				const code = ts.isFunctionDeclaration(binding) ? binding.getText() : unwrapExpression(binding).getText();
+				return inlineCodeExpression(code, codeImportsForExpression(code, context.imports));
+			}
 			return;
 		}
-		return inlineCodeExpression(node.getText());
+		return inlineCodeExpression(node.getText(), codeImportsForExpression(node.getText(), context.imports));
 	}
 	if (context.machineContextValue && (ts.isArrowFunction(node) || ts.isFunctionExpression(node))) return inlineCodeExpression(node.getText());
 	if (context.targetValue) {
@@ -4018,7 +4075,8 @@ function expressionToValue(expression, bindings, context = {}, depth = 0) {
 			}
 			return expressionToValue(binding, bindings, context, depth + 1);
 		}
-		return context.metaValue ? inlineCodeExpression(node.getText()) : node.text;
+		const imported = context.imports?.get(node.text);
+		return imported ? inlineCodeExpression(node.text, [imported]) : context.metaValue ? inlineCodeExpression(node.getText()) : node.text;
 	}
 	if (ts.isObjectLiteralExpression(node)) return objectLiteralToValue(node, bindings, context, depth);
 	if (ts.isArrayLiteralExpression(node)) {
@@ -4075,6 +4133,26 @@ function collectBindings(file) {
 	}
 	return bindings;
 }
+function collectSourceImports(file) {
+	const imports = /* @__PURE__ */ new Map();
+	for (const statement of file.statements) {
+		if (!ts.isImportDeclaration(statement)) continue;
+		const moduleSpecifier = statement.moduleSpecifier;
+		if (!ts.isStringLiteral(moduleSpecifier)) continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (!namedBindings || !ts.isNamedImports(namedBindings)) continue;
+		for (const element of namedBindings.elements) {
+			const imported = element.propertyName?.text ?? element.name.text;
+			imports.set(element.name.text, {
+				package: moduleSpecifier.text,
+				import: imported,
+				local: imported === element.name.text ? void 0 : element.name.text,
+				importKind: "named"
+			});
+		}
+	}
+	return imports;
+}
 function isCreateMachineCall(node) {
 	const expression = node.expression;
 	if (ts.isIdentifier(expression)) return isMachineFactoryName(expression.text);
@@ -4173,6 +4251,7 @@ function xstateSourceToConfig(source, options = {}) {
 function extractXStateMachineConfigs(source, options = {}) {
 	const file = sourceFile(source);
 	const bindings = collectBindings(file);
+	const imports = collectSourceImports(file);
 	const found = [];
 	const profile = options.profile === "auto" || !options.profile ? detectXStateSourceProfile(source) : options.profile;
 	function visit(node) {
@@ -4182,12 +4261,17 @@ function extractXStateMachineConfigs(source, options = {}) {
 		}
 		const arg = node.arguments[0];
 		if (!arg) return;
-		const value = expressionToValue(arg, bindings, { v6: profile === "xstate-v6-alpha" });
+		const value = expressionToValue(arg, bindings, {
+			v6: profile === "xstate-v6-alpha",
+			machineValue: true,
+			imports
+		});
 		if (value && typeof value === "object" && !Array.isArray(value)) {
 			const setupArg = setupCallForCreateMachine(node, bindings)?.arguments[0];
 			const setupValue = setupArg ? expressionToValue(setupArg, bindings, {
 				v6: profile === "xstate-v6-alpha",
-				setupValue: true
+				setupValue: true,
+				imports
 			}) : null;
 			const setupRecord = setupValue && typeof setupValue === "object" && !Array.isArray(setupValue) ? Object.fromEntries(Object.entries(setupValue).filter(([, item]) => !(item && typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 0))) : {};
 			found.push({
@@ -4231,7 +4315,7 @@ function objectType(schema) {
 	const required = getRequiredKeys(schema);
 	return `{ ${Object.entries(props).map(([key, def]) => {
 		const type = jsonSchemaToTSType(resolveDef(def));
-		return `${key}${isRequiredProperty(key, def, required) ? "" : "?"}: ${type}`;
+		return `${key}${isRequiredProperty$1(key, def, required) ? "" : "?"}: ${type}`;
 	}).join("; ")} }`;
 }
 function resolveDef(def) {
@@ -4262,7 +4346,7 @@ function eventsSchemaToTSType(events) {
 		const required = getRequiredKeys(schema);
 		const extraProps = Object.entries(props).filter(([k]) => k !== "type").map(([key, def]) => {
 			const type = jsonSchemaToTSType(resolveDef(def));
-			return `${key}${isRequiredProperty(key, def, required) ? "" : "?"}: ${type}`;
+			return `${key}${isRequiredProperty$1(key, def, required) ? "" : "?"}: ${type}`;
 		});
 		if (extraProps.length === 0) return `{ type: '${eventType}' }`;
 		return `{ type: '${eventType}'; ${extraProps.join("; ")} }`;
@@ -4271,13 +4355,138 @@ function eventsSchemaToTSType(events) {
 function getRequiredKeys(schema) {
 	return new Set(Array.isArray(schema.required) ? schema.required : []);
 }
-function isRequiredProperty(key, def, required) {
+function isRequiredProperty$1(key, def, required) {
 	if (required.has(key)) return true;
 	return typeof def === "object" && def !== null && def.required === true;
 }
+function jsonSchemaToZod(schema) {
+	if (!schema) return "z.unknown()";
+	if (schema.enum) return enumToZod(schema.enum);
+	if (schema.const !== void 0) return `z.literal(${serializeJS(schema.const)})`;
+	if (schema.oneOf) return xorToZod(schema.oneOf);
+	if (schema.anyOf) return unionToZod(schema.anyOf);
+	if (schema.allOf) {
+		const schemas = schema.allOf.map(definitionToZod);
+		if (schemas.length === 0) return "z.unknown()";
+		return schemas.slice(1).reduce((result, next) => `z.intersection(${result}, ${next})`, schemas[0]);
+	}
+	if (Array.isArray(schema.type)) return unionToZod(schema.type.map((type) => ({
+		...schema,
+		type
+	})));
+	if (schema.type === "array") {
+		const items = schema.items;
+		let result;
+		if (Array.isArray(items)) result = `z.tuple(${serializeJS(items.map((item) => raw(definitionToZod(item))))})`;
+		else result = `z.array(${definitionToZod(items)})`;
+		return applyArrayConstraints(result, schema);
+	}
+	if (schema.type === "object" || schema.properties) return objectToZod(schema);
+	if (schema.type) return primitiveToZod(schema, schema.type);
+	return "z.unknown()";
+}
+/** Build a required object schema from the graph's context property map. */
+function contextSchemaToZod(context) {
+	if (!context || Object.keys(context).length === 0) return null;
+	return `z.object(${serializeJS(Object.fromEntries(Object.entries(context).map(([key, schema]) => [key, raw(jsonSchemaToZod(schema))])))})`;
+}
+/** Build an event payload schema without duplicating the discriminant. */
+function eventSchemaToZod(schema) {
+	const properties = schema.properties ?? {};
+	const payloadProperties = Object.fromEntries(Object.entries(properties).filter(([key]) => key !== "type"));
+	return jsonSchemaToZod({
+		...schema,
+		properties: payloadProperties,
+		required: Array.isArray(schema.required) ? schema.required.filter((key) => key !== "type") : void 0
+	});
+}
+function objectToZod(schema) {
+	const properties = schema.properties ?? {};
+	const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+	let result = `z.object(${serializeJS(Object.fromEntries(Object.entries(properties).map(([key, definition]) => {
+		return [key, raw(`${definitionToZod(definition)}${isRequiredProperty(key, definition, required) ? "" : ".optional()"}`)];
+	})))})`;
+	if (schema.additionalProperties === false) result += ".strict()";
+	else if (schema.additionalProperties === true || schema.additionalProperties === void 0) result += ".passthrough()";
+	else if (schema.additionalProperties) result += `.catchall(${jsonSchemaToZod(schema.additionalProperties)})`;
+	return result;
+}
+function primitiveToZod(schema, type) {
+	let result;
+	switch (type) {
+		case "string":
+			result = "z.string()";
+			if (schema.format === "email") result += ".email()";
+			if (schema.format === "uri" || schema.format === "url") result += ".url()";
+			if (schema.format === "uuid") result += ".uuid()";
+			if (schema.format === "date-time") result += ".datetime({ offset: true })";
+			if (typeof schema.minLength === "number") result += `.min(${schema.minLength})`;
+			if (typeof schema.maxLength === "number") result += `.max(${schema.maxLength})`;
+			if (schema.pattern) result += `.regex(new RegExp(${serializeJS(schema.pattern)}))`;
+			break;
+		case "number":
+		case "integer":
+			result = "z.number()";
+			if (type === "integer") result += ".int()";
+			if (typeof schema.minimum === "number") result += `.min(${schema.minimum})`;
+			if (typeof schema.maximum === "number") result += `.max(${schema.maximum})`;
+			if (typeof schema.exclusiveMinimum === "number") result += `.gt(${schema.exclusiveMinimum})`;
+			if (typeof schema.exclusiveMaximum === "number") result += `.lt(${schema.exclusiveMaximum})`;
+			if (typeof schema.multipleOf === "number") result += `.multipleOf(${schema.multipleOf})`;
+			break;
+		case "boolean":
+			result = "z.boolean()";
+			break;
+		case "null":
+			result = "z.null()";
+			break;
+		case "object":
+			result = objectToZod(schema);
+			break;
+		default:
+			result = "z.unknown()";
+			break;
+	}
+	if (schema.default !== void 0) result += `.default(${serializeJS(schema.default)})`;
+	return result;
+}
+function applyArrayConstraints(result, schema) {
+	if (typeof schema.minItems === "number") result += `.min(${schema.minItems})`;
+	if (typeof schema.maxItems === "number") result += `.max(${schema.maxItems})`;
+	return result;
+}
+function enumToZod(values) {
+	if (values.length === 0) return "z.never()";
+	if (values.every((value) => typeof value === "string")) {
+		if (values.length === 1) return `z.literal(${serializeJS(values[0])})`;
+		return `z.enum(${serializeJS(values)})`;
+	}
+	return unionToZod(values.map((value) => ({ const: value })));
+}
+function unionToZod(definitions) {
+	const schemas = definitions.map(definitionToZod);
+	if (schemas.length === 0) return "z.never()";
+	if (schemas.length === 1) return schemas[0];
+	return `z.union(${serializeJS(schemas.map((schema) => raw(schema)))})`;
+}
+function xorToZod(definitions) {
+	const schemas = definitions.map(definitionToZod);
+	if (schemas.length === 0) return "z.never()";
+	if (schemas.length === 1) return schemas[0];
+	return `z.xor(${serializeJS(schemas.map((schema) => raw(schema)))})`;
+}
+function definitionToZod(definition) {
+	if (definition === false) return "z.never()";
+	if (definition === true || definition === void 0) return "z.unknown()";
+	return jsonSchemaToZod(definition);
+}
+function isRequiredProperty(key, definition, required) {
+	if (required.has(key)) return true;
+	return typeof definition === "object" && definition !== null && definition.required === true;
+}
 function graphToXStateTS(graph, options = {}) {
 	const inferredXStateVersion = isXStateV6ProfileRef(graph.data.profile ?? "xstate-v5") ? 6 : 5;
-	const { exportStyle = "named", targetLanguage = "typescript", xstateVersion = inferredXStateVersion, ...configOptions } = options;
+	const { exportStyle = "named", targetLanguage = "typescript", xstateVersion = inferredXStateVersion, xstateV6SchemaFormat = "types", ...configOptions } = options;
 	const schemas = graph.data.schemas;
 	const impls = filterInlineImplementations(graph.data.implementations);
 	const supportsTypeSyntax = targetLanguage === "typescript";
@@ -4286,10 +4495,11 @@ function graphToXStateTS(graph, options = {}) {
 	const hasGuards = !!impls?.guards.length;
 	const hasActors = !!impls?.actors.length;
 	const hasDelays = !!impls?.delays.length;
-	const hasSetup = hasSchemas || hasActions || hasGuards || hasActors || hasDelays;
+	const hasSetup = xstateVersion === 6 || hasSchemas || hasActions || hasGuards || hasActors || hasDelays;
 	const builtInActions = getUsedBuiltInActions(graph, xstateVersion);
 	const actorSourceImports = getActorSourceImports(graph);
 	const implementationImports = getImplementationImports(impls);
+	const codeImports = getCodeExpressionImports(graph);
 	const imports = buildImports({
 		hasSetup,
 		hasActors,
@@ -4297,14 +4507,18 @@ function graphToXStateTS(graph, options = {}) {
 		builtInActions,
 		actorSourceImports,
 		implementationImports,
-		usesTypes: xstateVersion === 6 && supportsTypeSyntax && hasSchemas
+		codeImports,
+		xstateVersion,
+		usesTypes: xstateVersion === 6 && supportsTypeSyntax && hasSchemas && xstateV6SchemaFormat === "types",
+		usesZod: xstateVersion === 6 && hasSchemas && xstateV6SchemaFormat === "zod"
 	});
 	const machineConfig = xstateVersion === 6 ? toV6MachineConfig(graphToMachineConfig(graph, configOptions)) : toV5MachineConfig(graphToMachineConfig(graph, configOptions));
 	let machineExpr;
 	if (hasSetup) {
 		const setupObj = buildSetupObject(schemas, impls, {
 			includeTypeSyntax: supportsTypeSyntax,
-			xstateVersion
+			xstateVersion,
+			xstateV6SchemaFormat
 		});
 		const configStr = serializeJS(machineConfig, 2);
 		machineExpr = `setup(${serializeJS(setupObj, 0)}).createMachine(${configStr})`;
@@ -4408,7 +4622,9 @@ function toV6TransitionValue(value) {
 	if (Array.isArray(value)) return buildV6TransitionFunction(value) ?? value.map((item) => toV6TransitionValue(item));
 	if (!value || typeof value !== "object") return value;
 	const transition = value;
-	if (transition.guard || transition.description || transition.input !== void 0) return mapV6MachineConfig(transition);
+	if (transition.matches !== void 0) return buildV6TransitionFunction([transition]) ?? mapV6MachineConfig(transition);
+	if (transition.guard) return buildV6TransitionFunction([transition]) ?? mapV6MachineConfig(transition);
+	if (transition.description || transition.input !== void 0) return mapV6MachineConfig(transition);
 	const target = transition.target;
 	const context = transition.context;
 	const actionsValue = transition.actions;
@@ -4424,7 +4640,20 @@ function toV6TransitionValue(value) {
 }
 function guardCondition(value) {
 	const expression = inlineExpr(value);
-	if (!expression) return value === void 0 ? { condition: "true" } : null;
+	if (!expression) {
+		if (value === void 0) return { condition: "true" };
+		if (value && typeof value === "object" && !Array.isArray(value)) {
+			const guard = value;
+			if (typeof guard.type === "string") {
+				const params = guard.params === void 0 ? "" : `, ${serializeJS(guard.params)}`;
+				return {
+					condition: `guards[${serializeJS(guard.type)}]({ context, event }${params})`,
+					firstParam: "{ context, event, guards }"
+				};
+			}
+		}
+		return null;
+	}
 	const arrow = expression.indexOf("=>");
 	if (arrow < 0) return null;
 	const params = expression.slice(0, arrow).trim();
@@ -4432,13 +4661,28 @@ function guardCondition(value) {
 	if (body.startsWith("{")) return null;
 	return {
 		condition: body,
+		callCondition: `(${expression})({ context, event, input, output, actions, guards, children, self, system })`,
 		firstParam: params.startsWith("(") && params.endsWith(")") ? params.slice(1, -1).trim() : params
 	};
 }
+function matchesCondition(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const entries = Object.entries(value);
+	if (entries.length === 0) return "true";
+	return entries.map(([key, expected]) => `Object.is(event[${serializeJS(key)}], ${serializeJS(expected)})`).join(" && ");
+}
+function combineConditions(match, guard) {
+	if (!match || match === "true") return guard;
+	if (guard === "true") return match;
+	return `${match} && (${guard})`;
+}
 const V6_ARG_BINDINGS = [
 	"context",
 	"event",
+	"input",
+	"output",
 	"actions",
+	"guards",
 	"children",
 	"self",
 	"system"
@@ -4527,7 +4771,8 @@ function buildV6TransitionFunction(transitions) {
 	for (const item of transitions) {
 		if (!item || typeof item !== "object" || Array.isArray(item)) return;
 		const transition = item;
-		if (transition.description !== void 0 || transition.input !== void 0 || transition.matches !== void 0) return;
+		const match = transition.matches === void 0 ? void 0 : matchesCondition(transition.matches);
+		if (match === null) return;
 		const guard = guardCondition(transition.guard);
 		if (!guard) return;
 		if (guard.firstParam) {
@@ -4538,25 +4783,35 @@ function buildV6TransitionFunction(transitions) {
 		const effects = (Array.isArray(actionValue) ? actionValue : actionValue === void 0 ? [] : [actionValue]).map(actionToV6Effect);
 		if (effects.some((effect) => !effect)) return;
 		const rendered = renderV6Effects(effects.filter((effect) => Boolean(effect)), transition.context === void 0 ? void 0 : serializeJS(unwrapTemplateExpressions(transition.context)));
-		const returnValue = buildV6TransitionReturnValue({
+		const effectiveReturnValue = buildV6TransitionReturnValue({
 			target: typeof transition.target === "string" ? transition.target : void 0,
 			reenter: transition.reenter === true,
-			meta: transition.meta
-		}, rendered.contextValue);
-		if (!returnValue) return;
-		const body = [...rendered.statements.map(formatV6Statement), `return ${returnValue};`];
+			meta: transition.meta,
+			input: transition.input
+		}, rendered.contextValue) ?? "{}";
+		const body = [...rendered.statements.map(formatV6Statement), `return ${effectiveReturnValue};`];
 		if (body.length === 0) return;
 		branches.push({
-			condition: guard.condition,
+			condition: combineConditions(match, guard.condition),
+			callCondition: guard.callCondition ? combineConditions(match, guard.callCondition) : void 0,
 			body
 		});
 	}
 	if (branches.length === 0) return;
-	const generated = branches.flatMap((branch) => branch.body).join("\n");
-	const merged = mergeV6FirstParam(authoredFirstParam, inferV6ArgBindings(generated));
+	const generated = branches.flatMap((branch) => [branch.condition, ...branch.body]).join("\n");
+	let renderedBranches = branches;
+	let merged = mergeV6FirstParam(authoredFirstParam, inferV6ArgBindings(generated));
+	if (!merged) {
+		if (branches.some((branch) => !branch.callCondition)) return;
+		renderedBranches = branches.map((branch) => ({
+			...branch,
+			condition: branch.callCondition
+		}));
+		merged = mergeV6FirstParam(void 0, inferV6ArgBindings(`${renderedBranches.map((branch) => branch.condition).join("\n")}\n${generated}`));
+	}
 	if (!merged) return;
 	const lines = merged.prelude.map((statement) => `  ${statement}`);
-	for (const branch of branches) if (branch.condition === "true") lines.push(...branch.body.map((line) => `  ${line}`));
+	for (const branch of renderedBranches) if (branch.condition === "true") lines.push(...branch.body.map((line) => `  ${line}`));
 	else {
 		lines.push(`  if (${branch.condition}) {`);
 		lines.push(...branch.body.map((line) => `    ${line}`));
@@ -4612,12 +4867,13 @@ function unwrapTemplateExpressions(value) {
 	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, unwrapTemplateExpressions(item)]));
 }
 function buildV6TransitionReturnValue(transition, contextValue) {
-	if (!transition.reenter && !transition.meta && !contextValue) return transition.target ? `{ target: ${serializeJS(transition.target)} }` : void 0;
+	if (!transition.reenter && !transition.meta && !contextValue && transition.input === void 0) return transition.target ? `{ target: ${serializeJS(transition.target)} }` : void 0;
 	return serializeJS({
 		target: transition.target,
 		reenter: transition.reenter ? true : void 0,
 		meta: transition.meta,
-		context: contextValue ? raw(contextValue) : void 0
+		context: contextValue ? raw(contextValue) : void 0,
+		input: transition.input === void 0 ? void 0 : unwrapTemplateExpressions(transition.input)
 	});
 }
 function mapMachineActionFields(value, mapActions) {
@@ -4740,7 +4996,7 @@ function actionOptions(params, consumedKeys) {
 	const rest = Object.fromEntries(Object.entries(params).filter(([key, value]) => !consumedKeys.includes(key) && value !== void 0));
 	return Object.keys(rest).length ? `, ${serializeJS(rest)}` : "";
 }
-function buildImports({ hasSetup, hasActors, actors, builtInActions, actorSourceImports, implementationImports, usesTypes }) {
+function buildImports({ hasSetup, hasActors, actors, builtInActions, actorSourceImports, implementationImports, codeImports, xstateVersion, usesTypes, usesZod }) {
 	const xstateImports = [];
 	if (hasSetup) xstateImports.push("setup");
 	else xstateImports.push("createMachine");
@@ -4749,9 +5005,51 @@ function buildImports({ hasSetup, hasActors, actors, builtInActions, actorSource
 	for (const name of implementationImports) xstateImports.push(name);
 	if (usesTypes) xstateImports.push("types");
 	if (hasActors) {
-		if (actors.length > 0) xstateImports.push("fromPromise");
+		if (actors.length > 0) xstateImports.push(xstateVersion === 6 ? "createAsyncLogic" : "fromPromise");
+	}
+	const externalImports = /* @__PURE__ */ new Map();
+	for (const codeImport of codeImports) {
+		const specifier = codeImport.local && codeImport.local !== codeImport.import ? `${codeImport.import} as ${codeImport.local}` : codeImport.import;
+		if (codeImport.package === "xstate") {
+			if ((codeImport.importKind ?? "named") === "named") xstateImports.push(specifier);
+			continue;
+		}
+		if ((codeImport.importKind ?? "named") !== "named") continue;
+		const names = externalImports.get(codeImport.package) ?? /* @__PURE__ */ new Set();
+		names.add(specifier);
+		externalImports.set(codeImport.package, names);
+	}
+	const imports = [`import { ${[...new Set(xstateImports)].join(", ")} } from 'xstate';`];
+	for (const [packageName, names] of externalImports) imports.push(`import { ${[...names].sort().join(", ")} } from '${packageName}';`);
+	if (usesZod && !externalImports.get("zod")?.has("z")) imports.push("import { z } from 'zod';");
+	return imports.join("\n");
+}
+function getCodeExpressionImports(graph) {
+	const imports = /* @__PURE__ */ new Map();
+	function visit(value) {
+		if (!value || typeof value !== "object") return;
+		if (Array.isArray(value)) {
+			value.forEach(visit);
+			return;
+		}
+		const record = value;
+		if (Array.isArray(record.imports)) for (const item of record.imports) {
+			if (!item || typeof item !== "object") continue;
+			const candidate = item;
+			if (typeof candidate.package !== "string" || typeof candidate.import !== "string") continue;
+			const key = `${candidate.package}:${candidate.import}:${candidate.local ?? ""}:${candidate.importKind ?? "named"}`;
+			imports.set(key, {
+				package: candidate.package,
+				import: candidate.import,
+				local: candidate.local,
+				importKind: candidate.importKind,
+				version: candidate.version
+			});
+		}
+		Object.values(record).forEach(visit);
 	}
-	return `import { ${[...new Set(xstateImports)].join(", ")} } from 'xstate';`;
+	visit(graph);
+	return [...imports.values()];
 }
 const XSTATE_ACTOR_LOGIC_HELPERS = new Set([
 	"createMachine",
@@ -4814,7 +5112,10 @@ function buildSetupObject(schemas, impls, options) {
 	}
 	if (impls?.actions.length) setup.actions = buildActionsBlock(impls.actions, options);
 	if (impls?.guards.length) setup.guards = buildGuardsBlock(impls.guards, options);
-	if (impls?.actors.length) setup.actors = buildActorsBlock(impls.actors, options);
+	if (impls?.actors.length) setup.actors = buildActorsBlock(impls.actors, {
+		...options,
+		xstateVersion: options.xstateVersion
+	});
 	if (impls?.delays.length) setup.delays = buildDelaysBlock(impls.delays);
 	return setup;
 }
@@ -4830,7 +5131,9 @@ function buildTypesBlock(schemas, options) {
 	return Object.keys(types).length > 0 ? types : void 0;
 }
 function buildV6SchemasBlock(schemas, options) {
-	if (!schemas || !options.includeTypeSyntax) return void 0;
+	if (!schemas) return void 0;
+	if (options.xstateV6SchemaFormat === "zod") return buildV6ZodSchemasBlock(schemas);
+	if (!options.includeTypeSyntax) return void 0;
 	const result = {};
 	const contextType = contextSchemaToTSType(schemas.context);
 	if (contextType) result.context = raw(`types<${contextType}>()`);
@@ -4839,6 +5142,16 @@ function buildV6SchemasBlock(schemas, options) {
 	if (schemas.output) result.output = raw(`types<${jsonSchemaToTSType(schemas.output)}>()`);
 	return Object.keys(result).length > 0 ? result : void 0;
 }
+function buildV6ZodSchemasBlock(schemas) {
+	if (!schemas) return void 0;
+	const result = {};
+	const contextSchema = contextSchemaToZod(schemas.context);
+	if (contextSchema) result.context = raw(contextSchema);
+	if (schemas.events && Object.keys(schemas.events).length > 0) result.events = Object.fromEntries(Object.entries(schemas.events).map(([eventType, schema]) => [eventType, raw(eventSchemaToZod(schema))]));
+	if (schemas.input) result.input = raw(jsonSchemaToZod(schemas.input));
+	if (schemas.output) result.output = raw(jsonSchemaToZod(schemas.output));
+	return Object.keys(result).length > 0 ? result : void 0;
+}
 function eventPayloadSchemaToTSType(schema) {
 	const props = schema.properties ?? {};
 	const payloadProps = Object.fromEntries(Object.entries(props).filter(([key]) => key !== "type"));
@@ -4885,6 +5198,7 @@ function buildGuardsBlock(guards, options) {
 }
 function buildActorsBlock(actors, options) {
 	const block = {};
+	const actorFactory = options.xstateVersion === 6 ? "createAsyncLogic" : "fromPromise";
 	for (const actor of actors) if (actor.code?.body) {
 		const inlineExpression = getActorLogicExpression(actor.code.body);
 		if (inlineExpression) {
@@ -4893,12 +5207,12 @@ function buildActorsBlock(actors, options) {
 		}
 		const functionExpression = stripExportDefault(actor.code.body);
 		if (isCompleteFunctionExpression(functionExpression)) {
-			block[actor.name] = raw(`fromPromise(${functionExpression})`);
+			block[actor.name] = raw(options.xstateVersion === 6 ? `${actorFactory}({ run: ${functionExpression} })` : `${actorFactory}(${functionExpression})`);
 			continue;
 		}
 		const inputType = options.includeTypeSyntax && 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})`);
+		block[actor.name] = raw(options.xstateVersion === 6 ? `${actorFactory}({ run: async ({ input }${inputType ? `: { input${inputType} }` : ""}) => {\n  ${dedent(actor.code.body)}\n} })` : `${actorFactory}(async ({ input }${inputType ? `: { input${inputType} }` : ""}) => {\n  ${dedent(actor.code.body)}\n})`);
+	} else block[actor.name] = raw(options.xstateVersion === 6 ? `${actorFactory}({ run: async ({ input }) => {\n  // TODO: implement ${actor.name}\n} })` : `${actorFactory}(async ({ input }) => {\n  // TODO: implement ${actor.name}\n})`);
 	return block;
 }
 function getActorLogicExpression(code) {

package/dist/{studio-CkrbMK00.d.mts → studio-erXbdakn.d.mts}

@@ -1,4 +1,4 @@
-import { A as output, C as ZodNumber, D as ZodString, E as ZodRecord, O as ZodUnion, S as ZodNullable, T as ZodOptional, b as ZodEnum, j as $strip, k as ZodUnknown, w as ZodObject, x as ZodLiteral, y as ZodArray } from "./index-D_pO_Pr8.mjs";
+import { A as output, C as ZodNumber, D as ZodString, E as ZodRecord, O as ZodUnion, S as ZodNullable, T as ZodOptional, b as ZodEnum, j as $strip, k as ZodUnknown, w as ZodObject, x as ZodLiteral, y as ZodArray } from "./index-DuvCSThi.mjs";
 import { n as StatelyCredential, t as StatelyAuthMode } from "./auth-B0ZTKri2.mjs";
 
 //#region ../api-contract/dist/errors.d.mts

package/dist/studio.d.mts

@@ -1,2 +1,2 @@
-import { A as Machine, C as StudioMachineRecord, D as VerifyApiKeyResponse, E as UpdateProjectInput, F as ProjectVisibility, I as VerifyResult, L as XStateVersion, M as Project, N as ProjectMachineSummary, O as createStatelyClient, P as ProjectSummary, R as ResourceErrorCode, S as StudioClientOptions, T as UpdateMachineInput, _ as ProjectMachine, a as CreateMachineTemplate, b as StudioApiErrorOptions, c as EnsureProjectInput, d as ExtractedMachine, f as GetMachineOptions, g as ProjectData, h as LegacyUpdateMachineInput, i as CreateMachineInput, j as MachineVersion, k as ExtractedMachines, l as ExtractMachinesInput, m as LegacyProjectVisibility, n as CreateMachineFromDefinitionInput, o as CreateProjectInput, p as LegacyExtractMachinesOptions, r as CreateMachineFromTemplateInput, s as DEFAULT_STATELY_BASE_URL, t as ConnectedRepo, u as ExtractMachinesResponse, v as RepoType, w as StudioRequestOptions, x as StudioClient, y as StudioApiError } from "./studio-CkrbMK00.mjs";
+import { A as Machine, C as StudioMachineRecord, D as VerifyApiKeyResponse, E as UpdateProjectInput, F as ProjectVisibility, I as VerifyResult, L as XStateVersion, M as Project, N as ProjectMachineSummary, O as createStatelyClient, P as ProjectSummary, R as ResourceErrorCode, S as StudioClientOptions, T as UpdateMachineInput, _ as ProjectMachine, a as CreateMachineTemplate, b as StudioApiErrorOptions, c as EnsureProjectInput, d as ExtractedMachine, f as GetMachineOptions, g as ProjectData, h as LegacyUpdateMachineInput, i as CreateMachineInput, j as MachineVersion, k as ExtractedMachines, l as ExtractMachinesInput, m as LegacyProjectVisibility, n as CreateMachineFromDefinitionInput, o as CreateProjectInput, p as LegacyExtractMachinesOptions, r as CreateMachineFromTemplateInput, s as DEFAULT_STATELY_BASE_URL, t as ConnectedRepo, u as ExtractMachinesResponse, v as RepoType, w as StudioRequestOptions, x as StudioClient, y as StudioApiError } from "./studio-erXbdakn.mjs";
 export { ConnectedRepo, CreateMachineFromDefinitionInput, CreateMachineFromTemplateInput, CreateMachineInput, CreateMachineTemplate, CreateProjectInput, DEFAULT_STATELY_BASE_URL, EnsureProjectInput, ExtractMachinesInput, ExtractMachinesResponse, ExtractedMachine, ExtractedMachines, GetMachineOptions, LegacyExtractMachinesOptions, LegacyProjectVisibility, LegacyUpdateMachineInput, Machine, MachineVersion, Project, ProjectData, ProjectMachine, ProjectMachineSummary, ProjectSummary, ProjectVisibility, RepoType, ResourceErrorCode, StudioApiError, StudioApiErrorOptions, StudioClient, StudioClientOptions, StudioMachineRecord, StudioRequestOptions, UpdateMachineInput, UpdateProjectInput, VerifyApiKeyResponse, VerifyResult, XStateVersion, createStatelyClient };

package/dist/sync.d.mts

@@ -1,5 +1,5 @@
-import { b as DigraphConfig, i as StatelyGraph } from "./graph-1fwR0Ynl.mjs";
-import { C as StudioMachineRecord, L as XStateVersion, g as ProjectData, o as CreateProjectInput, x as StudioClient } from "./studio-CkrbMK00.mjs";
+import { b as DigraphConfig, i as StatelyGraph } from "./graph-BGUND7ZF.mjs";
+import { C as StudioMachineRecord, L as XStateVersion, g as ProjectData, o as CreateProjectInput, x as StudioClient } from "./studio-erXbdakn.mjs";
 import { GraphDiff } from "@statelyai/graph";
 
 //#region src/sync.d.ts

package/dist/sync.mjs

@@ -1,6 +1,6 @@
 import "./openapi-BTDjYWXd.mjs";
 import { r as createStatelyClient } from "./studio-iNSHtNmP.mjs";
-import { f as normalizeMachineProfile, h as xstateSourceToConfig, i as INLINE_EXPRESSION_DIRECTIVE_FIELDS, m as serializeJS, n as getStatelyPragma, r as upsertStatelyPragma, s as detectXStateSourceProfile, t as findStatelyPragmaAttachments, u as graphToXStateTS } from "./statelyPragma-0djA1cnm.mjs";
+import { f as normalizeMachineProfile, h as xstateSourceToConfig, i as INLINE_EXPRESSION_DIRECTIVE_FIELDS, m as serializeJS, n as getStatelyPragma, r as upsertStatelyPragma, s as detectXStateSourceProfile, t as findStatelyPragmaAttachments, u as graphToXStateTS } from "./statelyPragma-B-axv279.mjs";
 import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";

package/dist/{version-DX-_ZovM.mjs → version-BfcJU2pO.mjs}

@@ -333,7 +333,7 @@ function createWebSocketTransport(options) {
 
 //#endregion
 //#region src/version.ts
-const SDK_VERSION = "0.23.1";
+const SDK_VERSION = "0.25.0";
 function inspectionRuntime() {
 	if (typeof window !== "undefined") return "browser";
 	if (typeof process !== "undefined" && process.versions?.node) return "node";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/sdk",
-  "version": "0.23.1",
+  "version": "0.25.0",
   "license": "MIT",
   "bin": {
     "stately-sdk": "./dist/bin.mjs"
@@ -93,8 +93,8 @@
     "jsdom": "^27.4.0",
     "tsdown": "0.21.0-beta.2",
     "vitest": "^3.2.4",
-    "@statelyai/api-contract": "0.3.8",
-    "@statelyai/graph-tools": "0.2.2"
+    "@statelyai/api-contract": "0.3.9",
+    "@statelyai/graph-tools": "0.3.0"
   },
   "engines": {
     "node": ">=22.4"