@statelyai/sdk 0.18.0 → 0.20.1

package/dist/studio-DHGspwII.mjs

@@ -0,0 +1,397 @@
+import { c as object, d as union, f as unknown, l as record, n as array, o as literal, r as boolean, s as number, t as _enum, u as string } from "./schemas-b9wG-zYl.mjs";
+import { createAuthorizationHeader, getCredentialToken } from "./auth.mjs";
+
+//#region ../api-contract/dist/errors.mjs
+/**
+* Error shape returned by every `/api/v1` machine operation (and by the shared
+* auth guard). Each operation registers its own error schema component in the
+* OpenAPI document, so this is a factory rather than a single shared instance.
+*/
+function createApiErrorResponseSchema() {
+	return object({
+		error: string(),
+		issues: array(unknown()).optional()
+	});
+}
+const apiErrorResponseSchema = createApiErrorResponseSchema();
+/**
+* Canonical error codes for the `/api/v1` resource operations. Machine
+* operations keep the flat `{ error: string }` shape above unchanged; the
+* nested envelope below applies to resource operations only.
+*/
+const resourceErrorCodeSchema = _enum([
+	"bad_request",
+	"unauthenticated",
+	"forbidden",
+	"not_found",
+	"conflict",
+	"payload_too_large",
+	"rate_limited",
+	"capability_disabled",
+	"upstream_error",
+	"internal_error"
+]);
+/** Factory, matching `createApiErrorResponseSchema`, for per-route OpenAPI components. */
+function createResourceApiErrorResponseSchema() {
+	return object({ error: object({
+		code: resourceErrorCodeSchema,
+		message: string(),
+		issues: array(unknown()).optional(),
+		retryable: boolean().optional()
+	}) });
+}
+const resourceApiErrorResponseSchema = createResourceApiErrorResponseSchema();
+
+//#endregion
+//#region ../api-contract/dist/resources.mjs
+/**
+* Canonical schemas for persistent `/api/v1` resources plus the owned,
+* deterministic code-extraction operation.
+*
+* These models are canonical, not upstream-shaped: providers (e.g. the Stately
+* Registry adapter) are responsible for translating upstream envelopes,
+* identifier quirks and casing into these shapes. No `{ data }` envelope
+* appears anywhere; all timestamps are ISO strings.
+*/
+/**
+* XState major versions the editor targets (see
+* `packages/editor/src/formats/xstate.ts`).
+*/
+const xstateVersionSchema = union([literal(5), literal(6)]);
+const projectVisibilitySchema = _enum([
+	"public",
+	"unlisted",
+	"private"
+]);
+const verifyResultSchema = object({
+	valid: literal(true),
+	tokenScope: _enum(["user", "project"])
+});
+const projectSummarySchema = object({
+	projectId: string(),
+	projectVersionId: string(),
+	name: string(),
+	description: string().nullable(),
+	visibility: projectVisibilitySchema,
+	createdAt: string(),
+	updatedAt: string()
+});
+const projectSchema = projectSummarySchema.extend({
+	rootMachineId: string().nullable(),
+	machines: array(object({ machineId: string() }))
+});
+/**
+* `name` is optional: the Registry project envelope only returns machine ids.
+* Providers that can supply names cheaply should.
+*/
+const projectMachineSummarySchema = object({
+	machineId: string(),
+	name: string().optional()
+});
+const machineSchema = object({
+	machineId: string(),
+	name: string(),
+	projectId: string().optional(),
+	projectVersionId: string(),
+	definition: unknown(),
+	createdAt: string().optional(),
+	updatedAt: string().optional()
+});
+const machineVersionSchema = object({
+	machineVersionId: string(),
+	machineId: string(),
+	versionNumber: number(),
+	name: string(),
+	definition: unknown(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const extractedMachinesSchema = object({ machines: array(object({ config: record(string(), unknown()) })) });
+const projectsCreateRequestSchema = object({
+	name: string().min(1),
+	visibility: projectVisibilitySchema
+});
+const projectsUpdateRequestSchema = object({
+	name: string().min(1).optional(),
+	description: string().nullable().optional(),
+	visibility: projectVisibilitySchema.optional()
+}).refine((value) => value.name !== void 0 || value.description !== void 0 || value.visibility !== void 0, { message: "At least one of `name`, `description` or `visibility` is required." });
+const machinesCreateRequestSchema = object({
+	projectVersionId: string().min(1),
+	xstateVersion: xstateVersionSchema,
+	name: string().min(1).optional(),
+	definition: unknown().optional()
+});
+const machinesUpdateRequestSchema = object({
+	name: string().min(1).optional(),
+	definition: unknown().optional()
+}).refine((value) => value.name !== void 0 || value.definition !== void 0, { message: "At least one of `name` or `definition` is required." });
+const codeExtractMachinesRequestSchema = object({
+	code: string().min(1),
+	xstateVersion: xstateVersionSchema.optional()
+});
+const authVerifyResponseSchema = verifyResultSchema;
+const projectsListResponseSchema = array(projectSummarySchema);
+const projectsGetResponseSchema = projectSchema;
+const projectsCreateResponseSchema = projectSchema;
+const projectsUpdateResponseSchema = projectSchema;
+const projectsDeleteResponseSchema = object({ projectId: string() });
+const projectsListMachinesResponseSchema = array(projectMachineSummarySchema);
+const machinesCreateResponseSchema = machineSchema;
+const machinesGetResponseSchema = machineSchema;
+const machinesUpdateResponseSchema = machineSchema;
+const machinesGetVersionResponseSchema = machineVersionSchema;
+const codeExtractMachinesResponseSchema = extractedMachinesSchema;
+/**
+* Request/response schema pairs keyed by resource capability name. Kept here
+* rather than on the `Capability` metadata entries so that the capability
+* registry stays plain, serialisable data.
+*/
+const resourceOperationSchemas = {
+	"auth.verify": { response: authVerifyResponseSchema },
+	"projects.list": { response: projectsListResponseSchema },
+	"projects.create": {
+		request: projectsCreateRequestSchema,
+		response: projectsCreateResponseSchema
+	},
+	"projects.get": { response: projectsGetResponseSchema },
+	"projects.update": {
+		request: projectsUpdateRequestSchema,
+		response: projectsUpdateResponseSchema
+	},
+	"projects.delete": { response: projectsDeleteResponseSchema },
+	"projects.listMachines": { response: projectsListMachinesResponseSchema },
+	"machines.create": {
+		request: machinesCreateRequestSchema,
+		response: machinesCreateResponseSchema
+	},
+	"machines.get": { response: machinesGetResponseSchema },
+	"machines.getVersion": { response: machinesGetVersionResponseSchema },
+	"machines.update": {
+		request: machinesUpdateRequestSchema,
+		response: machinesUpdateResponseSchema
+	}
+};
+/** Provider-independent operations implemented by this repository. */
+const codeOperationSchemas = { "code.extractMachines": {
+	request: codeExtractMachinesRequestSchema,
+	response: codeExtractMachinesResponseSchema
+} };
+/** Every owned API operation with a canonical request/response contract. */
+const operationSchemas = {
+	...resourceOperationSchemas,
+	...codeOperationSchemas
+};
+
+//#endregion
+//#region src/studio.ts
+/**
+* Remote client for the owned Stately resource contract (`/api/v1/*`).
+*
+* Every method targets our own routes (never the legacy Registry API), sends
+* JSON bodies with a bearer credential, and validates responses against the
+* canonical Zod schemas from `@statelyai/api-contract`. Responses are canonical
+* values directly: there is no `{ data }` envelope. Errors use the nested
+* envelope `{ error: { code, message, issues?, retryable? } }`.
+*/
+/** Default base URL of the editor/API deployment hosting `/api/v1`. */
+const DEFAULT_STATELY_BASE_URL = "https://editor.stately.ai";
+var StudioApiError = class extends Error {
+	status;
+	/** Canonical resource error code, when the server sent one. */
+	code;
+	issues;
+	retryable;
+	constructor(message, status, options = {}) {
+		super(message);
+		this.name = "StudioApiError";
+		this.status = status;
+		this.code = options.code;
+		this.issues = options.issues;
+		this.retryable = options.retryable;
+	}
+};
+function getFetch(fetchImpl) {
+	const resolvedFetch = fetchImpl ?? globalThis.fetch;
+	if (!resolvedFetch) throw new Error("No fetch implementation available. Pass one via createStatelyClient({ fetch }).");
+	return resolvedFetch;
+}
+function joinApiUrl(baseUrl, path) {
+	return `${baseUrl.replace(/\/+$/, "")}/api/v1${path}`;
+}
+async function parseJson(response) {
+	if (!response.headers.get("content-type")?.includes("application/json")) return null;
+	return response.json().catch(() => null);
+}
+function toApiError(data, status) {
+	const parsed = resourceApiErrorResponseSchema.safeParse(data);
+	if (parsed.success) {
+		const { code, message, issues, retryable } = parsed.data.error;
+		return new StudioApiError(message, status, {
+			code,
+			issues,
+			retryable
+		});
+	}
+	if (typeof data === "object" && data !== null && "error" in data && typeof data.error === "string") return new StudioApiError(data.error, status);
+	return new StudioApiError(`HTTP ${status}`, status);
+}
+function normalizeVisibility(visibility) {
+	return visibility.toLowerCase();
+}
+function normalizeXStateVersion(xstateVersion) {
+	return xstateVersion === void 0 || xstateVersion === 4 ? 5 : xstateVersion;
+}
+function normalizeExtractXStateVersion(xstateVersion) {
+	return xstateVersion === 4 ? 5 : xstateVersion;
+}
+function withMachineAlias(machine) {
+	return {
+		...machine,
+		definition: machine.definition,
+		id: machine.machineId
+	};
+}
+function withProjectAlias(project) {
+	return {
+		...project,
+		id: project.projectVersionId
+	};
+}
+function isCredentialLike(value) {
+	if (typeof value === "string") return true;
+	return typeof value === "object" && value !== null && "type" in value && (value.type === "api_key" || value.type === "oauth");
+}
+function createStatelyClient(options = {}) {
+	const baseUrl = options.baseUrl ?? DEFAULT_STATELY_BASE_URL;
+	const fetchImpl = getFetch(options.fetch);
+	const defaultCredential = options.credential ?? (options.apiKey ? {
+		type: "api_key",
+		token: options.apiKey
+	} : void 0);
+	const defaultAuthMode = options.authMode ?? "auto";
+	async function request(path, init, schema, requestOptions = {}) {
+		const headers = new Headers(init.headers);
+		const authMode = requestOptions.authMode ?? defaultAuthMode;
+		const credential = requestOptions.credential ?? defaultCredential;
+		if (authMode !== "none") {
+			const token = getCredentialToken(credential);
+			if (authMode === "bearer" && (!token || !credential)) throw new StudioApiError("No Stately credential configured. Pass createStatelyClient({ credential }) or use authMode: \"auto\" to let the server decide whether authentication is required.", 401, { code: "unauthenticated" });
+			if (token && credential) headers.set("Authorization", createAuthorizationHeader(credential));
+		}
+		const response = await fetchImpl(joinApiUrl(baseUrl, path), {
+			...init,
+			headers,
+			...requestOptions.signal ? { signal: requestOptions.signal } : {}
+		});
+		const data = await parseJson(response);
+		if (!response.ok) throw toApiError(data, response.status);
+		const parsed = schema.safeParse(data);
+		if (!parsed.success) throw new StudioApiError(`Unexpected response for ${path}: ${parsed.error.message}`, response.status, {
+			code: "internal_error",
+			issues: [...parsed.error.issues]
+		});
+		return parsed.data;
+	}
+	function jsonInit(method, body) {
+		return {
+			method,
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		};
+	}
+	const projects = {
+		list(requestOptions) {
+			return request("/projects", { method: "GET" }, projectsListResponseSchema, requestOptions);
+		},
+		create(input, requestOptions) {
+			return request("/projects", jsonInit("POST", {
+				name: input.name,
+				visibility: normalizeVisibility(input.visibility)
+			}), projectSchema, requestOptions).then(withProjectAlias);
+		},
+		get(projectId, requestOptions) {
+			return request(`/projects/${encodeURIComponent(projectId)}`, { method: "GET" }, projectSchema, requestOptions).then(withProjectAlias);
+		},
+		update(projectId, input, requestOptions) {
+			return request(`/projects/${encodeURIComponent(projectId)}`, jsonInit("PATCH", {
+				...input.name !== void 0 ? { name: input.name } : {},
+				...input.description !== void 0 ? { description: input.description } : {},
+				...input.visibility !== void 0 ? { visibility: normalizeVisibility(input.visibility) } : {}
+			}), projectSchema, requestOptions).then(withProjectAlias);
+		},
+		delete(projectId, requestOptions) {
+			return request(`/projects/${encodeURIComponent(projectId)}`, { method: "DELETE" }, projectsDeleteResponseSchema, requestOptions);
+		},
+		listMachines(projectId, requestOptions) {
+			return request(`/projects/${encodeURIComponent(projectId)}/machines`, { method: "GET" }, projectsListMachinesResponseSchema, requestOptions);
+		},
+		async ensure(input, requestOptions) {
+			if (input.matchConnectedRepo !== false) {
+				const match = (await projects.list(requestOptions)).find((candidate) => candidate.name === input.name);
+				if (match) return projects.get(match.projectId, requestOptions);
+			}
+			return projects.create(input, requestOptions);
+		}
+	};
+	const machines = {
+		create(input, requestOptions) {
+			return request("/machines", jsonInit("POST", {
+				projectVersionId: input.projectVersionId,
+				xstateVersion: normalizeXStateVersion(input.xstateVersion),
+				...input.name !== void 0 ? { name: input.name } : {},
+				...input.definition !== void 0 ? { definition: input.definition } : {}
+			}), machineSchema, requestOptions).then((machine) => withMachineAlias(machine));
+		},
+		async createMany(input, requestOptions) {
+			return [await machines.create(input, requestOptions)];
+		},
+		get(machineId, getOptions = {}) {
+			return request(`/machines/${encodeURIComponent(machineId)}`, { method: "GET" }, machineSchema, getOptions).then((machine) => withMachineAlias(machine));
+		},
+		getVersion(machineId, versionId, requestOptions) {
+			return request(`/machines/${encodeURIComponent(machineId)}/versions/${encodeURIComponent(versionId)}`, { method: "GET" }, machineVersionSchema, requestOptions);
+		},
+		update(machineIdOrInput, inputOrOptions, maybeOptions) {
+			const machineId = typeof machineIdOrInput === "string" ? machineIdOrInput : machineIdOrInput.machineId ?? machineIdOrInput.id;
+			if (!machineId) throw new StudioApiError("machines.update requires a machine id.", 400, { code: "bad_request" });
+			const input = (typeof machineIdOrInput === "string" ? inputOrOptions : machineIdOrInput) ?? {};
+			const requestOptions = typeof machineIdOrInput === "string" ? maybeOptions : inputOrOptions;
+			return request(`/machines/${encodeURIComponent(machineId)}`, jsonInit("PATCH", {
+				...input.name !== void 0 ? { name: input.name } : {},
+				...input.definition !== void 0 ? { definition: input.definition } : {}
+			}), machineSchema, requestOptions).then((machine) => withMachineAlias(machine));
+		}
+	};
+	return {
+		auth: { verify(credentialOrOptions, verifyOptions) {
+			return request("/auth/verify", { method: "GET" }, verifyResultSchema, isCredentialLike(credentialOrOptions) ? {
+				...verifyOptions,
+				credential: credentialOrOptions
+			} : credentialOrOptions ?? verifyOptions ?? {});
+		} },
+		projects,
+		machines,
+		code: { extractMachines(codeOrInput, extractOptions = {}) {
+			const input = typeof codeOrInput === "string" ? {
+				code: codeOrInput,
+				xstateVersion: extractOptions.xstateVersion
+			} : codeOrInput;
+			const legacyOptions = extractOptions;
+			const credential = legacyOptions.credential ?? (legacyOptions.apiKey ? {
+				type: "api_key",
+				token: legacyOptions.apiKey
+			} : void 0);
+			return request("/code/extract-machines", jsonInit("POST", {
+				code: input.code,
+				xstateVersion: normalizeExtractXStateVersion(input.xstateVersion)
+			}), extractedMachinesSchema, {
+				...extractOptions,
+				credential
+			});
+		} }
+	};
+}
+
+//#endregion
+export { StudioApiError as n, createStatelyClient as r, DEFAULT_STATELY_BASE_URL as t };

package/dist/{studio-Bk_u41gu.d.mts → studio-YSppd-am.d.mts}

@@ -1,5 +1,5 @@
-import { A as $strip, C as ZodObject, D as ZodUnion, E as ZodString, O as ZodUnknown, S as ZodNumber, T as ZodRecord, b as ZodLiteral, k as output, v as ZodArray, w as ZodOptional, x as ZodNullable, y as ZodEnum } from "./index-ag6K2iAS.mjs";
-import { n as StatelyCredential, t as StatelyAuthMode } from "./auth-2Thaw42j.mjs";
+import { A as $strip, C as ZodObject, D as ZodUnion, E as ZodString, O as ZodUnknown, S as ZodNumber, T as ZodRecord, b as ZodLiteral, k as output, v as ZodArray, w as ZodOptional, x as ZodNullable, y as ZodEnum } from "./index-BAkQThnl.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-Bk_u41gu.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-YSppd-am.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/studio.mjs

@@ -1,3 +1,3 @@
-import { n as StudioApiError, r as createStatelyClient, t as DEFAULT_STATELY_BASE_URL } from "./studio-txdyJHD7.mjs";
+import { n as StudioApiError, r as createStatelyClient, t as DEFAULT_STATELY_BASE_URL } from "./studio-DHGspwII.mjs";
 
 export { DEFAULT_STATELY_BASE_URL, StudioApiError, createStatelyClient };

package/dist/sync.d.mts

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

package/dist/sync.mjs

@@ -1,5 +1,5 @@
-import { r as createStatelyClient } from "./studio-txdyJHD7.mjs";
-import { i as INLINE_EXPRESSION_DIRECTIVE_FIELDS, m as xstateSourceToConfig, n as getStatelyPragma, p as serializeJS, r as upsertStatelyPragma, s as detectXStateSourceProfile, t as findStatelyPragmaAttachments, u as graphToXStateTS } from "./statelyPragma-Bm9O4XV6.mjs";
+import { r as createStatelyClient } from "./studio-DHGspwII.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-CIzsR_Sx.mjs";
 import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
@@ -157,7 +157,8 @@ function collectXStateSourceLocations(sourceText, document, options = {}) {
 	const inferredProfile = rootProfile === "xstate-v6-alpha" || resolvedTransitionFunctions.size > 0 || [...referencedStateSymbols].some((symbol) => detectXStateSourceProfile(bindings.get(symbol)?.sourceFile.text ?? "") === "xstate-v6-alpha") ? "xstate-v6-alpha" : rootProfile;
 	return {
 		version: 1,
-		profile: packageProfile ?? inferredProfile,
+		profile: packageProfile?.profile ?? inferredProfile,
+		profileRef: packageProfile?.profileRef ?? normalizeMachineProfile(inferredProfile),
 		root: {
 			uri,
 			range: toSourceRange$1(sourceFile, root)
@@ -198,10 +199,16 @@ function detectXStatePackageProfile(packageJson) {
 		}
 	}
 	if (!range) return void 0;
-	const clauseProfiles = range.replace(/^(?:workspace:|npm:xstate@)/, "").split("||").map((clause) => detectXStateRangeClauseProfile(clause.trim()));
+	const normalizedRange = range.replace(/^(?:workspace:|npm:xstate@)/, "");
+	const clauseProfiles = normalizedRange.split("||").map((clause) => detectXStateRangeClauseProfile(clause.trim()));
 	const profiles = new Set(clauseProfiles);
 	if (profiles.size !== 1 || profiles.has(void 0)) return void 0;
-	return clauseProfiles[0];
+	const profile = clauseProfiles[0];
+	if (!profile) return void 0;
+	return {
+		profile,
+		profileRef: /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(normalizedRange) ? `@statelyai/xstate@${normalizedRange}` : normalizeMachineProfile(profile)
+	};
 }
 function detectXStateRangeClauseProfile(clause) {
 	const normalizedClause = clause.replace(/([<>]=?)\s+/g, "$1");

package/dist/{transport-CyCrdKyz.mjs → version-YJizbJxR.mjs}

@@ -166,12 +166,13 @@ function createPostMessageTransport(options) {
 		}
 		const data = e.data;
 		if (!data?.type?.startsWith?.(PREFIX)) return;
-		if (data.type === "@statelyai.ready" && !isReady) {
-			isReady = true;
+		const becameReady = data.type === "@statelyai.ready" && !isReady;
+		if (becameReady) isReady = true;
+		messageHandlers.forEach((fn) => fn(data));
+		if (becameReady) {
 			readyHandlers.forEach((fn) => fn());
 			readyHandlers.clear();
 		}
-		messageHandlers.forEach((fn) => fn(data));
 	}
 	window.addEventListener("message", handleMessage);
 	return {
@@ -326,4 +327,13 @@ function createWebSocketTransport(options) {
 }
 
 //#endregion
-export { toInitMessage as a, createPendingExportManager as i, createWebSocketTransport as n, createEventRegistry as r, createPostMessageTransport as t };
+//#region src/version.ts
+const SDK_VERSION = "0.20.1";
+function inspectionRuntime() {
+	if (typeof window !== "undefined") return "browser";
+	if (typeof process !== "undefined" && process.versions?.node) return "node";
+	return "unknown";
+}
+
+//#endregion
+export { createEventRegistry as a, createWebSocketTransport as i, inspectionRuntime as n, createPendingExportManager as o, createPostMessageTransport as r, toInitMessage as s, SDK_VERSION as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/sdk",
-  "version": "0.18.0",
+  "version": "0.20.1",
   "license": "MIT",
   "bin": {
     "stately-sdk": "./dist/bin.mjs"
@@ -61,6 +61,10 @@
       "types": "./dist/protocol.d.mts",
       "import": "./dist/protocol.mjs"
     },
+    "./editor-host": {
+      "types": "./dist/editorHostSession.d.mts",
+      "import": "./dist/editorHostSession.mjs"
+    },
     "./relay": {
       "types": "./dist/relay.d.mts",
       "import": "./dist/relay.mjs"
@@ -89,8 +93,8 @@
     "jsdom": "^27.4.0",
     "tsdown": "0.21.0-beta.2",
     "vitest": "^3.2.4",
-    "@statelyai/api-contract": "0.0.2",
-    "@statelyai/graph-tools": "0.0.8"
+    "@statelyai/api-contract": "0.1.1",
+    "@statelyai/graph-tools": "0.0.9"
   },
   "engines": {
     "node": ">=22.4"