@statelyai/sdk 0.18.0 → 0.20.1

package/dist/{studio-txdyJHD7.mjs → schemas-b9wG-zYl.mjs}

@@ -1,5 +1,3 @@
-import { createAuthorizationHeader, getCredentialToken } from "./auth.mjs";
-
 //#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
 var _a$1;
 function $constructor(name, initializer, params) {
@@ -2830,6 +2828,17 @@ function _array(Class, element, params) {
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
+function _custom(Class, fn, _params) {
+	const norm = normalizeParams(_params);
+	norm.abort ?? (norm.abort = true);
+	return new Class({
+		type: "custom",
+		check: "custom",
+		fn,
+		...norm
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
 function _refine(Class, fn, _params) {
 	return new Class({
 		type: "custom",
@@ -4319,6 +4328,9 @@ const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
 	ZodType.init(inst, def);
 	inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
 });
+function custom(fn, _params) {
+	return _custom(ZodCustom, fn ?? (() => true), _params);
+}
 function refine(fn, _params = {}) {
 	return _refine(ZodCustom, fn, _params);
 }
@@ -4329,397 +4341,4 @@ const describe = describe$1;
 const meta = meta$1;
 
 //#endregion
-//#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 { array as a, literal as c, record as d, string as f, _enum as i, number as l, unknown as m, StudioApiError as n, boolean as o, union as p, createStatelyClient as r, discriminatedUnion as s, DEFAULT_STATELY_BASE_URL as t, object as u };
+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 as r, number as s, _enum as t, string as u };