@statelyai/sdk 0.34.2 → 0.35.0

package/dist/{openapi-BTDjYWXd.mjs → studio-Bn3alVku.mjs}

@@ -1,3 +1,5 @@
+import { createAuthorizationHeader, getCredentialToken } from "./auth.mjs";
+
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -13947,4 +13949,638 @@ var import_dist = require_dist();
 (0, import_dist.extendZodWithOpenApi)(external_exports);
 
 //#endregion
-export { discriminatedUnion as a, object as c, union as d, unknown as f, custom as i, record as l, array as n, literal as o, boolean$1 as r, number$1 as s, _enum as t, string$1 as u };
+//#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$1(),
+		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$1(),
+		issues: array(unknown()).optional(),
+		retryable: boolean$1().optional()
+	}) });
+}
+const resourceApiErrorResponseSchema = createResourceApiErrorResponseSchema();
+
+//#endregion
+//#region ../api-contract/dist/xgraph.mjs
+const looseRecordSchema = record(string$1(), unknown());
+const pointSchema = object({
+	x: number$1(),
+	y: number$1()
+});
+const nodeDataSchema = looseRecordSchema.refine((data) => !("parentId" in data), "XGraph node data must not contain parentId; use node.parentId.");
+const xgraphNodeSchema = object({
+	id: string$1(),
+	type: string$1().optional(),
+	parentId: string$1().nullable().optional(),
+	sourceId: string$1().optional(),
+	targetId: string$1().optional(),
+	label: string$1().nullable().optional(),
+	data: nodeDataSchema.optional(),
+	x: number$1().optional(),
+	y: number$1().optional(),
+	width: number$1().optional(),
+	height: number$1().optional(),
+	position: pointSchema.optional(),
+	dx: number$1().optional(),
+	dy: number$1().optional()
+}).passthrough();
+const xgraphEdgeSchema = object({
+	id: string$1(),
+	type: string$1().optional(),
+	sourceId: string$1(),
+	targetId: string$1(),
+	label: string$1().nullable().optional(),
+	data: unknown(),
+	x: number$1().optional(),
+	y: number$1().optional(),
+	width: number$1().optional(),
+	height: number$1().optional(),
+	position: pointSchema.optional(),
+	dx: number$1().optional(),
+	dy: number$1().optional()
+}).passthrough();
+/** XGraph wire shape accepted and emitted at API boundaries. */
+const xgraphSchema = object({
+	xgraphSchemaVersion: literal("1.0.0").optional(),
+	id: string$1(),
+	type: string$1().optional(),
+	parentId: string$1().nullable().optional(),
+	initialNodeId: string$1().nullable().optional(),
+	nodes: array(xgraphNodeSchema),
+	edges: array(xgraphEdgeSchema),
+	data: unknown().optional(),
+	layout: unknown().nullable().optional(),
+	annotations: array(unknown()).optional(),
+	direction: _enum([
+		"up",
+		"down",
+		"left",
+		"right"
+	]).optional(),
+	style: looseRecordSchema.optional()
+}).passthrough();
+
+//#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"])
+});
+/**
+* Entitlements for the authenticated caller.
+*
+* Internal contract: this is not published as an `/api/v1` operation. Editor
+* feature gating resolves it server-side through the resource provider and
+* hands the mapped result to the client (see
+* `packages/editor/src/entitlements`).
+*
+* `entitlements` is an open set of provider-defined strings; unknown values are
+* ignored rather than rejected.
+*/
+const entitlementsResultSchema = object({
+	subscription: object({
+		tier: string$1(),
+		status: string$1()
+	}).nullable(),
+	entitlements: array(string$1())
+});
+/**
+* Which editor format a machine's stored definition is in: `digraph` is the
+* original (legacy) editor's format, `xgraph` the current one.
+*/
+const machineDefinitionFormatSchema = _enum(["digraph", "xgraph"]);
+/**
+* `name` and `updatedAt` are optional: some upstream project envelopes only
+* return machine ids. Providers that can supply them cheaply should.
+*/
+const projectMachineSummarySchema = object({
+	machineId: string$1(),
+	name: string$1().optional(),
+	updatedAt: string$1().optional(),
+	format: machineDefinitionFormatSchema.optional()
+});
+/**
+* A project list row. It carries the project's machine roster, not just its
+* metadata, so a client can mount a whole workspace from one `projects.list`
+* response and fetch definitions lazily.
+*/
+const projectSummarySchema = object({
+	projectId: string$1(),
+	projectVersionId: string$1(),
+	name: string$1(),
+	description: string$1().nullable(),
+	visibility: projectVisibilitySchema,
+	createdAt: string$1(),
+	updatedAt: string$1(),
+	rootMachineId: string$1().nullable().optional(),
+	machines: array(projectMachineSummarySchema).optional(),
+	permissions: object({ canEdit: boolean$1() }).optional(),
+	allowedVisibility: array(projectVisibilitySchema).optional()
+});
+const projectSchema = projectSummarySchema.extend({
+	rootMachineId: string$1().nullable(),
+	machines: array(projectMachineSummarySchema),
+	permissions: object({ canEdit: boolean$1() })
+});
+const machineSchema = object({
+	machineId: string$1(),
+	name: string$1(),
+	projectId: string$1().optional(),
+	projectVersionId: string$1(),
+	definition: unknown(),
+	graph: xgraphSchema.optional(),
+	createdAt: string$1().optional(),
+	updatedAt: string$1().optional(),
+	format: machineDefinitionFormatSchema.optional()
+});
+const machineVersionSchema = object({
+	machineVersionId: string$1(),
+	machineId: string$1(),
+	versionNumber: number$1(),
+	name: string$1(),
+	definition: unknown(),
+	createdAt: string$1(),
+	updatedAt: string$1(),
+	format: machineDefinitionFormatSchema.optional()
+});
+/** Version-history row without the definition payload. */
+const machineVersionSummarySchema = object({
+	machineVersionId: string$1(),
+	machineId: string$1(),
+	versionNumber: number$1(),
+	name: string$1().nullable(),
+	status: string$1(),
+	parentVersionId: string$1().nullable(),
+	createdAt: string$1(),
+	updatedAt: string$1(),
+	format: machineDefinitionFormatSchema.optional()
+});
+/** Result of converting a machine's stored definition to XGraph in place. */
+const machinesConvertResultSchema = object({
+	machine: machineSchema,
+	created: boolean$1(),
+	version: object({
+		machineVersionId: string$1(),
+		versionNumber: number$1(),
+		name: string$1().nullable()
+	})
+});
+/**
+* A project the caller may fork a machine into, with the version ids a fork
+* can target. `projectVersionIds` is ordered as the provider reports it.
+*/
+const projectDestinationProjectSchema = object({
+	projectId: string$1(),
+	name: string$1(),
+	visibility: projectVisibilitySchema,
+	projectVersionIds: array(string$1())
+});
+/**
+* Fork destinations grouped by owner. The caller's personal projects are one
+* owner alongside each team; `ownerId` is opaque and provider-defined.
+*/
+const projectDestinationSchema = object({
+	ownerId: string$1(),
+	name: string$1(),
+	projects: array(projectDestinationProjectSchema)
+});
+/** Result of forking a machine into a new or existing project version. */
+const machinesForkResultSchema = object({
+	machine: machineSchema,
+	projectVersionId: string$1(),
+	projectId: string$1()
+});
+/**
+* The version holding a machine's pre-conversion (legacy editor) definition.
+* `versionId` is `null` when the machine has no such version, which is the
+* signal that the legacy editor cannot be re-entered for it.
+*/
+const machineLegacyVersionSchema = object({ versionId: string$1().nullable() });
+/** Result of restoring a machine's legacy-editor definition. */
+const machinesRestoreLegacyResultSchema = object({
+	machine: machineSchema,
+	version: object({
+		machineVersionId: string$1(),
+		versionNumber: number$1(),
+		name: string$1().nullable()
+	})
+});
+/**
+* Result of restoring a machine to one of its own versions.
+*
+* `capturedVersion` is the new version holding the machine's *pre-restore*
+* definition, so the restore itself is undoable. It is `null` when the restore
+* was a no-op (the machine already held that version's definition), which is
+* the signal that no history row was added.
+*/
+const machinesRestoreVersionResultSchema = object({
+	machine: machineSchema,
+	capturedVersion: machineVersionSummarySchema.nullable()
+});
+const extractedMachinesSchema = object({ machines: array(object({
+	config: record(string$1(), unknown()),
+	machineIndex: number$1().int().nonnegative().optional()
+})) });
+const projectsCreateRequestSchema = object({
+	name: string$1().min(1),
+	visibility: projectVisibilitySchema
+});
+const projectsUpdateRequestSchema = object({
+	name: string$1().min(1).optional(),
+	description: string$1().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$1().min(1),
+	xstateVersion: xstateVersionSchema,
+	name: string$1().min(1).optional(),
+	definition: unknown().optional()
+});
+const machinesUpdateRequestSchema = object({
+	name: string$1().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." });
+/**
+* `status` is canonical lowercase; providers map it to their own casing.
+* Omitting `definition` snapshots the machine's current definition.
+*/
+const machineVersionsCreateRequestSchema = object({
+	name: string$1().min(1).optional(),
+	definition: unknown().optional(),
+	status: _enum(["committed", "auto"]).optional(),
+	parentVersionId: string$1().min(1).optional()
+});
+const machinesConvertRequestSchema = object({
+	definition: xgraphSchema,
+	expectedUpdatedAt: string$1().min(1),
+	keepOriginalVersion: boolean$1().optional()
+});
+/**
+* Fork a machine into exactly one target: an existing project version, or a
+* new project to create for it. Both, or neither, is a client bug.
+*/
+const machinesForkRequestSchema = object({
+	targetProjectVersionId: string$1().min(1).optional(),
+	targetProject: object({
+		name: string$1().min(1),
+		visibility: projectVisibilitySchema,
+		teamId: string$1().min(1).optional()
+	}).optional(),
+	machineName: string$1().min(1).optional(),
+	xstateVersion: xstateVersionSchema.optional()
+}).refine((value) => value.targetProjectVersionId === void 0 !== (value.targetProject === void 0), { message: "Exactly one of `targetProjectVersionId` or `targetProject` is required." });
+const machinesRestoreLegacyRequestSchema = object({
+	versionId: string$1().min(1).optional(),
+	expectedUpdatedAt: string$1().min(1),
+	reason: string$1().optional()
+});
+const machinesRestoreVersionRequestSchema = object({ expectedUpdatedAt: string$1().min(1).optional() });
+const codeExtractMachinesRequestSchema = object({
+	code: string$1().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$1() });
+const projectsListMachinesResponseSchema = array(projectMachineSummarySchema);
+const projectsDestinationsResponseSchema = array(projectDestinationSchema);
+const machinesCreateResponseSchema = machineSchema;
+const machinesGetResponseSchema = machineSchema;
+const machinesUpdateResponseSchema = machineSchema;
+const machinesGetVersionResponseSchema = machineVersionSchema;
+const machineVersionsListResponseSchema = array(machineVersionSummarySchema);
+const machineVersionsCreateResponseSchema = machineVersionSchema;
+const machinesConvertDefinitionResponseSchema = machinesConvertResultSchema;
+const machinesForkResponseSchema = machinesForkResultSchema;
+const machinesGetLegacyVersionResponseSchema = machineLegacyVersionSchema;
+const machinesRestoreLegacyResponseSchema = machinesRestoreLegacyResultSchema;
+const machinesRestoreVersionResponseSchema = machinesRestoreVersionResultSchema;
+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 },
+	"projects.destinations": { response: projectsDestinationsResponseSchema },
+	"machines.create": {
+		request: machinesCreateRequestSchema,
+		response: machinesCreateResponseSchema
+	},
+	"machines.get": { response: machinesGetResponseSchema },
+	"machines.getVersion": { response: machinesGetVersionResponseSchema },
+	"machines.update": {
+		request: machinesUpdateRequestSchema,
+		response: machinesUpdateResponseSchema
+	},
+	"machines.versions.list": { response: machineVersionsListResponseSchema },
+	"machines.versions.create": {
+		request: machineVersionsCreateRequestSchema,
+		response: machineVersionsCreateResponseSchema
+	},
+	"machines.convertDefinition": {
+		request: machinesConvertRequestSchema,
+		response: machinesConvertDefinitionResponseSchema
+	},
+	"machines.fork": {
+		request: machinesForkRequestSchema,
+		response: machinesForkResponseSchema
+	},
+	"machines.getLegacyVersion": { response: machinesGetLegacyVersionResponseSchema },
+	"machines.restoreLegacy": {
+		request: machinesRestoreLegacyRequestSchema,
+		response: machinesRestoreLegacyResponseSchema
+	},
+	"machines.restoreVersion": {
+		request: machinesRestoreVersionRequestSchema,
+		response: machinesRestoreVersionResponseSchema
+	}
+};
+/** 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.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-CFN3-0-2.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-3ujfe2z0.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,4 +1,4 @@
-import "./openapi-BTDjYWXd.mjs";
-import { n as StudioApiError, r as createStatelyClient, t as DEFAULT_STATELY_BASE_URL } from "./studio-BZP6DaIO.mjs";
+import { n as StudioApiError, r as createStatelyClient, t as DEFAULT_STATELY_BASE_URL } from "./studio-Bn3alVku.mjs";
+import "./auth.mjs";
 
 export { DEFAULT_STATELY_BASE_URL, StudioApiError, createStatelyClient };

package/dist/{version-CUFh-PYe.mjs → version-DECst76A.mjs}

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