@statelyai/sdk 0.39.1 → 0.41.0

package/dist/{studio-DL0yj2Pi.mjs → schemas-DsQ8UYlM.mjs}

@@ -1,340 +1,5 @@
-import { createAuthorizationHeader, getCredentialToken } from "./auth.mjs";
+import { r as __exportAll } from "./chunk-D1OLi6Wq.mjs";
 
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.5.0_zod@4.4.3/node_modules/@asteasolutions/zod-to-openapi/dist/index.cjs
-var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/******************************************************************************
-	Copyright (c) Microsoft Corporation.
-	
-	Permission to use, copy, modify, and/or distribute this software for any
-	purpose with or without fee is hereby granted.
-	
-	THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-	REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-	AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-	INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-	OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-	PERFORMANCE OF THIS SOFTWARE.
-	***************************************************************************** */
-	function __rest(s, e) {
-		var t = {};
-		for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-		if (s != null && typeof Object.getOwnPropertySymbols === "function") {
-			for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-		}
-		return t;
-	}
-	const ZodTypeKeys = {
-		ZodAny: "any",
-		ZodArray: "array",
-		ZodBigInt: "bigint",
-		ZodBoolean: "boolean",
-		ZodDefault: "default",
-		ZodPrefault: "prefault",
-		ZodTransform: "transform",
-		ZodEnum: "enum",
-		ZodIntersection: "intersection",
-		ZodLazy: "lazy",
-		ZodLiteral: "literal",
-		ZodNever: "never",
-		ZodNull: "null",
-		ZodNullable: "nullable",
-		ZodNumber: "number",
-		ZodNonOptional: "nonoptional",
-		ZodObject: "object",
-		ZodOptional: "optional",
-		ZodPipe: "pipe",
-		ZodReadonly: "readonly",
-		ZodRecord: "record",
-		ZodString: "string",
-		ZodTuple: "tuple",
-		ZodType: "type",
-		ZodUnion: "union",
-		ZodDiscriminatedUnion: "union",
-		ZodUnknown: "unknown",
-		ZodVoid: "void",
-		ZodDate: "date",
-		ZodTemplateLiteral: "template_literal"
-	};
-	function isZodType(schema, typeNames) {
-		return (Array.isArray(typeNames) ? typeNames : [typeNames]).some((typeName) => {
-			var _a;
-			const typeNameMatch = ((_a = schema === null || schema === void 0 ? void 0 : schema.def) === null || _a === void 0 ? void 0 : _a.type) === ZodTypeKeys[typeName];
-			if (typeName === "ZodDiscriminatedUnion") return typeNameMatch && "discriminator" in schema.def;
-			return typeNameMatch;
-		});
-	}
-	function isAnyZodType(schema) {
-		return schema && "def" in schema;
-	}
-	var $ZodRegistry = class {
-		constructor() {
-			this._map = /* @__PURE__ */ new Map();
-			this._idmap = /* @__PURE__ */ new Map();
-		}
-		add(schema, ..._meta) {
-			const meta = _meta[0];
-			this._map.set(schema, meta);
-			if (meta && typeof meta === "object" && "id" in meta) {
-				if (this._idmap.has(meta.id)) throw new Error(`ID ${meta.id} already exists in the registry`);
-				this._idmap.set(meta.id, schema);
-			}
-			return this;
-		}
-		clear() {
-			this._map = /* @__PURE__ */ new Map();
-			this._idmap = /* @__PURE__ */ new Map();
-			return this;
-		}
-		remove(schema) {
-			const meta = this._map.get(schema);
-			if (meta && typeof meta === "object" && "id" in meta) this._idmap.delete(meta.id);
-			this._map.delete(schema);
-			return this;
-		}
-		get(schema) {
-			const p = schema._zod.parent;
-			if (p) {
-				const pm = { ...this.get(p) ?? {} };
-				delete pm.id;
-				return {
-					...pm,
-					...this._map.get(schema)
-				};
-			}
-			return this._map.get(schema);
-		}
-		has(schema) {
-			return this._map.has(schema);
-		}
-	};
-	function registry() {
-		return new $ZodRegistry();
-	}
-	function isUndefined(value) {
-		return value === void 0;
-	}
-	function omit(object, keys) {
-		const result = {};
-		Object.entries(object).forEach(([key, value]) => {
-			if (!keys.some((keyToOmit) => keyToOmit === key)) result[key] = value;
-		});
-		return result;
-	}
-	function omitBy(object, predicate) {
-		const result = {};
-		Object.entries(object).forEach(([key, value]) => {
-			if (!predicate(value, key)) result[key] = value;
-		});
-		return result;
-	}
-	/**
-	* @deprecated This is not really deprecated but this should always be used with
-	* caution. Using it may alter the behavior of the library and the generated schemas.
-	*/
-	const zodToOpenAPIRegistry = registry();
-	var Metadata = class {
-		static collectMetadata(schema, metadata) {
-			const currentMetadata = this.getMetadataFromRegistry(schema);
-			const _internal = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata._internal), metadata === null || metadata === void 0 ? void 0 : metadata._internal);
-			const param = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), metadata === null || metadata === void 0 ? void 0 : metadata.param);
-			const totalMetadata = Object.assign(Object.assign(Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : {}), currentMetadata), metadata), Object.keys(param).length > 0 ? { param } : {});
-			if (isZodType(schema, [
-				"ZodOptional",
-				"ZodNullable",
-				"ZodDefault",
-				"ZodPrefault",
-				"ZodReadonly",
-				"ZodNonOptional"
-			]) && isAnyZodType(schema._zod.def.innerType)) return this.collectMetadata(schema._zod.def.innerType, totalMetadata);
-			if (isZodType(schema, "ZodPipe")) {
-				const inSchema = schema._zod.def.in;
-				const outSchema = schema._zod.def.out;
-				if (isZodType(inSchema, "ZodTransform") && isAnyZodType(outSchema)) return this.collectMetadata(outSchema, totalMetadata);
-				if (isAnyZodType(inSchema)) return this.collectMetadata(inSchema, totalMetadata);
-			}
-			return totalMetadata;
-		}
-		/**
-		* @deprecated Use one of `getOpenApiMetadata` or `getInternalMetadata` instead
-		*/
-		static getMetadata(zodSchema) {
-			return this.collectMetadata(zodSchema);
-		}
-		static getOpenApiMetadata(zodSchema) {
-			const metadata = this.collectMetadata(zodSchema);
-			const _a = metadata !== null && metadata !== void 0 ? metadata : {}, { _internal } = _a;
-			return __rest(_a, ["_internal"]);
-		}
-		static getInternalMetadata(zodSchema) {
-			var _a;
-			return (_a = this.collectMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a._internal;
-		}
-		static getParamMetadata(zodSchema) {
-			const metadata = this.collectMetadata(zodSchema);
-			return Object.assign(Object.assign({}, metadata), { param: Object.assign(Object.assign({}, (metadata === null || metadata === void 0 ? void 0 : metadata.description) ? { description: metadata.description } : {}), metadata === null || metadata === void 0 ? void 0 : metadata.param) });
-		}
-		/**
-		* A method that omits all custom keys added to the regular OpenAPI
-		* metadata properties
-		*/
-		static buildSchemaMetadata(metadata) {
-			return omitBy(omit(metadata, ["param", "_internal"]), isUndefined);
-		}
-		static buildParameterMetadata(metadata) {
-			return omitBy(metadata, isUndefined);
-		}
-		static applySchemaMetadata(initialData, metadata) {
-			return omitBy(Object.assign(Object.assign({}, initialData), this.buildSchemaMetadata(metadata)), isUndefined);
-		}
-		static getRefId(zodSchema) {
-			var _a;
-			return (_a = this.getInternalMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a.refId;
-		}
-		static unwrapChained(schema) {
-			return this.unwrapUntil(schema);
-		}
-		static getDefaultValue(zodSchema) {
-			var _a;
-			const unwrapped = (_a = this.unwrapUntil(zodSchema, "ZodDefault")) !== null && _a !== void 0 ? _a : this.unwrapUntil(zodSchema, "ZodPrefault");
-			return unwrapped === null || unwrapped === void 0 ? void 0 : unwrapped._zod.def.defaultValue;
-		}
-		static unwrapUntil(schema, typeName) {
-			if (typeName && isZodType(schema, typeName)) return schema;
-			if (isZodType(schema, [
-				"ZodOptional",
-				"ZodNullable",
-				"ZodDefault",
-				"ZodPrefault",
-				"ZodReadonly",
-				"ZodNonOptional"
-			]) && isAnyZodType(schema._zod.def.innerType)) return this.unwrapUntil(schema._zod.def.innerType, typeName);
-			if (isZodType(schema, "ZodPipe")) {
-				const inSchema = schema._zod.def.in;
-				const outSchema = schema._zod.def.out;
-				if (isZodType(inSchema, "ZodTransform") && isAnyZodType(outSchema)) return this.unwrapUntil(outSchema, typeName);
-				if (isAnyZodType(inSchema)) return this.unwrapUntil(inSchema, typeName);
-			}
-			return typeName ? void 0 : schema;
-		}
-		static getMetadataFromInternalRegistry(zodSchema) {
-			return zodToOpenAPIRegistry.get(zodSchema);
-		}
-		static getMetadataFromRegistry(zodSchema) {
-			const internal = this.getMetadataFromInternalRegistry(zodSchema);
-			const general = zodSchema.meta();
-			if (!internal) return general;
-			const { _internal } = internal, rest = __rest(internal, ["_internal"]);
-			const _a = general !== null && general !== void 0 ? general : {}, { id, title } = _a, restGeneral = __rest(_a, ["id", "title"]);
-			return Object.assign(Object.assign(Object.assign({ _internal: Object.assign(Object.assign({}, id ? { refId: id } : {}), _internal) }, rest), title ? { description: title } : {}), restGeneral);
-		}
-		static setMetadataInRegistry(zodSchema, metadata) {
-			zodToOpenAPIRegistry.add(zodSchema, metadata);
-		}
-	};
-	function preserveMetadataFromModifier(zodSchema, modifier) {
-		const zodModifier = zodSchema[modifier];
-		if (typeof zodModifier !== "function") return;
-		zodSchema[modifier] = function(...args) {
-			const result = zodModifier.apply(this, args);
-			const meta = Metadata.getMetadataFromRegistry(this);
-			if (meta) Metadata.setMetadataInRegistry(result, meta);
-			return result;
-		};
-	}
-	function extendZodWithOpenApi(zod) {
-		if (typeof zod.ZodType.prototype.openapi !== "undefined") return;
-		zod.ZodType.prototype.openapi = function(...args) {
-			const { refId, metadata, options } = getOpenApiConfiguration(...args);
-			const _a = metadata !== null && metadata !== void 0 ? metadata : {}, { param } = _a, restOfOpenApi = __rest(_a, ["param"]);
-			const allMetadata = Metadata.getMetadataFromRegistry(this);
-			const _b = allMetadata !== null && allMetadata !== void 0 ? allMetadata : {}, { _internal: internalMetadata } = _b, currentMetadata = __rest(_b, ["_internal"]);
-			const _internal = Object.assign(Object.assign(Object.assign({}, internalMetadata), options), refId ? { refId } : void 0);
-			const resultMetadata = Object.assign(Object.assign(Object.assign({}, currentMetadata), restOfOpenApi), (currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param) || param ? { param: Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), param) } : void 0);
-			const result = new this.constructor(this._def);
-			function setMetadata(schema) {
-				Metadata.setMetadataInRegistry(schema, Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : void 0), resultMetadata));
-			}
-			setMetadata(result);
-			/**
-			* In order to handle z.json() which is implemented as:
-			*
-			* const jsonSchema = lazy(() => { return union([ ... ]) });
-			* return jsonSchema;
-			*
-			* We need to not only set the metadata to the resulting schema (which would be different
-			* from `jsonSchema`), but also to the original lazy schema so that the _internal metadata (refId)
-			* is also present in the internally used `jsonSchema`.
-			*/
-			if (isZodType(result, "ZodLazy")) setMetadata(this);
-			if (isZodType(result, "ZodObject")) {
-				const currentMetadata = Metadata.getMetadataFromRegistry(result);
-				const originalExtend = result.extend;
-				result.extend = function(...args) {
-					const extendedResult = originalExtend.apply(result, args);
-					const _a = currentMetadata !== null && currentMetadata !== void 0 ? currentMetadata : {}, { _internal } = _a, rest = __rest(_a, ["_internal"]);
-					Metadata.setMetadataInRegistry(extendedResult, { _internal: { extendedFrom: (_internal === null || _internal === void 0 ? void 0 : _internal.refId) ? {
-						refId: _internal.refId,
-						schema: result
-					} : _internal === null || _internal === void 0 ? void 0 : _internal.extendedFrom } });
-					return extendedResult.openapi(rest);
-				};
-				preserveMetadataFromModifier(result, "catchall");
-			}
-			preserveMetadataFromModifier(result, "optional");
-			preserveMetadataFromModifier(result, "nullable");
-			preserveMetadataFromModifier(result, "default");
-			preserveMetadataFromModifier(result, "transform");
-			preserveMetadataFromModifier(result, "refine");
-			preserveMetadataFromModifier(result, "length");
-			preserveMetadataFromModifier(result, "min");
-			preserveMetadataFromModifier(result, "max");
-			const originalMeta = result.meta;
-			result.meta = function(...args) {
-				const result = originalMeta.apply(this, args);
-				if (args[0]) {
-					const meta = Metadata.getMetadataFromInternalRegistry(this);
-					if (meta) Metadata.setMetadataInRegistry(result, Object.assign(Object.assign({}, meta), args[0]));
-				}
-				return result;
-			};
-			return result;
-		};
-	}
-	function getOpenApiConfiguration(refOrOpenapi, metadataOrOptions, options) {
-		if (typeof refOrOpenapi === "string") return {
-			refId: refOrOpenapi,
-			metadata: metadataOrOptions,
-			options
-		};
-		return {
-			refId: void 0,
-			metadata: refOrOpenapi,
-			options: metadataOrOptions
-		};
-	}
-	exports.extendZodWithOpenApi = extendZodWithOpenApi;
-}));
-
-//#endregion
 //#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
 var _a$1;
 /** A special constant with type `never` */
@@ -1228,14 +893,14 @@ const safeDecodeAsync$1 = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 var regexes_exports = /* @__PURE__ */ __exportAll({
 	base64: () => base64$1,
 	base64url: () => base64url$1,
-	bigint: () => bigint$2,
-	boolean: () => boolean$2,
+	bigint: () => bigint$1,
+	boolean: () => boolean$1,
 	browserEmail: () => browserEmail,
 	cidrv4: () => cidrv4$1,
 	cidrv6: () => cidrv6$1,
 	cuid: () => cuid$1,
 	cuid2: () => cuid2$1,
-	date: () => date$3,
+	date: () => date$2,
 	datetime: () => datetime$1,
 	domain: () => domain,
 	duration: () => duration$1,
@@ -1260,7 +925,7 @@ var regexes_exports = /* @__PURE__ */ __exportAll({
 	md5_hex: () => md5_hex,
 	nanoid: () => nanoid$1,
 	null: () => _null$2,
-	number: () => number$2,
+	number: () => number$1,
 	rfc5322Email: () => rfc5322Email,
 	sha1_base64: () => sha1_base64,
 	sha1_base64url: () => sha1_base64url,
@@ -1274,7 +939,7 @@ var regexes_exports = /* @__PURE__ */ __exportAll({
 	sha512_base64: () => sha512_base64,
 	sha512_base64url: () => sha512_base64url,
 	sha512_hex: () => sha512_hex,
-	string: () => string$2,
+	string: () => string$1,
 	time: () => time$1,
 	ulid: () => ulid$1,
 	undefined: () => _undefined$2,
@@ -1342,7 +1007,7 @@ const domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$
 const httpProtocol = /^https?$/;
 const e164$1 = /^\+[1-9]\d{6,14}$/;
 const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
-const date$3 = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
+const date$2 = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
 function timeSource(args) {
 	const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
 	return typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
@@ -1358,14 +1023,14 @@ function datetime$1(args) {
 	const timeRegex = `${time}(?:${opts.join("|")})`;
 	return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
 }
-const string$2 = (params) => {
+const string$1 = (params) => {
 	const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
 	return new RegExp(`^${regex}$`);
 };
-const bigint$2 = /^-?\d+n?$/;
+const bigint$1 = /^-?\d+n?$/;
 const integer = /^-?\d+$/;
-const number$2 = /^-?\d+(?:\.\d+)?$/;
-const boolean$2 = /^(?:true|false)$/i;
+const number$1 = /^-?\d+(?:\.\d+)?$/;
+const boolean$1 = /^(?:true|false)$/i;
 const _null$2 = /^null$/i;
 const _undefined$2 = /^undefined$/i;
 const lowercase = /^[^A-Z]*$/;
@@ -2032,7 +1697,7 @@ const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
 });
 const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
 	$ZodType.init(inst, def);
-	inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string$2(inst._zod.bag);
+	inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string$1(inst._zod.bag);
 	inst._zod.parse = (payload, _) => {
 		if (def.coerce) try {
 			payload.value = String(payload.value);
@@ -2171,7 +1836,7 @@ const $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, d
 	$ZodStringFormat.init(inst, def);
 });
 const $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
-	def.pattern ?? (def.pattern = date$3);
+	def.pattern ?? (def.pattern = date$2);
 	$ZodStringFormat.init(inst, def);
 });
 const $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
@@ -2331,7 +1996,7 @@ const $ZodCustomStringFormat = /* @__PURE__ */ $constructor("$ZodCustomStringFor
 });
 const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
 	$ZodType.init(inst, def);
-	inst._zod.pattern = inst._zod.bag.pattern ?? number$2;
+	inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
 	inst._zod.parse = (payload, _ctx) => {
 		if (def.coerce) try {
 			payload.value = Number(payload.value);
@@ -2355,7 +2020,7 @@ const $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst,
 });
 const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
 	$ZodType.init(inst, def);
-	inst._zod.pattern = boolean$2;
+	inst._zod.pattern = boolean$1;
 	inst._zod.parse = (payload, _ctx) => {
 		if (def.coerce) try {
 			payload.value = Boolean(payload.value);
@@ -2373,7 +2038,7 @@ const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
 });
 const $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
 	$ZodType.init(inst, def);
-	inst._zod.pattern = bigint$2;
+	inst._zod.pattern = bigint$1;
 	inst._zod.parse = (payload, _ctx) => {
 		if (def.coerce) try {
 			payload.value = BigInt(payload.value);
@@ -3183,7 +2848,7 @@ const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
 					issues: []
 				}, ctx);
 				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
-				if (typeof key === "string" && number$2.test(key) && keyResult.issues.length) {
+				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length) {
 					const retryResult = def.keyType._zod.run({
 						value: Number(key),
 						issues: []
@@ -11773,7 +11438,7 @@ var iso_exports = /* @__PURE__ */ __exportAll({
 	ZodISODateTime: () => ZodISODateTime,
 	ZodISODuration: () => ZodISODuration,
 	ZodISOTime: () => ZodISOTime,
-	date: () => date$2,
+	date: () => date$1,
 	datetime: () => datetime,
 	duration: () => duration,
 	time: () => time
@@ -11789,7 +11454,7 @@ const ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
 	$ZodISODate.init(inst, def);
 	ZodStringFormat.init(inst, def);
 });
-function date$2(params) {
+function date$1(params) {
 	return _isoDate(ZodISODate, params);
 }
 const ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
@@ -11925,8 +11590,8 @@ var schemas_exports = /* @__PURE__ */ __exportAll({
 	array: () => array,
 	base64: () => base64,
 	base64url: () => base64url,
-	bigint: () => bigint$1,
-	boolean: () => boolean$1,
+	bigint: () => bigint,
+	boolean: () => boolean,
 	catch: () => _catch,
 	check: () => check,
 	cidrv4: () => cidrv4,
@@ -11935,7 +11600,7 @@ var schemas_exports = /* @__PURE__ */ __exportAll({
 	cuid: () => cuid,
 	cuid2: () => cuid2,
 	custom: () => custom,
-	date: () => date$1,
+	date: () => date,
 	describe: () => describe,
 	discriminatedUnion: () => discriminatedUnion,
 	e164: () => e164,
@@ -11979,7 +11644,7 @@ var schemas_exports = /* @__PURE__ */ __exportAll({
 	null: () => _null,
 	nullable: () => nullable,
 	nullish: () => nullish,
-	number: () => number$1,
+	number: () => number,
 	object: () => object,
 	optional: () => optional,
 	partialRecord: () => partialRecord,
@@ -11992,7 +11657,7 @@ var schemas_exports = /* @__PURE__ */ __exportAll({
 	refine: () => refine,
 	set: () => set,
 	strictObject: () => strictObject,
-	string: () => string$1,
+	string: () => string,
 	stringFormat: () => stringFormat,
 	stringbool: () => stringbool,
 	success: () => success,
@@ -12261,11 +11926,11 @@ const ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
 	inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
 	inst.e164 = (params) => inst.check(_e164(ZodE164, params));
 	inst.datetime = (params) => inst.check(datetime(params));
-	inst.date = (params) => inst.check(date$2(params));
+	inst.date = (params) => inst.check(date$1(params));
 	inst.time = (params) => inst.check(time(params));
 	inst.duration = (params) => inst.check(duration(params));
 });
-function string$1(params) {
+function string(params) {
 	return _string(ZodString, params);
 }
 const ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
@@ -12517,7 +12182,7 @@ const ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
 	inst.isFinite = true;
 	inst.format = bag.format ?? null;
 });
-function number$1(params) {
+function number(params) {
 	return _number(ZodNumber, params);
 }
 const ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
@@ -12544,7 +12209,7 @@ const ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
 	ZodType.init(inst, def);
 	inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
 });
-function boolean$1(params) {
+function boolean(params) {
 	return _boolean(ZodBoolean, params);
 }
 const ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
@@ -12569,7 +12234,7 @@ const ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
 	inst.maxValue = bag.maximum ?? null;
 	inst.format = bag.format ?? null;
 });
-function bigint$1(params) {
+function bigint(params) {
 	return _bigint(ZodBigInt, params);
 }
 const ZodBigIntFormat = /* @__PURE__ */ $constructor("ZodBigIntFormat", (inst, def) => {
@@ -12648,7 +12313,7 @@ const ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
 	inst.minDate = c.minimum ? new Date(c.minimum) : null;
 	inst.maxDate = c.maximum ? new Date(c.maximum) : null;
 });
-function date$1(params) {
+function date(params) {
 	return _date(ZodDate, params);
 }
 const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
@@ -12851,7 +12516,7 @@ const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
 function record(keyType, valueType, params) {
 	if (!valueType || !valueType._zod) return new ZodRecord({
 		type: "record",
-		keyType: string$1(),
+		keyType: string(),
 		valueType: keyType,
 		...normalizeParams(valueType)
 	});
@@ -13296,12 +12961,12 @@ const stringbool = (...args) => _stringbool({
 function json(params) {
 	const jsonSchema = lazy(() => {
 		return union([
-			string$1(params),
-			number$1(),
-			boolean$1(),
+			string(params),
+			number(),
+			boolean(),
 			_null(),
 			array(jsonSchema),
-			record(string$1(), jsonSchema)
+			record(string(), jsonSchema)
 		]);
 	});
 	return jsonSchema;
@@ -13315,1275 +12980,4 @@ function preprocess(fn, schema) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/compat.js
-/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
-const ZodIssueCode = {
-	invalid_type: "invalid_type",
-	too_big: "too_big",
-	too_small: "too_small",
-	invalid_format: "invalid_format",
-	not_multiple_of: "not_multiple_of",
-	unrecognized_keys: "unrecognized_keys",
-	invalid_union: "invalid_union",
-	invalid_key: "invalid_key",
-	invalid_element: "invalid_element",
-	invalid_value: "invalid_value",
-	custom: "custom"
-};
-/** @deprecated Use `z.config(params)` instead. */
-function setErrorMap(map) {
-	config({ customError: map });
-}
-/** @deprecated Use `z.config()` instead. */
-function getErrorMap() {
-	return config().customError;
-}
-/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
-var ZodFirstPartyTypeKind;
-(function(ZodFirstPartyTypeKind) {})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/from-json-schema.js
-const z = {
-	...schemas_exports,
-	...checks_exports,
-	iso: iso_exports
-};
-const RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
-	"$schema",
-	"$ref",
-	"$defs",
-	"definitions",
-	"$id",
-	"id",
-	"$comment",
-	"$anchor",
-	"$vocabulary",
-	"$dynamicRef",
-	"$dynamicAnchor",
-	"type",
-	"enum",
-	"const",
-	"anyOf",
-	"oneOf",
-	"allOf",
-	"not",
-	"properties",
-	"required",
-	"additionalProperties",
-	"patternProperties",
-	"propertyNames",
-	"minProperties",
-	"maxProperties",
-	"items",
-	"prefixItems",
-	"additionalItems",
-	"minItems",
-	"maxItems",
-	"uniqueItems",
-	"contains",
-	"minContains",
-	"maxContains",
-	"minLength",
-	"maxLength",
-	"pattern",
-	"format",
-	"minimum",
-	"maximum",
-	"exclusiveMinimum",
-	"exclusiveMaximum",
-	"multipleOf",
-	"description",
-	"default",
-	"contentEncoding",
-	"contentMediaType",
-	"contentSchema",
-	"unevaluatedItems",
-	"unevaluatedProperties",
-	"if",
-	"then",
-	"else",
-	"dependentSchemas",
-	"dependentRequired",
-	"nullable",
-	"readOnly"
-]);
-function detectVersion(schema, defaultTarget) {
-	const $schema = schema.$schema;
-	if ($schema === "https://json-schema.org/draft/2020-12/schema") return "draft-2020-12";
-	if ($schema === "http://json-schema.org/draft-07/schema#") return "draft-7";
-	if ($schema === "http://json-schema.org/draft-04/schema#") return "draft-4";
-	return defaultTarget ?? "draft-2020-12";
-}
-function resolveRef(ref, ctx) {
-	if (!ref.startsWith("#")) throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
-	const path = ref.slice(1).split("/").filter(Boolean);
-	if (path.length === 0) return ctx.rootSchema;
-	const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-	if (path[0] === defsKey) {
-		const key = path[1];
-		if (!key || !ctx.defs[key]) throw new Error(`Reference not found: ${ref}`);
-		return ctx.defs[key];
-	}
-	throw new Error(`Reference not found: ${ref}`);
-}
-function convertBaseSchema(schema, ctx) {
-	if (schema.not !== void 0) {
-		if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) return z.never();
-		throw new Error("not is not supported in Zod (except { not: {} } for never)");
-	}
-	if (schema.unevaluatedItems !== void 0) throw new Error("unevaluatedItems is not supported");
-	if (schema.unevaluatedProperties !== void 0) throw new Error("unevaluatedProperties is not supported");
-	if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) throw new Error("Conditional schemas (if/then/else) are not supported");
-	if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) throw new Error("dependentSchemas and dependentRequired are not supported");
-	if (schema.$ref) {
-		const refPath = schema.$ref;
-		if (ctx.refs.has(refPath)) return ctx.refs.get(refPath);
-		if (ctx.processing.has(refPath)) return z.lazy(() => {
-			if (!ctx.refs.has(refPath)) throw new Error(`Circular reference not resolved: ${refPath}`);
-			return ctx.refs.get(refPath);
-		});
-		ctx.processing.add(refPath);
-		const zodSchema = convertSchema(resolveRef(refPath, ctx), ctx);
-		ctx.refs.set(refPath, zodSchema);
-		ctx.processing.delete(refPath);
-		return zodSchema;
-	}
-	if (schema.enum !== void 0) {
-		const enumValues = schema.enum;
-		if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) return z.null();
-		if (enumValues.length === 0) return z.never();
-		if (enumValues.length === 1) return z.literal(enumValues[0]);
-		if (enumValues.every((v) => typeof v === "string")) return z.enum(enumValues);
-		const literalSchemas = enumValues.map((v) => z.literal(v));
-		if (literalSchemas.length < 2) return literalSchemas[0];
-		return z.union([
-			literalSchemas[0],
-			literalSchemas[1],
-			...literalSchemas.slice(2)
-		]);
-	}
-	if (schema.const !== void 0) return z.literal(schema.const);
-	const type = schema.type;
-	if (Array.isArray(type)) {
-		const typeSchemas = type.map((t) => {
-			return convertBaseSchema({
-				...schema,
-				type: t
-			}, ctx);
-		});
-		if (typeSchemas.length === 0) return z.never();
-		if (typeSchemas.length === 1) return typeSchemas[0];
-		return z.union(typeSchemas);
-	}
-	if (!type) return z.any();
-	let zodSchema;
-	switch (type) {
-		case "string": {
-			let stringSchema = z.string();
-			if (schema.format) {
-				const format = schema.format;
-				if (format === "email") stringSchema = stringSchema.check(z.email());
-				else if (format === "uri" || format === "uri-reference") stringSchema = stringSchema.check(z.url());
-				else if (format === "uuid" || format === "guid") stringSchema = stringSchema.check(z.uuid());
-				else if (format === "date-time") stringSchema = stringSchema.check(z.iso.datetime());
-				else if (format === "date") stringSchema = stringSchema.check(z.iso.date());
-				else if (format === "time") stringSchema = stringSchema.check(z.iso.time());
-				else if (format === "duration") stringSchema = stringSchema.check(z.iso.duration());
-				else if (format === "ipv4") stringSchema = stringSchema.check(z.ipv4());
-				else if (format === "ipv6") stringSchema = stringSchema.check(z.ipv6());
-				else if (format === "mac") stringSchema = stringSchema.check(z.mac());
-				else if (format === "cidr") stringSchema = stringSchema.check(z.cidrv4());
-				else if (format === "cidr-v6") stringSchema = stringSchema.check(z.cidrv6());
-				else if (format === "base64") stringSchema = stringSchema.check(z.base64());
-				else if (format === "base64url") stringSchema = stringSchema.check(z.base64url());
-				else if (format === "e164") stringSchema = stringSchema.check(z.e164());
-				else if (format === "jwt") stringSchema = stringSchema.check(z.jwt());
-				else if (format === "emoji") stringSchema = stringSchema.check(z.emoji());
-				else if (format === "nanoid") stringSchema = stringSchema.check(z.nanoid());
-				else if (format === "cuid") stringSchema = stringSchema.check(z.cuid());
-				else if (format === "cuid2") stringSchema = stringSchema.check(z.cuid2());
-				else if (format === "ulid") stringSchema = stringSchema.check(z.ulid());
-				else if (format === "xid") stringSchema = stringSchema.check(z.xid());
-				else if (format === "ksuid") stringSchema = stringSchema.check(z.ksuid());
-			}
-			if (typeof schema.minLength === "number") stringSchema = stringSchema.min(schema.minLength);
-			if (typeof schema.maxLength === "number") stringSchema = stringSchema.max(schema.maxLength);
-			if (schema.pattern) stringSchema = stringSchema.regex(new RegExp(schema.pattern));
-			zodSchema = stringSchema;
-			break;
-		}
-		case "number":
-		case "integer": {
-			let numberSchema = type === "integer" ? z.number().int() : z.number();
-			if (typeof schema.minimum === "number") numberSchema = numberSchema.min(schema.minimum);
-			if (typeof schema.maximum === "number") numberSchema = numberSchema.max(schema.maximum);
-			if (typeof schema.exclusiveMinimum === "number") numberSchema = numberSchema.gt(schema.exclusiveMinimum);
-			else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") numberSchema = numberSchema.gt(schema.minimum);
-			if (typeof schema.exclusiveMaximum === "number") numberSchema = numberSchema.lt(schema.exclusiveMaximum);
-			else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") numberSchema = numberSchema.lt(schema.maximum);
-			if (typeof schema.multipleOf === "number") numberSchema = numberSchema.multipleOf(schema.multipleOf);
-			zodSchema = numberSchema;
-			break;
-		}
-		case "boolean":
-			zodSchema = z.boolean();
-			break;
-		case "null":
-			zodSchema = z.null();
-			break;
-		case "object": {
-			const shape = {};
-			const properties = schema.properties || {};
-			const requiredSet = new Set(schema.required || []);
-			for (const [key, propSchema] of Object.entries(properties)) {
-				const propZodSchema = convertSchema(propSchema, ctx);
-				shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
-			}
-			if (schema.propertyNames) {
-				const keySchema = convertSchema(schema.propertyNames, ctx);
-				const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
-				if (Object.keys(shape).length === 0) {
-					zodSchema = z.record(keySchema, valueSchema);
-					break;
-				}
-				const objectSchema = z.object(shape).passthrough();
-				const recordSchema = z.looseRecord(keySchema, valueSchema);
-				zodSchema = z.intersection(objectSchema, recordSchema);
-				break;
-			}
-			if (schema.patternProperties) {
-				const patternProps = schema.patternProperties;
-				const patternKeys = Object.keys(patternProps);
-				const looseRecords = [];
-				for (const pattern of patternKeys) {
-					const patternValue = convertSchema(patternProps[pattern], ctx);
-					const keySchema = z.string().regex(new RegExp(pattern));
-					looseRecords.push(z.looseRecord(keySchema, patternValue));
-				}
-				const schemasToIntersect = [];
-				if (Object.keys(shape).length > 0) schemasToIntersect.push(z.object(shape).passthrough());
-				schemasToIntersect.push(...looseRecords);
-				if (schemasToIntersect.length === 0) zodSchema = z.object({}).passthrough();
-				else if (schemasToIntersect.length === 1) zodSchema = schemasToIntersect[0];
-				else {
-					let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
-					for (let i = 2; i < schemasToIntersect.length; i++) result = z.intersection(result, schemasToIntersect[i]);
-					zodSchema = result;
-				}
-				break;
-			}
-			const objectSchema = z.object(shape);
-			if (schema.additionalProperties === false) zodSchema = objectSchema.strict();
-			else if (typeof schema.additionalProperties === "object") zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
-			else zodSchema = objectSchema.passthrough();
-			break;
-		}
-		case "array": {
-			const prefixItems = schema.prefixItems;
-			const items = schema.items;
-			if (prefixItems && Array.isArray(prefixItems)) {
-				const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
-				const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
-				if (rest) zodSchema = z.tuple(tupleItems).rest(rest);
-				else zodSchema = z.tuple(tupleItems);
-				if (typeof schema.minItems === "number") zodSchema = zodSchema.check(z.minLength(schema.minItems));
-				if (typeof schema.maxItems === "number") zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
-			} else if (Array.isArray(items)) {
-				const tupleItems = items.map((item) => convertSchema(item, ctx));
-				const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
-				if (rest) zodSchema = z.tuple(tupleItems).rest(rest);
-				else zodSchema = z.tuple(tupleItems);
-				if (typeof schema.minItems === "number") zodSchema = zodSchema.check(z.minLength(schema.minItems));
-				if (typeof schema.maxItems === "number") zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
-			} else if (items !== void 0) {
-				const element = convertSchema(items, ctx);
-				let arraySchema = z.array(element);
-				if (typeof schema.minItems === "number") arraySchema = arraySchema.min(schema.minItems);
-				if (typeof schema.maxItems === "number") arraySchema = arraySchema.max(schema.maxItems);
-				zodSchema = arraySchema;
-			} else zodSchema = z.array(z.any());
-			break;
-		}
-		default: throw new Error(`Unsupported type: ${type}`);
-	}
-	return zodSchema;
-}
-function convertSchema(schema, ctx) {
-	if (typeof schema === "boolean") return schema ? z.any() : z.never();
-	let baseSchema = convertBaseSchema(schema, ctx);
-	const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
-	if (schema.anyOf && Array.isArray(schema.anyOf)) {
-		const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-		const anyOfUnion = z.union(options);
-		baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
-	}
-	if (schema.oneOf && Array.isArray(schema.oneOf)) {
-		const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-		const oneOfUnion = z.xor(options);
-		baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
-	}
-	if (schema.allOf && Array.isArray(schema.allOf)) if (schema.allOf.length === 0) baseSchema = hasExplicitType ? baseSchema : z.any();
-	else {
-		let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
-		const startIdx = hasExplicitType ? 0 : 1;
-		for (let i = startIdx; i < schema.allOf.length; i++) result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
-		baseSchema = result;
-	}
-	if (schema.nullable === true && ctx.version === "openapi-3.0") baseSchema = z.nullable(baseSchema);
-	if (schema.readOnly === true) baseSchema = z.readonly(baseSchema);
-	if (schema.default !== void 0) baseSchema = baseSchema.default(schema.default);
-	const extraMeta = {};
-	for (const key of [
-		"$id",
-		"id",
-		"$comment",
-		"$anchor",
-		"$vocabulary",
-		"$dynamicRef",
-		"$dynamicAnchor"
-	]) if (key in schema) extraMeta[key] = schema[key];
-	for (const key of [
-		"contentEncoding",
-		"contentMediaType",
-		"contentSchema"
-	]) if (key in schema) extraMeta[key] = schema[key];
-	for (const key of Object.keys(schema)) if (!RECOGNIZED_KEYS.has(key)) extraMeta[key] = schema[key];
-	if (Object.keys(extraMeta).length > 0) ctx.registry.add(baseSchema, extraMeta);
-	if (schema.description) baseSchema = baseSchema.describe(schema.description);
-	return baseSchema;
-}
-/**
-* Converts a JSON Schema to a Zod schema. This function should be considered semi-experimental. It's behavior is liable to change. */
-function fromJSONSchema(schema, params) {
-	if (typeof schema === "boolean") return schema ? z.any() : z.never();
-	let normalized;
-	try {
-		normalized = JSON.parse(JSON.stringify(schema));
-	} catch {
-		throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
-	}
-	const ctx = {
-		version: detectVersion(normalized, params?.defaultTarget),
-		defs: normalized.$defs || normalized.definitions || {},
-		refs: /* @__PURE__ */ new Map(),
-		processing: /* @__PURE__ */ new Set(),
-		rootSchema: normalized,
-		registry: params?.registry ?? globalRegistry
-	};
-	return convertSchema(normalized, ctx);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/coerce.js
-var coerce_exports = /* @__PURE__ */ __exportAll({
-	bigint: () => bigint,
-	boolean: () => boolean,
-	date: () => date,
-	number: () => number,
-	string: () => string
-});
-function string(params) {
-	return _coercedString(ZodString, params);
-}
-function number(params) {
-	return _coercedNumber(ZodNumber, params);
-}
-function boolean(params) {
-	return _coercedBoolean(ZodBoolean, params);
-}
-function bigint(params) {
-	return _coercedBigint(ZodBigInt, params);
-}
-function date(params) {
-	return _coercedDate(ZodDate, params);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
-var external_exports = /* @__PURE__ */ __exportAll({
-	$brand: () => $brand,
-	$input: () => $input,
-	$output: () => $output,
-	NEVER: () => NEVER,
-	TimePrecision: () => TimePrecision,
-	ZodAny: () => ZodAny,
-	ZodArray: () => ZodArray,
-	ZodBase64: () => ZodBase64,
-	ZodBase64URL: () => ZodBase64URL,
-	ZodBigInt: () => ZodBigInt,
-	ZodBigIntFormat: () => ZodBigIntFormat,
-	ZodBoolean: () => ZodBoolean,
-	ZodCIDRv4: () => ZodCIDRv4,
-	ZodCIDRv6: () => ZodCIDRv6,
-	ZodCUID: () => ZodCUID,
-	ZodCUID2: () => ZodCUID2,
-	ZodCatch: () => ZodCatch,
-	ZodCodec: () => ZodCodec,
-	ZodCustom: () => ZodCustom,
-	ZodCustomStringFormat: () => ZodCustomStringFormat,
-	ZodDate: () => ZodDate,
-	ZodDefault: () => ZodDefault,
-	ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-	ZodE164: () => ZodE164,
-	ZodEmail: () => ZodEmail,
-	ZodEmoji: () => ZodEmoji,
-	ZodEnum: () => ZodEnum,
-	ZodError: () => ZodError,
-	ZodExactOptional: () => ZodExactOptional,
-	ZodFile: () => ZodFile,
-	ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-	ZodFunction: () => ZodFunction,
-	ZodGUID: () => ZodGUID,
-	ZodIPv4: () => ZodIPv4,
-	ZodIPv6: () => ZodIPv6,
-	ZodISODate: () => ZodISODate,
-	ZodISODateTime: () => ZodISODateTime,
-	ZodISODuration: () => ZodISODuration,
-	ZodISOTime: () => ZodISOTime,
-	ZodIntersection: () => ZodIntersection,
-	ZodIssueCode: () => ZodIssueCode,
-	ZodJWT: () => ZodJWT,
-	ZodKSUID: () => ZodKSUID,
-	ZodLazy: () => ZodLazy,
-	ZodLiteral: () => ZodLiteral,
-	ZodMAC: () => ZodMAC,
-	ZodMap: () => ZodMap,
-	ZodNaN: () => ZodNaN,
-	ZodNanoID: () => ZodNanoID,
-	ZodNever: () => ZodNever,
-	ZodNonOptional: () => ZodNonOptional,
-	ZodNull: () => ZodNull,
-	ZodNullable: () => ZodNullable,
-	ZodNumber: () => ZodNumber,
-	ZodNumberFormat: () => ZodNumberFormat,
-	ZodObject: () => ZodObject,
-	ZodOptional: () => ZodOptional,
-	ZodPipe: () => ZodPipe,
-	ZodPrefault: () => ZodPrefault,
-	ZodPreprocess: () => ZodPreprocess,
-	ZodPromise: () => ZodPromise,
-	ZodReadonly: () => ZodReadonly,
-	ZodRealError: () => ZodRealError,
-	ZodRecord: () => ZodRecord,
-	ZodSet: () => ZodSet,
-	ZodString: () => ZodString,
-	ZodStringFormat: () => ZodStringFormat,
-	ZodSuccess: () => ZodSuccess,
-	ZodSymbol: () => ZodSymbol,
-	ZodTemplateLiteral: () => ZodTemplateLiteral,
-	ZodTransform: () => ZodTransform,
-	ZodTuple: () => ZodTuple,
-	ZodType: () => ZodType,
-	ZodULID: () => ZodULID,
-	ZodURL: () => ZodURL,
-	ZodUUID: () => ZodUUID,
-	ZodUndefined: () => ZodUndefined,
-	ZodUnion: () => ZodUnion,
-	ZodUnknown: () => ZodUnknown,
-	ZodVoid: () => ZodVoid,
-	ZodXID: () => ZodXID,
-	ZodXor: () => ZodXor,
-	_ZodString: () => _ZodString,
-	_default: () => _default,
-	_function: () => _function,
-	any: () => any,
-	array: () => array,
-	base64: () => base64,
-	base64url: () => base64url,
-	bigint: () => bigint$1,
-	boolean: () => boolean$1,
-	catch: () => _catch,
-	check: () => check,
-	cidrv4: () => cidrv4,
-	cidrv6: () => cidrv6,
-	clone: () => clone,
-	codec: () => codec,
-	coerce: () => coerce_exports,
-	config: () => config,
-	core: () => core_exports,
-	cuid: () => cuid,
-	cuid2: () => cuid2,
-	custom: () => custom,
-	date: () => date$1,
-	decode: () => decode,
-	decodeAsync: () => decodeAsync,
-	describe: () => describe,
-	discriminatedUnion: () => discriminatedUnion,
-	e164: () => e164,
-	email: () => email,
-	emoji: () => emoji,
-	encode: () => encode,
-	encodeAsync: () => encodeAsync,
-	endsWith: () => _endsWith,
-	enum: () => _enum,
-	exactOptional: () => exactOptional,
-	file: () => file,
-	flattenError: () => flattenError,
-	float32: () => float32,
-	float64: () => float64,
-	formatError: () => formatError,
-	fromJSONSchema: () => fromJSONSchema,
-	function: () => _function,
-	getErrorMap: () => getErrorMap,
-	globalRegistry: () => globalRegistry,
-	gt: () => _gt,
-	gte: () => _gte,
-	guid: () => guid,
-	hash: () => hash,
-	hex: () => hex,
-	hostname: () => hostname,
-	httpUrl: () => httpUrl,
-	includes: () => _includes,
-	instanceof: () => _instanceof,
-	int: () => int,
-	int32: () => int32,
-	int64: () => int64,
-	intersection: () => intersection,
-	invertCodec: () => invertCodec,
-	ipv4: () => ipv4,
-	ipv6: () => ipv6,
-	iso: () => iso_exports,
-	json: () => json,
-	jwt: () => jwt,
-	keyof: () => keyof,
-	ksuid: () => ksuid,
-	lazy: () => lazy,
-	length: () => _length,
-	literal: () => literal,
-	locales: () => locales_exports,
-	looseObject: () => looseObject,
-	looseRecord: () => looseRecord,
-	lowercase: () => _lowercase,
-	lt: () => _lt,
-	lte: () => _lte,
-	mac: () => mac,
-	map: () => map,
-	maxLength: () => _maxLength,
-	maxSize: () => _maxSize,
-	meta: () => meta,
-	mime: () => _mime,
-	minLength: () => _minLength,
-	minSize: () => _minSize,
-	multipleOf: () => _multipleOf,
-	nan: () => nan,
-	nanoid: () => nanoid,
-	nativeEnum: () => nativeEnum,
-	negative: () => _negative,
-	never: () => never,
-	nonnegative: () => _nonnegative,
-	nonoptional: () => nonoptional,
-	nonpositive: () => _nonpositive,
-	normalize: () => _normalize,
-	null: () => _null,
-	nullable: () => nullable,
-	nullish: () => nullish,
-	number: () => number$1,
-	object: () => object,
-	optional: () => optional,
-	overwrite: () => _overwrite,
-	parse: () => parse,
-	parseAsync: () => parseAsync,
-	partialRecord: () => partialRecord,
-	pipe: () => pipe,
-	positive: () => _positive,
-	prefault: () => prefault,
-	preprocess: () => preprocess,
-	prettifyError: () => prettifyError,
-	promise: () => promise,
-	property: () => _property,
-	readonly: () => readonly,
-	record: () => record,
-	refine: () => refine,
-	regex: () => _regex,
-	regexes: () => regexes_exports,
-	registry: () => registry,
-	safeDecode: () => safeDecode,
-	safeDecodeAsync: () => safeDecodeAsync,
-	safeEncode: () => safeEncode,
-	safeEncodeAsync: () => safeEncodeAsync,
-	safeParse: () => safeParse,
-	safeParseAsync: () => safeParseAsync,
-	set: () => set,
-	setErrorMap: () => setErrorMap,
-	size: () => _size,
-	slugify: () => _slugify,
-	startsWith: () => _startsWith,
-	strictObject: () => strictObject,
-	string: () => string$1,
-	stringFormat: () => stringFormat,
-	stringbool: () => stringbool,
-	success: () => success,
-	superRefine: () => superRefine,
-	symbol: () => symbol,
-	templateLiteral: () => templateLiteral,
-	toJSONSchema: () => toJSONSchema,
-	toLowerCase: () => _toLowerCase,
-	toUpperCase: () => _toUpperCase,
-	transform: () => transform,
-	treeifyError: () => treeifyError,
-	trim: () => _trim,
-	tuple: () => tuple,
-	uint32: () => uint32,
-	uint64: () => uint64,
-	ulid: () => ulid,
-	undefined: () => _undefined,
-	union: () => union,
-	unknown: () => unknown,
-	uppercase: () => _uppercase,
-	url: () => url,
-	util: () => util_exports,
-	uuid: () => uuid,
-	uuidv4: () => uuidv4,
-	uuidv6: () => uuidv6,
-	uuidv7: () => uuidv7,
-	void: () => _void,
-	xid: () => xid,
-	xor: () => xor
-});
-config(en_default());
-
-//#endregion
-//#region ../api-contract/dist/openapi.mjs
-var import_dist = require_dist();
-(0, import_dist.extendZodWithOpenApi)(external_exports);
-
-//#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$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().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();
-/** XGraph wire shape accepted and emitted at API boundaries. */
-const xgraphSchema = object({
-	xgraphSchemaVersion: literal("1.0.0").optional(),
-	id: string$1().optional(),
-	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(),
-	ownership: _enum(["personal", "team"]).optional(),
-	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(),
-	expectedUpdatedAt: string$1().min(1).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 } : {},
-				...input.expectedUpdatedAt !== void 0 ? { expectedUpdatedAt: input.expectedUpdatedAt } : {}
-			}), 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 };
+export { ZodString as $, uuid as $n, _property as $r, int as $t, ZodJWT as A, preprocess as An, _coercedDate as Ar, boolean as At, ZodNull as B, stringbool as Bn, _lte as Br, discriminatedUnion as Bt, ZodExactOptional as C, config as Ci, nullish as Cn, iso_exports as Cr, _undefined as Ct, ZodIPv4 as D, partialRecord as Dn, TimePrecision as Dr, base64 as Dt, ZodGUID as E, optional as En, toJSONSchema as Er, array as Et, ZodMap as F, schemas_exports as Fn, _gte as Fr, cuid as Ft, ZodOptional as G, transform as Gn, _minSize as Gr, file as Gt, ZodNumber as H, superRefine as Hn, _maxSize as Hr, email as Ht, ZodNaN as I, set as In, _includes as Ir, cuid2 as It, ZodPreprocess as J, uint64 as Jn, _nonnegative as Jr, guid as Jt, ZodPipe as K, tuple as Kn, _multipleOf as Kr, float32 as Kt, ZodNanoID as L, strictObject as Ln, _length as Lr, custom as Lt, ZodLazy as M, readonly as Mn, _coercedString as Mr, cidrv4 as Mt, ZodLiteral as N, record as Nn, _endsWith as Nr, cidrv6 as Nt, ZodIPv6 as O, pipe as On, _coercedBigint as Or, base64url as Ot, ZodMAC as P, refine as Pn, _gt as Pr, codec as Pt, ZodSet as Q, url as Qn, _positive as Qr, httpUrl as Qt, ZodNever as R, string as Rn, _lowercase as Rr, date as Rt, ZodEnum as S, NEVER as Si, nullable as Sn, ZodISOTime as Sr, _null as St, ZodFunction as T, object as Tn, core_exports as Tr, any as Tt, ZodNumberFormat as U, symbol as Un, _mime as Ur, emoji as Ut, ZodNullable as V, success as Vn, _maxLength as Vr, e164 as Vt, ZodObject as W, templateLiteral as Wn, _minLength as Wr, exactOptional as Wt, ZodReadonly as X, union as Xn, _normalize as Xr, hex as Xt, ZodPromise as Y, ulid as Yn, _nonpositive as Yr, hash as Yt, ZodRecord as Z, unknown as Zn, _overwrite as Zr, hostname as Zt, ZodDefault as _, prettifyError as _i, nan as _n, ZodError as _r, _catch as _t, ZodBigInt as a, _toUpperCase as ai, ipv6 as an, decode as ar, ZodTuple as at, ZodEmail as b, util_exports as bi, never as bn, ZodISODateTime as br, _function as bt, ZodCIDRv4 as c, $input as ci, keyof as cn, encodeAsync as cr, ZodURL as ct, ZodCUID2 as d, registry as di, literal as dn, safeDecode as dr, ZodUnion as dt, _regex as ei, int32 as en, uuidv4 as er, ZodStringFormat as et, ZodCatch as f, locales_exports as fi, looseObject as fn, safeDecodeAsync as fr, ZodUnknown as ft, ZodDate as g, formatError as gi, meta as gn, safeParseAsync as gr, _ZodString as gt, ZodCustomStringFormat as h, flattenError as hi, map as hn, safeParse as hr, ZodXor as ht, ZodBase64URL as i, _toLowerCase as ii, ipv4 as in, xor as ir, ZodTransform as it, ZodKSUID as j, promise as jn, _coercedNumber as jr, check as jt, ZodIntersection as k, prefault as kn, _coercedBoolean as kr, bigint as kt, ZodCIDRv6 as l, $output as li, ksuid as ln, parse as lr, ZodUUID as lt, ZodCustom as m, regexes_exports as mi, mac as mn, safeEncodeAsync as mr, ZodXID as mt, ZodArray as n, _slugify as ni, intersection as nn, uuidv7 as nr, ZodSymbol as nt, ZodBigIntFormat as o, _trim as oi, json as on, decodeAsync as or, ZodType as ot, ZodCodec as p, en_default as pi, looseRecord as pn, safeEncode as pr, ZodVoid as pt, ZodPrefault as q, uint32 as qn, _negative as qr, float64 as qt, ZodBase64 as r, _startsWith as ri, invertCodec as rn, xid as rr, ZodTemplateLiteral as rt, ZodBoolean as s, _uppercase as si, jwt as sn, encode as sr, ZodULID as st, ZodAny as t, _size as ti, int64 as tn, uuidv6 as tr, ZodSuccess as tt, ZodCUID as u, globalRegistry as ui, lazy as un, parseAsync as ur, ZodUndefined as ut, ZodDiscriminatedUnion as v, treeifyError as vi, nanoid as vn, ZodRealError as vr, _default as vt, ZodFile as w, number as wn, checks_exports as wr, _void as wt, ZodEmoji as x, $brand as xi, nonoptional as xn, ZodISODuration as xr, _instanceof as xt, ZodE164 as y, clone as yi, nativeEnum as yn, ZodISODate as yr, _enum as yt, ZodNonOptional as z, stringFormat as zn, _lt as zr, describe as zt };