@critical-path/svelte 0.10.2 → 0.11.0

package/dist/index.js

@@ -372,12 +372,12 @@ var c = class {
 		}
 	}
 };
-function l(e, t) {
+function ee(e, t) {
 	return new c(e, t);
 }
 //#endregion
 //#region src/attachment-state.svelte.ts
-var u = class {
+var te = class {
 	client;
 	filter;
 	#e = t.state(t.proxy([]));
@@ -435,12 +435,12 @@ var u = class {
 		}
 	}
 };
-function d(e, t) {
-	return new u(e, t);
+function ne(e, t) {
+	return new te(e, t);
 }
 //#endregion
 //#region src/activity-state.svelte.ts
-var f = class {
+var re = class {
 	client;
 	taskId;
 	#e = t.state(t.proxy([]));
@@ -597,12 +597,12 @@ var f = class {
 		}
 	}
 };
-function p(e, t) {
-	return new f(e, t);
+function ie(e, t) {
+	return new re(e, t);
 }
 //#endregion
 //#region src/deliverable-state.svelte.ts
-var m = class {
+var ae = class {
 	client;
 	projectId;
 	#e = t.state(t.proxy([]));
@@ -680,13 +680,3281 @@ var m = class {
 		return this.client.getDeliverableSummary(e);
 	}
 };
+function oe(e, t) {
+	return new ae(e, t);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.js
+var l;
+(function(e) {
+	e.assertEqual = (e) => {};
+	function t(e) {}
+	e.assertIs = t;
+	function n(e) {
+		throw Error();
+	}
+	e.assertNever = n, e.arrayToEnum = (e) => {
+		let t = {};
+		for (let n of e) t[n] = n;
+		return t;
+	}, e.getValidEnumValues = (t) => {
+		let n = e.objectKeys(t).filter((e) => typeof t[t[e]] != "number"), r = {};
+		for (let e of n) r[e] = t[e];
+		return e.objectValues(r);
+	}, e.objectValues = (t) => e.objectKeys(t).map(function(e) {
+		return t[e];
+	}), e.objectKeys = typeof Object.keys == "function" ? (e) => Object.keys(e) : (e) => {
+		let t = [];
+		for (let n in e) Object.prototype.hasOwnProperty.call(e, n) && t.push(n);
+		return t;
+	}, e.find = (e, t) => {
+		for (let n of e) if (t(n)) return n;
+	}, e.isInteger = typeof Number.isInteger == "function" ? (e) => Number.isInteger(e) : (e) => typeof e == "number" && Number.isFinite(e) && Math.floor(e) === e;
+	function r(e, t = " | ") {
+		return e.map((e) => typeof e == "string" ? `'${e}'` : e).join(t);
+	}
+	e.joinValues = r, e.jsonStringifyReplacer = (e, t) => typeof t == "bigint" ? t.toString() : t;
+})(l ||= {});
+var se;
+(function(e) {
+	e.mergeShapes = (e, t) => ({
+		...e,
+		...t
+	});
+})(se ||= {});
+var u = l.arrayToEnum([
+	"string",
+	"nan",
+	"number",
+	"integer",
+	"float",
+	"boolean",
+	"date",
+	"bigint",
+	"symbol",
+	"function",
+	"undefined",
+	"null",
+	"array",
+	"object",
+	"unknown",
+	"promise",
+	"void",
+	"never",
+	"map",
+	"set"
+]), d = (e) => {
+	switch (typeof e) {
+		case "undefined": return u.undefined;
+		case "string": return u.string;
+		case "number": return Number.isNaN(e) ? u.nan : u.number;
+		case "boolean": return u.boolean;
+		case "function": return u.function;
+		case "bigint": return u.bigint;
+		case "symbol": return u.symbol;
+		case "object": return Array.isArray(e) ? u.array : e === null ? u.null : e.then && typeof e.then == "function" && e.catch && typeof e.catch == "function" ? u.promise : typeof Map < "u" && e instanceof Map ? u.map : typeof Set < "u" && e instanceof Set ? u.set : typeof Date < "u" && e instanceof Date ? u.date : u.object;
+		default: return u.unknown;
+	}
+}, f = l.arrayToEnum([
+	"invalid_type",
+	"invalid_literal",
+	"custom",
+	"invalid_union",
+	"invalid_union_discriminator",
+	"invalid_enum_value",
+	"unrecognized_keys",
+	"invalid_arguments",
+	"invalid_return_type",
+	"invalid_date",
+	"invalid_string",
+	"too_small",
+	"too_big",
+	"invalid_intersection_types",
+	"not_multiple_of",
+	"not_finite"
+]), p = class e extends Error {
+	get errors() {
+		return this.issues;
+	}
+	constructor(e) {
+		super(), this.issues = [], this.addIssue = (e) => {
+			this.issues = [...this.issues, e];
+		}, this.addIssues = (e = []) => {
+			this.issues = [...this.issues, ...e];
+		};
+		let t = new.target.prototype;
+		Object.setPrototypeOf ? Object.setPrototypeOf(this, t) : this.__proto__ = t, this.name = "ZodError", this.issues = e;
+	}
+	format(e) {
+		let t = e || function(e) {
+			return e.message;
+		}, n = { _errors: [] }, r = (e) => {
+			for (let i of e.issues) if (i.code === "invalid_union") i.unionErrors.map(r);
+			else if (i.code === "invalid_return_type") r(i.returnTypeError);
+			else if (i.code === "invalid_arguments") r(i.argumentsError);
+			else if (i.path.length === 0) n._errors.push(t(i));
+			else {
+				let e = n, r = 0;
+				for (; r < i.path.length;) {
+					let n = i.path[r];
+					r === i.path.length - 1 ? (e[n] = e[n] || { _errors: [] }, e[n]._errors.push(t(i))) : e[n] = e[n] || { _errors: [] }, e = e[n], r++;
+				}
+			}
+		};
+		return r(this), n;
+	}
+	static assert(t) {
+		if (!(t instanceof e)) throw Error(`Not a ZodError: ${t}`);
+	}
+	toString() {
+		return this.message;
+	}
+	get message() {
+		return JSON.stringify(this.issues, l.jsonStringifyReplacer, 2);
+	}
+	get isEmpty() {
+		return this.issues.length === 0;
+	}
+	flatten(e = (e) => e.message) {
+		let t = {}, n = [];
+		for (let r of this.issues) if (r.path.length > 0) {
+			let n = r.path[0];
+			t[n] = t[n] || [], t[n].push(e(r));
+		} else n.push(e(r));
+		return {
+			formErrors: n,
+			fieldErrors: t
+		};
+	}
+	get formErrors() {
+		return this.flatten();
+	}
+};
+p.create = (e) => new p(e);
+//#endregion
+//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/locales/en.js
+var m = (e, t) => {
+	let n;
+	switch (e.code) {
+		case f.invalid_type:
+			n = e.received === u.undefined ? "Required" : `Expected ${e.expected}, received ${e.received}`;
+			break;
+		case f.invalid_literal:
+			n = `Invalid literal value, expected ${JSON.stringify(e.expected, l.jsonStringifyReplacer)}`;
+			break;
+		case f.unrecognized_keys:
+			n = `Unrecognized key(s) in object: ${l.joinValues(e.keys, ", ")}`;
+			break;
+		case f.invalid_union:
+			n = "Invalid input";
+			break;
+		case f.invalid_union_discriminator:
+			n = `Invalid discriminator value. Expected ${l.joinValues(e.options)}`;
+			break;
+		case f.invalid_enum_value:
+			n = `Invalid enum value. Expected ${l.joinValues(e.options)}, received '${e.received}'`;
+			break;
+		case f.invalid_arguments:
+			n = "Invalid function arguments";
+			break;
+		case f.invalid_return_type:
+			n = "Invalid function return type";
+			break;
+		case f.invalid_date:
+			n = "Invalid date";
+			break;
+		case f.invalid_string:
+			typeof e.validation == "object" ? "includes" in e.validation ? (n = `Invalid input: must include "${e.validation.includes}"`, typeof e.validation.position == "number" && (n = `${n} at one or more positions greater than or equal to ${e.validation.position}`)) : "startsWith" in e.validation ? n = `Invalid input: must start with "${e.validation.startsWith}"` : "endsWith" in e.validation ? n = `Invalid input: must end with "${e.validation.endsWith}"` : l.assertNever(e.validation) : n = e.validation === "regex" ? "Invalid" : `Invalid ${e.validation}`;
+			break;
+		case f.too_small:
+			n = e.type === "array" ? `Array must contain ${e.exact ? "exactly" : e.inclusive ? "at least" : "more than"} ${e.minimum} element(s)` : e.type === "string" ? `String must contain ${e.exact ? "exactly" : e.inclusive ? "at least" : "over"} ${e.minimum} character(s)` : e.type === "number" || e.type === "bigint" ? `Number must be ${e.exact ? "exactly equal to " : e.inclusive ? "greater than or equal to " : "greater than "}${e.minimum}` : e.type === "date" ? `Date must be ${e.exact ? "exactly equal to " : e.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(e.minimum))}` : "Invalid input";
+			break;
+		case f.too_big:
+			n = e.type === "array" ? `Array must contain ${e.exact ? "exactly" : e.inclusive ? "at most" : "less than"} ${e.maximum} element(s)` : e.type === "string" ? `String must contain ${e.exact ? "exactly" : e.inclusive ? "at most" : "under"} ${e.maximum} character(s)` : e.type === "number" ? `Number must be ${e.exact ? "exactly" : e.inclusive ? "less than or equal to" : "less than"} ${e.maximum}` : e.type === "bigint" ? `BigInt must be ${e.exact ? "exactly" : e.inclusive ? "less than or equal to" : "less than"} ${e.maximum}` : e.type === "date" ? `Date must be ${e.exact ? "exactly" : e.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number(e.maximum))}` : "Invalid input";
+			break;
+		case f.custom:
+			n = "Invalid input";
+			break;
+		case f.invalid_intersection_types:
+			n = "Intersection results could not be merged";
+			break;
+		case f.not_multiple_of:
+			n = `Number must be a multiple of ${e.multipleOf}`;
+			break;
+		case f.not_finite:
+			n = "Number must be finite";
+			break;
+		default: n = t.defaultError, l.assertNever(e);
+	}
+	return { message: n };
+}, ce = m;
+function le() {
+	return ce;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
+var ue = (e) => {
+	let { data: t, path: n, errorMaps: r, issueData: i } = e, a = [...n, ...i.path || []], o = {
+		...i,
+		path: a
+	};
+	if (i.message !== void 0) return {
+		...i,
+		path: a,
+		message: i.message
+	};
+	let s = "", c = r.filter((e) => !!e).slice().reverse();
+	for (let e of c) s = e(o, {
+		data: t,
+		defaultError: s
+	}).message;
+	return {
+		...i,
+		path: a,
+		message: s
+	};
+};
 function h(e, t) {
-	return new m(e, t);
+	let n = le(), r = ue({
+		issueData: t,
+		data: e.data,
+		path: e.path,
+		errorMaps: [
+			e.common.contextualErrorMap,
+			e.schemaErrorMap,
+			n,
+			n === m ? void 0 : m
+		].filter((e) => !!e)
+	});
+	e.common.issues.push(r);
+}
+var g = class e {
+	constructor() {
+		this.value = "valid";
+	}
+	dirty() {
+		this.value === "valid" && (this.value = "dirty");
+	}
+	abort() {
+		this.value !== "aborted" && (this.value = "aborted");
+	}
+	static mergeArray(e, t) {
+		let n = [];
+		for (let r of t) {
+			if (r.status === "aborted") return _;
+			r.status === "dirty" && e.dirty(), n.push(r.value);
+		}
+		return {
+			status: e.value,
+			value: n
+		};
+	}
+	static async mergeObjectAsync(t, n) {
+		let r = [];
+		for (let e of n) {
+			let t = await e.key, n = await e.value;
+			r.push({
+				key: t,
+				value: n
+			});
+		}
+		return e.mergeObjectSync(t, r);
+	}
+	static mergeObjectSync(e, t) {
+		let n = {};
+		for (let r of t) {
+			let { key: t, value: i } = r;
+			if (t.status === "aborted" || i.status === "aborted") return _;
+			t.status === "dirty" && e.dirty(), i.status === "dirty" && e.dirty(), t.value !== "__proto__" && (i.value !== void 0 || r.alwaysSet) && (n[t.value] = i.value);
+		}
+		return {
+			status: e.value,
+			value: n
+		};
+	}
+}, _ = Object.freeze({ status: "aborted" }), de = (e) => ({
+	status: "dirty",
+	value: e
+}), v = (e) => ({
+	status: "valid",
+	value: e
+}), fe = (e) => e.status === "aborted", pe = (e) => e.status === "dirty", y = (e) => e.status === "valid", b = (e) => typeof Promise < "u" && e instanceof Promise, x;
+(function(e) {
+	e.errToObj = (e) => typeof e == "string" ? { message: e } : e || {}, e.toString = (e) => typeof e == "string" ? e : e?.message;
+})(x ||= {});
+//#endregion
+//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
+var S = class {
+	constructor(e, t, n, r) {
+		this._cachedPath = [], this.parent = e, this.data = t, this._path = n, this._key = r;
+	}
+	get path() {
+		return this._cachedPath.length || (Array.isArray(this._key) ? this._cachedPath.push(...this._path, ...this._key) : this._cachedPath.push(...this._path, this._key)), this._cachedPath;
+	}
+}, me = (e, t) => {
+	if (y(t)) return {
+		success: !0,
+		data: t.value
+	};
+	if (!e.common.issues.length) throw Error("Validation failed but no issues detected.");
+	return {
+		success: !1,
+		get error() {
+			if (this._error) return this._error;
+			let t = new p(e.common.issues);
+			return this._error = t, this._error;
+		}
+	};
+};
+function C(e) {
+	if (!e) return {};
+	let { errorMap: t, invalid_type_error: n, required_error: r, description: i } = e;
+	if (t && (n || r)) throw Error("Can't use \"invalid_type_error\" or \"required_error\" in conjunction with custom error map.");
+	return t ? {
+		errorMap: t,
+		description: i
+	} : {
+		errorMap: (t, i) => {
+			let { message: a } = e;
+			return t.code === "invalid_enum_value" ? { message: a ?? i.defaultError } : i.data === void 0 ? { message: a ?? r ?? i.defaultError } : t.code === "invalid_type" ? { message: a ?? n ?? i.defaultError } : { message: i.defaultError };
+		},
+		description: i
+	};
+}
+var w = class {
+	get description() {
+		return this._def.description;
+	}
+	_getType(e) {
+		return d(e.data);
+	}
+	_getOrReturnCtx(e, t) {
+		return t || {
+			common: e.parent.common,
+			data: e.data,
+			parsedType: d(e.data),
+			schemaErrorMap: this._def.errorMap,
+			path: e.path,
+			parent: e.parent
+		};
+	}
+	_processInputParams(e) {
+		return {
+			status: new g(),
+			ctx: {
+				common: e.parent.common,
+				data: e.data,
+				parsedType: d(e.data),
+				schemaErrorMap: this._def.errorMap,
+				path: e.path,
+				parent: e.parent
+			}
+		};
+	}
+	_parseSync(e) {
+		let t = this._parse(e);
+		if (b(t)) throw Error("Synchronous parse encountered promise.");
+		return t;
+	}
+	_parseAsync(e) {
+		let t = this._parse(e);
+		return Promise.resolve(t);
+	}
+	parse(e, t) {
+		let n = this.safeParse(e, t);
+		if (n.success) return n.data;
+		throw n.error;
+	}
+	safeParse(e, t) {
+		let n = {
+			common: {
+				issues: [],
+				async: t?.async ?? !1,
+				contextualErrorMap: t?.errorMap
+			},
+			path: t?.path || [],
+			schemaErrorMap: this._def.errorMap,
+			parent: null,
+			data: e,
+			parsedType: d(e)
+		};
+		return me(n, this._parseSync({
+			data: e,
+			path: n.path,
+			parent: n
+		}));
+	}
+	"~validate"(e) {
+		let t = {
+			common: {
+				issues: [],
+				async: !!this["~standard"].async
+			},
+			path: [],
+			schemaErrorMap: this._def.errorMap,
+			parent: null,
+			data: e,
+			parsedType: d(e)
+		};
+		if (!this["~standard"].async) try {
+			let n = this._parseSync({
+				data: e,
+				path: [],
+				parent: t
+			});
+			return y(n) ? { value: n.value } : { issues: t.common.issues };
+		} catch (e) {
+			e?.message?.toLowerCase()?.includes("encountered") && (this["~standard"].async = !0), t.common = {
+				issues: [],
+				async: !0
+			};
+		}
+		return this._parseAsync({
+			data: e,
+			path: [],
+			parent: t
+		}).then((e) => y(e) ? { value: e.value } : { issues: t.common.issues });
+	}
+	async parseAsync(e, t) {
+		let n = await this.safeParseAsync(e, t);
+		if (n.success) return n.data;
+		throw n.error;
+	}
+	async safeParseAsync(e, t) {
+		let n = {
+			common: {
+				issues: [],
+				contextualErrorMap: t?.errorMap,
+				async: !0
+			},
+			path: t?.path || [],
+			schemaErrorMap: this._def.errorMap,
+			parent: null,
+			data: e,
+			parsedType: d(e)
+		}, r = this._parse({
+			data: e,
+			path: n.path,
+			parent: n
+		});
+		return me(n, await (b(r) ? r : Promise.resolve(r)));
+	}
+	refine(e, t) {
+		let n = (e) => typeof t == "string" || t === void 0 ? { message: t } : typeof t == "function" ? t(e) : t;
+		return this._refinement((t, r) => {
+			let i = e(t), a = () => r.addIssue({
+				code: f.custom,
+				...n(t)
+			});
+			return typeof Promise < "u" && i instanceof Promise ? i.then((e) => e ? !0 : (a(), !1)) : i ? !0 : (a(), !1);
+		});
+	}
+	refinement(e, t) {
+		return this._refinement((n, r) => e(n) ? !0 : (r.addIssue(typeof t == "function" ? t(n, r) : t), !1));
+	}
+	_refinement(e) {
+		return new W({
+			schema: this,
+			typeName: Z.ZodEffects,
+			effect: {
+				type: "refinement",
+				refinement: e
+			}
+		});
+	}
+	superRefine(e) {
+		return this._refinement(e);
+	}
+	constructor(e) {
+		this.spa = this.safeParseAsync, this._def = e, this.parse = this.parse.bind(this), this.safeParse = this.safeParse.bind(this), this.parseAsync = this.parseAsync.bind(this), this.safeParseAsync = this.safeParseAsync.bind(this), this.spa = this.spa.bind(this), this.refine = this.refine.bind(this), this.refinement = this.refinement.bind(this), this.superRefine = this.superRefine.bind(this), this.optional = this.optional.bind(this), this.nullable = this.nullable.bind(this), this.nullish = this.nullish.bind(this), this.array = this.array.bind(this), this.promise = this.promise.bind(this), this.or = this.or.bind(this), this.and = this.and.bind(this), this.transform = this.transform.bind(this), this.brand = this.brand.bind(this), this.default = this.default.bind(this), this.catch = this.catch.bind(this), this.describe = this.describe.bind(this), this.pipe = this.pipe.bind(this), this.readonly = this.readonly.bind(this), this.isNullable = this.isNullable.bind(this), this.isOptional = this.isOptional.bind(this), this["~standard"] = {
+			version: 1,
+			vendor: "zod",
+			validate: (e) => this["~validate"](e)
+		};
+	}
+	optional() {
+		return G.create(this, this._def);
+	}
+	nullable() {
+		return K.create(this, this._def);
+	}
+	nullish() {
+		return this.nullable().optional();
+	}
+	array() {
+		return M.create(this);
+	}
+	promise() {
+		return U.create(this, this._def);
+	}
+	or(e) {
+		return F.create([this, e], this._def);
+	}
+	and(e) {
+		return L.create(this, e, this._def);
+	}
+	transform(e) {
+		return new W({
+			...C(this._def),
+			schema: this,
+			typeName: Z.ZodEffects,
+			effect: {
+				type: "transform",
+				transform: e
+			}
+		});
+	}
+	default(e) {
+		let t = typeof e == "function" ? e : () => e;
+		return new q({
+			...C(this._def),
+			innerType: this,
+			defaultValue: t,
+			typeName: Z.ZodDefault
+		});
+	}
+	brand() {
+		return new Qe({
+			typeName: Z.ZodBranded,
+			type: this,
+			...C(this._def)
+		});
+	}
+	catch(e) {
+		let t = typeof e == "function" ? e : () => e;
+		return new J({
+			...C(this._def),
+			innerType: this,
+			catchValue: t,
+			typeName: Z.ZodCatch
+		});
+	}
+	describe(e) {
+		let t = this.constructor;
+		return new t({
+			...this._def,
+			description: e
+		});
+	}
+	pipe(e) {
+		return $e.create(this, e);
+	}
+	readonly() {
+		return X.create(this);
+	}
+	isOptional() {
+		return this.safeParse(void 0).success;
+	}
+	isNullable() {
+		return this.safeParse(null).success;
+	}
+}, he = /^c[^\s-]{8,}$/i, ge = /^[0-9a-z]+$/, _e = /^[0-9A-HJKMNP-TV-Z]{26}$/i, ve = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i, ye = /^[a-z0-9_-]{21}$/i, be = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/, xe = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/, Se = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, Ce = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", we, Te = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/, Ee = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/, De = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/, Oe = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/, ke = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, Ae = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/, je = "((\\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])))", Me = RegExp(`^${je}$`);
+function Ne(e) {
+	let t = "[0-5]\\d";
+	e.precision ? t = `${t}\\.\\d{${e.precision}}` : e.precision ?? (t = `${t}(\\.\\d+)?`);
+	let n = e.precision ? "+" : "?";
+	return `([01]\\d|2[0-3]):[0-5]\\d(:${t})${n}`;
+}
+function Pe(e) {
+	return RegExp(`^${Ne(e)}$`);
+}
+function Fe(e) {
+	let t = `${je}T${Ne(e)}`, n = [];
+	return n.push(e.local ? "Z?" : "Z"), e.offset && n.push("([+-]\\d{2}:?\\d{2})"), t = `${t}(${n.join("|")})`, RegExp(`^${t}$`);
+}
+function Ie(e, t) {
+	return !!((t === "v4" || !t) && Te.test(e) || (t === "v6" || !t) && De.test(e));
+}
+function Le(e, t) {
+	if (!be.test(e)) return !1;
+	try {
+		let [n] = e.split(".");
+		if (!n) return !1;
+		let r = n.replace(/-/g, "+").replace(/_/g, "/").padEnd(n.length + (4 - n.length % 4) % 4, "="), i = JSON.parse(atob(r));
+		return !(typeof i != "object" || !i || "typ" in i && i?.typ !== "JWT" || !i.alg || t && i.alg !== t);
+	} catch {
+		return !1;
+	}
+}
+function Re(e, t) {
+	return !!((t === "v4" || !t) && Ee.test(e) || (t === "v6" || !t) && Oe.test(e));
+}
+var T = class e extends w {
+	_parse(e) {
+		if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== u.string) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				code: f.invalid_type,
+				expected: u.string,
+				received: t.parsedType
+			}), _;
+		}
+		let t = new g(), n;
+		for (let r of this._def.checks) if (r.kind === "min") e.data.length < r.value && (n = this._getOrReturnCtx(e, n), h(n, {
+			code: f.too_small,
+			minimum: r.value,
+			type: "string",
+			inclusive: !0,
+			exact: !1,
+			message: r.message
+		}), t.dirty());
+		else if (r.kind === "max") e.data.length > r.value && (n = this._getOrReturnCtx(e, n), h(n, {
+			code: f.too_big,
+			maximum: r.value,
+			type: "string",
+			inclusive: !0,
+			exact: !1,
+			message: r.message
+		}), t.dirty());
+		else if (r.kind === "length") {
+			let i = e.data.length > r.value, a = e.data.length < r.value;
+			(i || a) && (n = this._getOrReturnCtx(e, n), i ? h(n, {
+				code: f.too_big,
+				maximum: r.value,
+				type: "string",
+				inclusive: !0,
+				exact: !0,
+				message: r.message
+			}) : a && h(n, {
+				code: f.too_small,
+				minimum: r.value,
+				type: "string",
+				inclusive: !0,
+				exact: !0,
+				message: r.message
+			}), t.dirty());
+		} else if (r.kind === "email") Se.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "email",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty());
+		else if (r.kind === "emoji") we ||= new RegExp(Ce, "u"), we.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "emoji",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty());
+		else if (r.kind === "uuid") ve.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "uuid",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty());
+		else if (r.kind === "nanoid") ye.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "nanoid",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty());
+		else if (r.kind === "cuid") he.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "cuid",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty());
+		else if (r.kind === "cuid2") ge.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "cuid2",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty());
+		else if (r.kind === "ulid") _e.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "ulid",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty());
+		else if (r.kind === "url") try {
+			new URL(e.data);
+		} catch {
+			n = this._getOrReturnCtx(e, n), h(n, {
+				validation: "url",
+				code: f.invalid_string,
+				message: r.message
+			}), t.dirty();
+		}
+		else r.kind === "regex" ? (r.regex.lastIndex = 0, r.regex.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "regex",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty())) : r.kind === "trim" ? e.data = e.data.trim() : r.kind === "includes" ? e.data.includes(r.value, r.position) || (n = this._getOrReturnCtx(e, n), h(n, {
+			code: f.invalid_string,
+			validation: {
+				includes: r.value,
+				position: r.position
+			},
+			message: r.message
+		}), t.dirty()) : r.kind === "toLowerCase" ? e.data = e.data.toLowerCase() : r.kind === "toUpperCase" ? e.data = e.data.toUpperCase() : r.kind === "startsWith" ? e.data.startsWith(r.value) || (n = this._getOrReturnCtx(e, n), h(n, {
+			code: f.invalid_string,
+			validation: { startsWith: r.value },
+			message: r.message
+		}), t.dirty()) : r.kind === "endsWith" ? e.data.endsWith(r.value) || (n = this._getOrReturnCtx(e, n), h(n, {
+			code: f.invalid_string,
+			validation: { endsWith: r.value },
+			message: r.message
+		}), t.dirty()) : r.kind === "datetime" ? Fe(r).test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			code: f.invalid_string,
+			validation: "datetime",
+			message: r.message
+		}), t.dirty()) : r.kind === "date" ? Me.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			code: f.invalid_string,
+			validation: "date",
+			message: r.message
+		}), t.dirty()) : r.kind === "time" ? Pe(r).test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			code: f.invalid_string,
+			validation: "time",
+			message: r.message
+		}), t.dirty()) : r.kind === "duration" ? xe.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "duration",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty()) : r.kind === "ip" ? Ie(e.data, r.version) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "ip",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty()) : r.kind === "jwt" ? Le(e.data, r.alg) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "jwt",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty()) : r.kind === "cidr" ? Re(e.data, r.version) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "cidr",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty()) : r.kind === "base64" ? ke.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "base64",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty()) : r.kind === "base64url" ? Ae.test(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+			validation: "base64url",
+			code: f.invalid_string,
+			message: r.message
+		}), t.dirty()) : l.assertNever(r);
+		return {
+			status: t.value,
+			value: e.data
+		};
+	}
+	_regex(e, t, n) {
+		return this.refinement((t) => e.test(t), {
+			validation: t,
+			code: f.invalid_string,
+			...x.errToObj(n)
+		});
+	}
+	_addCheck(t) {
+		return new e({
+			...this._def,
+			checks: [...this._def.checks, t]
+		});
+	}
+	email(e) {
+		return this._addCheck({
+			kind: "email",
+			...x.errToObj(e)
+		});
+	}
+	url(e) {
+		return this._addCheck({
+			kind: "url",
+			...x.errToObj(e)
+		});
+	}
+	emoji(e) {
+		return this._addCheck({
+			kind: "emoji",
+			...x.errToObj(e)
+		});
+	}
+	uuid(e) {
+		return this._addCheck({
+			kind: "uuid",
+			...x.errToObj(e)
+		});
+	}
+	nanoid(e) {
+		return this._addCheck({
+			kind: "nanoid",
+			...x.errToObj(e)
+		});
+	}
+	cuid(e) {
+		return this._addCheck({
+			kind: "cuid",
+			...x.errToObj(e)
+		});
+	}
+	cuid2(e) {
+		return this._addCheck({
+			kind: "cuid2",
+			...x.errToObj(e)
+		});
+	}
+	ulid(e) {
+		return this._addCheck({
+			kind: "ulid",
+			...x.errToObj(e)
+		});
+	}
+	base64(e) {
+		return this._addCheck({
+			kind: "base64",
+			...x.errToObj(e)
+		});
+	}
+	base64url(e) {
+		return this._addCheck({
+			kind: "base64url",
+			...x.errToObj(e)
+		});
+	}
+	jwt(e) {
+		return this._addCheck({
+			kind: "jwt",
+			...x.errToObj(e)
+		});
+	}
+	ip(e) {
+		return this._addCheck({
+			kind: "ip",
+			...x.errToObj(e)
+		});
+	}
+	cidr(e) {
+		return this._addCheck({
+			kind: "cidr",
+			...x.errToObj(e)
+		});
+	}
+	datetime(e) {
+		return typeof e == "string" ? this._addCheck({
+			kind: "datetime",
+			precision: null,
+			offset: !1,
+			local: !1,
+			message: e
+		}) : this._addCheck({
+			kind: "datetime",
+			precision: e?.precision === void 0 ? null : e?.precision,
+			offset: e?.offset ?? !1,
+			local: e?.local ?? !1,
+			...x.errToObj(e?.message)
+		});
+	}
+	date(e) {
+		return this._addCheck({
+			kind: "date",
+			message: e
+		});
+	}
+	time(e) {
+		return typeof e == "string" ? this._addCheck({
+			kind: "time",
+			precision: null,
+			message: e
+		}) : this._addCheck({
+			kind: "time",
+			precision: e?.precision === void 0 ? null : e?.precision,
+			...x.errToObj(e?.message)
+		});
+	}
+	duration(e) {
+		return this._addCheck({
+			kind: "duration",
+			...x.errToObj(e)
+		});
+	}
+	regex(e, t) {
+		return this._addCheck({
+			kind: "regex",
+			regex: e,
+			...x.errToObj(t)
+		});
+	}
+	includes(e, t) {
+		return this._addCheck({
+			kind: "includes",
+			value: e,
+			position: t?.position,
+			...x.errToObj(t?.message)
+		});
+	}
+	startsWith(e, t) {
+		return this._addCheck({
+			kind: "startsWith",
+			value: e,
+			...x.errToObj(t)
+		});
+	}
+	endsWith(e, t) {
+		return this._addCheck({
+			kind: "endsWith",
+			value: e,
+			...x.errToObj(t)
+		});
+	}
+	min(e, t) {
+		return this._addCheck({
+			kind: "min",
+			value: e,
+			...x.errToObj(t)
+		});
+	}
+	max(e, t) {
+		return this._addCheck({
+			kind: "max",
+			value: e,
+			...x.errToObj(t)
+		});
+	}
+	length(e, t) {
+		return this._addCheck({
+			kind: "length",
+			value: e,
+			...x.errToObj(t)
+		});
+	}
+	nonempty(e) {
+		return this.min(1, x.errToObj(e));
+	}
+	trim() {
+		return new e({
+			...this._def,
+			checks: [...this._def.checks, { kind: "trim" }]
+		});
+	}
+	toLowerCase() {
+		return new e({
+			...this._def,
+			checks: [...this._def.checks, { kind: "toLowerCase" }]
+		});
+	}
+	toUpperCase() {
+		return new e({
+			...this._def,
+			checks: [...this._def.checks, { kind: "toUpperCase" }]
+		});
+	}
+	get isDatetime() {
+		return !!this._def.checks.find((e) => e.kind === "datetime");
+	}
+	get isDate() {
+		return !!this._def.checks.find((e) => e.kind === "date");
+	}
+	get isTime() {
+		return !!this._def.checks.find((e) => e.kind === "time");
+	}
+	get isDuration() {
+		return !!this._def.checks.find((e) => e.kind === "duration");
+	}
+	get isEmail() {
+		return !!this._def.checks.find((e) => e.kind === "email");
+	}
+	get isURL() {
+		return !!this._def.checks.find((e) => e.kind === "url");
+	}
+	get isEmoji() {
+		return !!this._def.checks.find((e) => e.kind === "emoji");
+	}
+	get isUUID() {
+		return !!this._def.checks.find((e) => e.kind === "uuid");
+	}
+	get isNANOID() {
+		return !!this._def.checks.find((e) => e.kind === "nanoid");
+	}
+	get isCUID() {
+		return !!this._def.checks.find((e) => e.kind === "cuid");
+	}
+	get isCUID2() {
+		return !!this._def.checks.find((e) => e.kind === "cuid2");
+	}
+	get isULID() {
+		return !!this._def.checks.find((e) => e.kind === "ulid");
+	}
+	get isIP() {
+		return !!this._def.checks.find((e) => e.kind === "ip");
+	}
+	get isCIDR() {
+		return !!this._def.checks.find((e) => e.kind === "cidr");
+	}
+	get isBase64() {
+		return !!this._def.checks.find((e) => e.kind === "base64");
+	}
+	get isBase64url() {
+		return !!this._def.checks.find((e) => e.kind === "base64url");
+	}
+	get minLength() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+		return e;
+	}
+	get maxLength() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+		return e;
+	}
+};
+T.create = (e) => new T({
+	checks: [],
+	typeName: Z.ZodString,
+	coerce: e?.coerce ?? !1,
+	...C(e)
+});
+function ze(e, t) {
+	let n = (e.toString().split(".")[1] || "").length, r = (t.toString().split(".")[1] || "").length, i = n > r ? n : r;
+	return Number.parseInt(e.toFixed(i).replace(".", "")) % Number.parseInt(t.toFixed(i).replace(".", "")) / 10 ** i;
+}
+var E = class e extends w {
+	constructor() {
+		super(...arguments), this.min = this.gte, this.max = this.lte, this.step = this.multipleOf;
+	}
+	_parse(e) {
+		if (this._def.coerce && (e.data = Number(e.data)), this._getType(e) !== u.number) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				code: f.invalid_type,
+				expected: u.number,
+				received: t.parsedType
+			}), _;
+		}
+		let t, n = new g();
+		for (let r of this._def.checks) r.kind === "int" ? l.isInteger(e.data) || (t = this._getOrReturnCtx(e, t), h(t, {
+			code: f.invalid_type,
+			expected: "integer",
+			received: "float",
+			message: r.message
+		}), n.dirty()) : r.kind === "min" ? (r.inclusive ? e.data < r.value : e.data <= r.value) && (t = this._getOrReturnCtx(e, t), h(t, {
+			code: f.too_small,
+			minimum: r.value,
+			type: "number",
+			inclusive: r.inclusive,
+			exact: !1,
+			message: r.message
+		}), n.dirty()) : r.kind === "max" ? (r.inclusive ? e.data > r.value : e.data >= r.value) && (t = this._getOrReturnCtx(e, t), h(t, {
+			code: f.too_big,
+			maximum: r.value,
+			type: "number",
+			inclusive: r.inclusive,
+			exact: !1,
+			message: r.message
+		}), n.dirty()) : r.kind === "multipleOf" ? ze(e.data, r.value) !== 0 && (t = this._getOrReturnCtx(e, t), h(t, {
+			code: f.not_multiple_of,
+			multipleOf: r.value,
+			message: r.message
+		}), n.dirty()) : r.kind === "finite" ? Number.isFinite(e.data) || (t = this._getOrReturnCtx(e, t), h(t, {
+			code: f.not_finite,
+			message: r.message
+		}), n.dirty()) : l.assertNever(r);
+		return {
+			status: n.value,
+			value: e.data
+		};
+	}
+	gte(e, t) {
+		return this.setLimit("min", e, !0, x.toString(t));
+	}
+	gt(e, t) {
+		return this.setLimit("min", e, !1, x.toString(t));
+	}
+	lte(e, t) {
+		return this.setLimit("max", e, !0, x.toString(t));
+	}
+	lt(e, t) {
+		return this.setLimit("max", e, !1, x.toString(t));
+	}
+	setLimit(t, n, r, i) {
+		return new e({
+			...this._def,
+			checks: [...this._def.checks, {
+				kind: t,
+				value: n,
+				inclusive: r,
+				message: x.toString(i)
+			}]
+		});
+	}
+	_addCheck(t) {
+		return new e({
+			...this._def,
+			checks: [...this._def.checks, t]
+		});
+	}
+	int(e) {
+		return this._addCheck({
+			kind: "int",
+			message: x.toString(e)
+		});
+	}
+	positive(e) {
+		return this._addCheck({
+			kind: "min",
+			value: 0,
+			inclusive: !1,
+			message: x.toString(e)
+		});
+	}
+	negative(e) {
+		return this._addCheck({
+			kind: "max",
+			value: 0,
+			inclusive: !1,
+			message: x.toString(e)
+		});
+	}
+	nonpositive(e) {
+		return this._addCheck({
+			kind: "max",
+			value: 0,
+			inclusive: !0,
+			message: x.toString(e)
+		});
+	}
+	nonnegative(e) {
+		return this._addCheck({
+			kind: "min",
+			value: 0,
+			inclusive: !0,
+			message: x.toString(e)
+		});
+	}
+	multipleOf(e, t) {
+		return this._addCheck({
+			kind: "multipleOf",
+			value: e,
+			message: x.toString(t)
+		});
+	}
+	finite(e) {
+		return this._addCheck({
+			kind: "finite",
+			message: x.toString(e)
+		});
+	}
+	safe(e) {
+		return this._addCheck({
+			kind: "min",
+			inclusive: !0,
+			value: -(2 ** 53 - 1),
+			message: x.toString(e)
+		})._addCheck({
+			kind: "max",
+			inclusive: !0,
+			value: 2 ** 53 - 1,
+			message: x.toString(e)
+		});
+	}
+	get minValue() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+		return e;
+	}
+	get maxValue() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+		return e;
+	}
+	get isInt() {
+		return !!this._def.checks.find((e) => e.kind === "int" || e.kind === "multipleOf" && l.isInteger(e.value));
+	}
+	get isFinite() {
+		let e = null, t = null;
+		for (let n of this._def.checks) if (n.kind === "finite" || n.kind === "int" || n.kind === "multipleOf") return !0;
+		else n.kind === "min" ? (t === null || n.value > t) && (t = n.value) : n.kind === "max" && (e === null || n.value < e) && (e = n.value);
+		return Number.isFinite(t) && Number.isFinite(e);
+	}
+};
+E.create = (e) => new E({
+	checks: [],
+	typeName: Z.ZodNumber,
+	coerce: e?.coerce || !1,
+	...C(e)
+});
+var D = class e extends w {
+	constructor() {
+		super(...arguments), this.min = this.gte, this.max = this.lte;
+	}
+	_parse(e) {
+		if (this._def.coerce) try {
+			e.data = BigInt(e.data);
+		} catch {
+			return this._getInvalidInput(e);
+		}
+		if (this._getType(e) !== u.bigint) return this._getInvalidInput(e);
+		let t, n = new g();
+		for (let r of this._def.checks) r.kind === "min" ? (r.inclusive ? e.data < r.value : e.data <= r.value) && (t = this._getOrReturnCtx(e, t), h(t, {
+			code: f.too_small,
+			type: "bigint",
+			minimum: r.value,
+			inclusive: r.inclusive,
+			message: r.message
+		}), n.dirty()) : r.kind === "max" ? (r.inclusive ? e.data > r.value : e.data >= r.value) && (t = this._getOrReturnCtx(e, t), h(t, {
+			code: f.too_big,
+			type: "bigint",
+			maximum: r.value,
+			inclusive: r.inclusive,
+			message: r.message
+		}), n.dirty()) : r.kind === "multipleOf" ? e.data % r.value !== BigInt(0) && (t = this._getOrReturnCtx(e, t), h(t, {
+			code: f.not_multiple_of,
+			multipleOf: r.value,
+			message: r.message
+		}), n.dirty()) : l.assertNever(r);
+		return {
+			status: n.value,
+			value: e.data
+		};
+	}
+	_getInvalidInput(e) {
+		let t = this._getOrReturnCtx(e);
+		return h(t, {
+			code: f.invalid_type,
+			expected: u.bigint,
+			received: t.parsedType
+		}), _;
+	}
+	gte(e, t) {
+		return this.setLimit("min", e, !0, x.toString(t));
+	}
+	gt(e, t) {
+		return this.setLimit("min", e, !1, x.toString(t));
+	}
+	lte(e, t) {
+		return this.setLimit("max", e, !0, x.toString(t));
+	}
+	lt(e, t) {
+		return this.setLimit("max", e, !1, x.toString(t));
+	}
+	setLimit(t, n, r, i) {
+		return new e({
+			...this._def,
+			checks: [...this._def.checks, {
+				kind: t,
+				value: n,
+				inclusive: r,
+				message: x.toString(i)
+			}]
+		});
+	}
+	_addCheck(t) {
+		return new e({
+			...this._def,
+			checks: [...this._def.checks, t]
+		});
+	}
+	positive(e) {
+		return this._addCheck({
+			kind: "min",
+			value: BigInt(0),
+			inclusive: !1,
+			message: x.toString(e)
+		});
+	}
+	negative(e) {
+		return this._addCheck({
+			kind: "max",
+			value: BigInt(0),
+			inclusive: !1,
+			message: x.toString(e)
+		});
+	}
+	nonpositive(e) {
+		return this._addCheck({
+			kind: "max",
+			value: BigInt(0),
+			inclusive: !0,
+			message: x.toString(e)
+		});
+	}
+	nonnegative(e) {
+		return this._addCheck({
+			kind: "min",
+			value: BigInt(0),
+			inclusive: !0,
+			message: x.toString(e)
+		});
+	}
+	multipleOf(e, t) {
+		return this._addCheck({
+			kind: "multipleOf",
+			value: e,
+			message: x.toString(t)
+		});
+	}
+	get minValue() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+		return e;
+	}
+	get maxValue() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+		return e;
+	}
+};
+D.create = (e) => new D({
+	checks: [],
+	typeName: Z.ZodBigInt,
+	coerce: e?.coerce ?? !1,
+	...C(e)
+});
+var Be = class extends w {
+	_parse(e) {
+		if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== u.boolean) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				code: f.invalid_type,
+				expected: u.boolean,
+				received: t.parsedType
+			}), _;
+		}
+		return v(e.data);
+	}
+};
+Be.create = (e) => new Be({
+	typeName: Z.ZodBoolean,
+	coerce: e?.coerce || !1,
+	...C(e)
+});
+var Ve = class e extends w {
+	_parse(e) {
+		if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== u.date) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				code: f.invalid_type,
+				expected: u.date,
+				received: t.parsedType
+			}), _;
+		}
+		if (Number.isNaN(e.data.getTime())) return h(this._getOrReturnCtx(e), { code: f.invalid_date }), _;
+		let t = new g(), n;
+		for (let r of this._def.checks) r.kind === "min" ? e.data.getTime() < r.value && (n = this._getOrReturnCtx(e, n), h(n, {
+			code: f.too_small,
+			message: r.message,
+			inclusive: !0,
+			exact: !1,
+			minimum: r.value,
+			type: "date"
+		}), t.dirty()) : r.kind === "max" ? e.data.getTime() > r.value && (n = this._getOrReturnCtx(e, n), h(n, {
+			code: f.too_big,
+			message: r.message,
+			inclusive: !0,
+			exact: !1,
+			maximum: r.value,
+			type: "date"
+		}), t.dirty()) : l.assertNever(r);
+		return {
+			status: t.value,
+			value: new Date(e.data.getTime())
+		};
+	}
+	_addCheck(t) {
+		return new e({
+			...this._def,
+			checks: [...this._def.checks, t]
+		});
+	}
+	min(e, t) {
+		return this._addCheck({
+			kind: "min",
+			value: e.getTime(),
+			message: x.toString(t)
+		});
+	}
+	max(e, t) {
+		return this._addCheck({
+			kind: "max",
+			value: e.getTime(),
+			message: x.toString(t)
+		});
+	}
+	get minDate() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+		return e == null ? null : new Date(e);
+	}
+	get maxDate() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+		return e == null ? null : new Date(e);
+	}
+};
+Ve.create = (e) => new Ve({
+	checks: [],
+	coerce: e?.coerce || !1,
+	typeName: Z.ZodDate,
+	...C(e)
+});
+var He = class extends w {
+	_parse(e) {
+		if (this._getType(e) !== u.symbol) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				code: f.invalid_type,
+				expected: u.symbol,
+				received: t.parsedType
+			}), _;
+		}
+		return v(e.data);
+	}
+};
+He.create = (e) => new He({
+	typeName: Z.ZodSymbol,
+	...C(e)
+});
+var O = class extends w {
+	_parse(e) {
+		if (this._getType(e) !== u.undefined) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				code: f.invalid_type,
+				expected: u.undefined,
+				received: t.parsedType
+			}), _;
+		}
+		return v(e.data);
+	}
+};
+O.create = (e) => new O({
+	typeName: Z.ZodUndefined,
+	...C(e)
+});
+var k = class extends w {
+	_parse(e) {
+		if (this._getType(e) !== u.null) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				code: f.invalid_type,
+				expected: u.null,
+				received: t.parsedType
+			}), _;
+		}
+		return v(e.data);
+	}
+};
+k.create = (e) => new k({
+	typeName: Z.ZodNull,
+	...C(e)
+});
+var Ue = class extends w {
+	constructor() {
+		super(...arguments), this._any = !0;
+	}
+	_parse(e) {
+		return v(e.data);
+	}
+};
+Ue.create = (e) => new Ue({
+	typeName: Z.ZodAny,
+	...C(e)
+});
+var A = class extends w {
+	constructor() {
+		super(...arguments), this._unknown = !0;
+	}
+	_parse(e) {
+		return v(e.data);
+	}
+};
+A.create = (e) => new A({
+	typeName: Z.ZodUnknown,
+	...C(e)
+});
+var j = class extends w {
+	_parse(e) {
+		let t = this._getOrReturnCtx(e);
+		return h(t, {
+			code: f.invalid_type,
+			expected: u.never,
+			received: t.parsedType
+		}), _;
+	}
+};
+j.create = (e) => new j({
+	typeName: Z.ZodNever,
+	...C(e)
+});
+var We = class extends w {
+	_parse(e) {
+		if (this._getType(e) !== u.undefined) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				code: f.invalid_type,
+				expected: u.void,
+				received: t.parsedType
+			}), _;
+		}
+		return v(e.data);
+	}
+};
+We.create = (e) => new We({
+	typeName: Z.ZodVoid,
+	...C(e)
+});
+var M = class e extends w {
+	_parse(e) {
+		let { ctx: t, status: n } = this._processInputParams(e), r = this._def;
+		if (t.parsedType !== u.array) return h(t, {
+			code: f.invalid_type,
+			expected: u.array,
+			received: t.parsedType
+		}), _;
+		if (r.exactLength !== null) {
+			let e = t.data.length > r.exactLength.value, i = t.data.length < r.exactLength.value;
+			(e || i) && (h(t, {
+				code: e ? f.too_big : f.too_small,
+				minimum: i ? r.exactLength.value : void 0,
+				maximum: e ? r.exactLength.value : void 0,
+				type: "array",
+				inclusive: !0,
+				exact: !0,
+				message: r.exactLength.message
+			}), n.dirty());
+		}
+		if (r.minLength !== null && t.data.length < r.minLength.value && (h(t, {
+			code: f.too_small,
+			minimum: r.minLength.value,
+			type: "array",
+			inclusive: !0,
+			exact: !1,
+			message: r.minLength.message
+		}), n.dirty()), r.maxLength !== null && t.data.length > r.maxLength.value && (h(t, {
+			code: f.too_big,
+			maximum: r.maxLength.value,
+			type: "array",
+			inclusive: !0,
+			exact: !1,
+			message: r.maxLength.message
+		}), n.dirty()), t.common.async) return Promise.all([...t.data].map((e, n) => r.type._parseAsync(new S(t, e, t.path, n)))).then((e) => g.mergeArray(n, e));
+		let i = [...t.data].map((e, n) => r.type._parseSync(new S(t, e, t.path, n)));
+		return g.mergeArray(n, i);
+	}
+	get element() {
+		return this._def.type;
+	}
+	min(t, n) {
+		return new e({
+			...this._def,
+			minLength: {
+				value: t,
+				message: x.toString(n)
+			}
+		});
+	}
+	max(t, n) {
+		return new e({
+			...this._def,
+			maxLength: {
+				value: t,
+				message: x.toString(n)
+			}
+		});
+	}
+	length(t, n) {
+		return new e({
+			...this._def,
+			exactLength: {
+				value: t,
+				message: x.toString(n)
+			}
+		});
+	}
+	nonempty(e) {
+		return this.min(1, e);
+	}
+};
+M.create = (e, t) => new M({
+	type: e,
+	minLength: null,
+	maxLength: null,
+	exactLength: null,
+	typeName: Z.ZodArray,
+	...C(t)
+});
+function N(e) {
+	if (e instanceof P) {
+		let t = {};
+		for (let n in e.shape) {
+			let r = e.shape[n];
+			t[n] = G.create(N(r));
+		}
+		return new P({
+			...e._def,
+			shape: () => t
+		});
+	}
+	return e instanceof M ? new M({
+		...e._def,
+		type: N(e.element)
+	}) : e instanceof G ? G.create(N(e.unwrap())) : e instanceof K ? K.create(N(e.unwrap())) : e instanceof R ? R.create(e.items.map((e) => N(e))) : e;
+}
+var P = class e extends w {
+	constructor() {
+		super(...arguments), this._cached = null, this.nonstrict = this.passthrough, this.augment = this.extend;
+	}
+	_getCached() {
+		if (this._cached !== null) return this._cached;
+		let e = this._def.shape(), t = l.objectKeys(e);
+		return this._cached = {
+			shape: e,
+			keys: t
+		}, this._cached;
+	}
+	_parse(e) {
+		if (this._getType(e) !== u.object) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				code: f.invalid_type,
+				expected: u.object,
+				received: t.parsedType
+			}), _;
+		}
+		let { status: t, ctx: n } = this._processInputParams(e), { shape: r, keys: i } = this._getCached(), a = [];
+		if (!(this._def.catchall instanceof j && this._def.unknownKeys === "strip")) for (let e in n.data) i.includes(e) || a.push(e);
+		let o = [];
+		for (let e of i) {
+			let t = r[e], i = n.data[e];
+			o.push({
+				key: {
+					status: "valid",
+					value: e
+				},
+				value: t._parse(new S(n, i, n.path, e)),
+				alwaysSet: e in n.data
+			});
+		}
+		if (this._def.catchall instanceof j) {
+			let e = this._def.unknownKeys;
+			if (e === "passthrough") for (let e of a) o.push({
+				key: {
+					status: "valid",
+					value: e
+				},
+				value: {
+					status: "valid",
+					value: n.data[e]
+				}
+			});
+			else if (e === "strict") a.length > 0 && (h(n, {
+				code: f.unrecognized_keys,
+				keys: a
+			}), t.dirty());
+			else if (e !== "strip") throw Error("Internal ZodObject error: invalid unknownKeys value.");
+		} else {
+			let e = this._def.catchall;
+			for (let t of a) {
+				let r = n.data[t];
+				o.push({
+					key: {
+						status: "valid",
+						value: t
+					},
+					value: e._parse(new S(n, r, n.path, t)),
+					alwaysSet: t in n.data
+				});
+			}
+		}
+		return n.common.async ? Promise.resolve().then(async () => {
+			let e = [];
+			for (let t of o) {
+				let n = await t.key, r = await t.value;
+				e.push({
+					key: n,
+					value: r,
+					alwaysSet: t.alwaysSet
+				});
+			}
+			return e;
+		}).then((e) => g.mergeObjectSync(t, e)) : g.mergeObjectSync(t, o);
+	}
+	get shape() {
+		return this._def.shape();
+	}
+	strict(t) {
+		return x.errToObj, new e({
+			...this._def,
+			unknownKeys: "strict",
+			...t === void 0 ? {} : { errorMap: (e, n) => {
+				let r = this._def.errorMap?.(e, n).message ?? n.defaultError;
+				return e.code === "unrecognized_keys" ? { message: x.errToObj(t).message ?? r } : { message: r };
+			} }
+		});
+	}
+	strip() {
+		return new e({
+			...this._def,
+			unknownKeys: "strip"
+		});
+	}
+	passthrough() {
+		return new e({
+			...this._def,
+			unknownKeys: "passthrough"
+		});
+	}
+	extend(t) {
+		return new e({
+			...this._def,
+			shape: () => ({
+				...this._def.shape(),
+				...t
+			})
+		});
+	}
+	merge(t) {
+		return new e({
+			unknownKeys: t._def.unknownKeys,
+			catchall: t._def.catchall,
+			shape: () => ({
+				...this._def.shape(),
+				...t._def.shape()
+			}),
+			typeName: Z.ZodObject
+		});
+	}
+	setKey(e, t) {
+		return this.augment({ [e]: t });
+	}
+	catchall(t) {
+		return new e({
+			...this._def,
+			catchall: t
+		});
+	}
+	pick(t) {
+		let n = {};
+		for (let e of l.objectKeys(t)) t[e] && this.shape[e] && (n[e] = this.shape[e]);
+		return new e({
+			...this._def,
+			shape: () => n
+		});
+	}
+	omit(t) {
+		let n = {};
+		for (let e of l.objectKeys(this.shape)) t[e] || (n[e] = this.shape[e]);
+		return new e({
+			...this._def,
+			shape: () => n
+		});
+	}
+	deepPartial() {
+		return N(this);
+	}
+	partial(t) {
+		let n = {};
+		for (let e of l.objectKeys(this.shape)) {
+			let r = this.shape[e];
+			n[e] = t && !t[e] ? r : r.optional();
+		}
+		return new e({
+			...this._def,
+			shape: () => n
+		});
+	}
+	required(t) {
+		let n = {};
+		for (let e of l.objectKeys(this.shape)) if (t && !t[e]) n[e] = this.shape[e];
+		else {
+			let t = this.shape[e];
+			for (; t instanceof G;) t = t._def.innerType;
+			n[e] = t;
+		}
+		return new e({
+			...this._def,
+			shape: () => n
+		});
+	}
+	keyof() {
+		return Ze(l.objectKeys(this.shape));
+	}
+};
+P.create = (e, t) => new P({
+	shape: () => e,
+	unknownKeys: "strip",
+	catchall: j.create(),
+	typeName: Z.ZodObject,
+	...C(t)
+}), P.strictCreate = (e, t) => new P({
+	shape: () => e,
+	unknownKeys: "strict",
+	catchall: j.create(),
+	typeName: Z.ZodObject,
+	...C(t)
+}), P.lazycreate = (e, t) => new P({
+	shape: e,
+	unknownKeys: "strip",
+	catchall: j.create(),
+	typeName: Z.ZodObject,
+	...C(t)
+});
+var F = class extends w {
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e), n = this._def.options;
+		function r(e) {
+			for (let t of e) if (t.result.status === "valid") return t.result;
+			for (let n of e) if (n.result.status === "dirty") return t.common.issues.push(...n.ctx.common.issues), n.result;
+			let n = e.map((e) => new p(e.ctx.common.issues));
+			return h(t, {
+				code: f.invalid_union,
+				unionErrors: n
+			}), _;
+		}
+		if (t.common.async) return Promise.all(n.map(async (e) => {
+			let n = {
+				...t,
+				common: {
+					...t.common,
+					issues: []
+				},
+				parent: null
+			};
+			return {
+				result: await e._parseAsync({
+					data: t.data,
+					path: t.path,
+					parent: n
+				}),
+				ctx: n
+			};
+		})).then(r);
+		{
+			let e, r = [];
+			for (let i of n) {
+				let n = {
+					...t,
+					common: {
+						...t.common,
+						issues: []
+					},
+					parent: null
+				}, a = i._parseSync({
+					data: t.data,
+					path: t.path,
+					parent: n
+				});
+				if (a.status === "valid") return a;
+				a.status === "dirty" && !e && (e = {
+					result: a,
+					ctx: n
+				}), n.common.issues.length && r.push(n.common.issues);
+			}
+			if (e) return t.common.issues.push(...e.ctx.common.issues), e.result;
+			let i = r.map((e) => new p(e));
+			return h(t, {
+				code: f.invalid_union,
+				unionErrors: i
+			}), _;
+		}
+	}
+	get options() {
+		return this._def.options;
+	}
+};
+F.create = (e, t) => new F({
+	options: e,
+	typeName: Z.ZodUnion,
+	...C(t)
+});
+var I = (e) => e instanceof z ? I(e.schema) : e instanceof W ? I(e.innerType()) : e instanceof B ? [e.value] : e instanceof V ? e.options : e instanceof H ? l.objectValues(e.enum) : e instanceof q ? I(e._def.innerType) : e instanceof O ? [void 0] : e instanceof k ? [null] : e instanceof G ? [void 0, ...I(e.unwrap())] : e instanceof K ? [null, ...I(e.unwrap())] : e instanceof Qe || e instanceof X ? I(e.unwrap()) : e instanceof J ? I(e._def.innerType) : [], Ge = class e extends w {
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e);
+		if (t.parsedType !== u.object) return h(t, {
+			code: f.invalid_type,
+			expected: u.object,
+			received: t.parsedType
+		}), _;
+		let n = this.discriminator, r = t.data[n], i = this.optionsMap.get(r);
+		return i ? t.common.async ? i._parseAsync({
+			data: t.data,
+			path: t.path,
+			parent: t
+		}) : i._parseSync({
+			data: t.data,
+			path: t.path,
+			parent: t
+		}) : (h(t, {
+			code: f.invalid_union_discriminator,
+			options: Array.from(this.optionsMap.keys()),
+			path: [n]
+		}), _);
+	}
+	get discriminator() {
+		return this._def.discriminator;
+	}
+	get options() {
+		return this._def.options;
+	}
+	get optionsMap() {
+		return this._def.optionsMap;
+	}
+	static create(t, n, r) {
+		let i = /* @__PURE__ */ new Map();
+		for (let e of n) {
+			let n = I(e.shape[t]);
+			if (!n.length) throw Error(`A discriminator value for key \`${t}\` could not be extracted from all schema options`);
+			for (let r of n) {
+				if (i.has(r)) throw Error(`Discriminator property ${String(t)} has duplicate value ${String(r)}`);
+				i.set(r, e);
+			}
+		}
+		return new e({
+			typeName: Z.ZodDiscriminatedUnion,
+			discriminator: t,
+			options: n,
+			optionsMap: i,
+			...C(r)
+		});
+	}
+};
+function Ke(e, t) {
+	let n = d(e), r = d(t);
+	if (e === t) return {
+		valid: !0,
+		data: e
+	};
+	if (n === u.object && r === u.object) {
+		let n = l.objectKeys(t), r = l.objectKeys(e).filter((e) => n.indexOf(e) !== -1), i = {
+			...e,
+			...t
+		};
+		for (let n of r) {
+			let r = Ke(e[n], t[n]);
+			if (!r.valid) return { valid: !1 };
+			i[n] = r.data;
+		}
+		return {
+			valid: !0,
+			data: i
+		};
+	}
+	if (n === u.array && r === u.array) {
+		if (e.length !== t.length) return { valid: !1 };
+		let n = [];
+		for (let r = 0; r < e.length; r++) {
+			let i = e[r], a = t[r], o = Ke(i, a);
+			if (!o.valid) return { valid: !1 };
+			n.push(o.data);
+		}
+		return {
+			valid: !0,
+			data: n
+		};
+	}
+	return n === u.date && r === u.date && +e == +t ? {
+		valid: !0,
+		data: e
+	} : { valid: !1 };
+}
+var L = class extends w {
+	_parse(e) {
+		let { status: t, ctx: n } = this._processInputParams(e), r = (e, r) => {
+			if (fe(e) || fe(r)) return _;
+			let i = Ke(e.value, r.value);
+			return i.valid ? ((pe(e) || pe(r)) && t.dirty(), {
+				status: t.value,
+				value: i.data
+			}) : (h(n, { code: f.invalid_intersection_types }), _);
+		};
+		return n.common.async ? Promise.all([this._def.left._parseAsync({
+			data: n.data,
+			path: n.path,
+			parent: n
+		}), this._def.right._parseAsync({
+			data: n.data,
+			path: n.path,
+			parent: n
+		})]).then(([e, t]) => r(e, t)) : r(this._def.left._parseSync({
+			data: n.data,
+			path: n.path,
+			parent: n
+		}), this._def.right._parseSync({
+			data: n.data,
+			path: n.path,
+			parent: n
+		}));
+	}
+};
+L.create = (e, t, n) => new L({
+	left: e,
+	right: t,
+	typeName: Z.ZodIntersection,
+	...C(n)
+});
+var R = class e extends w {
+	_parse(e) {
+		let { status: t, ctx: n } = this._processInputParams(e);
+		if (n.parsedType !== u.array) return h(n, {
+			code: f.invalid_type,
+			expected: u.array,
+			received: n.parsedType
+		}), _;
+		if (n.data.length < this._def.items.length) return h(n, {
+			code: f.too_small,
+			minimum: this._def.items.length,
+			inclusive: !0,
+			exact: !1,
+			type: "array"
+		}), _;
+		!this._def.rest && n.data.length > this._def.items.length && (h(n, {
+			code: f.too_big,
+			maximum: this._def.items.length,
+			inclusive: !0,
+			exact: !1,
+			type: "array"
+		}), t.dirty());
+		let r = [...n.data].map((e, t) => {
+			let r = this._def.items[t] || this._def.rest;
+			return r ? r._parse(new S(n, e, n.path, t)) : null;
+		}).filter((e) => !!e);
+		return n.common.async ? Promise.all(r).then((e) => g.mergeArray(t, e)) : g.mergeArray(t, r);
+	}
+	get items() {
+		return this._def.items;
+	}
+	rest(t) {
+		return new e({
+			...this._def,
+			rest: t
+		});
+	}
+};
+R.create = (e, t) => {
+	if (!Array.isArray(e)) throw Error("You must pass an array of schemas to z.tuple([ ... ])");
+	return new R({
+		items: e,
+		typeName: Z.ZodTuple,
+		rest: null,
+		...C(t)
+	});
+};
+var qe = class e extends w {
+	get keySchema() {
+		return this._def.keyType;
+	}
+	get valueSchema() {
+		return this._def.valueType;
+	}
+	_parse(e) {
+		let { status: t, ctx: n } = this._processInputParams(e);
+		if (n.parsedType !== u.object) return h(n, {
+			code: f.invalid_type,
+			expected: u.object,
+			received: n.parsedType
+		}), _;
+		let r = [], i = this._def.keyType, a = this._def.valueType;
+		for (let e in n.data) r.push({
+			key: i._parse(new S(n, e, n.path, e)),
+			value: a._parse(new S(n, n.data[e], n.path, e)),
+			alwaysSet: e in n.data
+		});
+		return n.common.async ? g.mergeObjectAsync(t, r) : g.mergeObjectSync(t, r);
+	}
+	get element() {
+		return this._def.valueType;
+	}
+	static create(t, n, r) {
+		return n instanceof w ? new e({
+			keyType: t,
+			valueType: n,
+			typeName: Z.ZodRecord,
+			...C(r)
+		}) : new e({
+			keyType: T.create(),
+			valueType: t,
+			typeName: Z.ZodRecord,
+			...C(n)
+		});
+	}
+}, Je = class extends w {
+	get keySchema() {
+		return this._def.keyType;
+	}
+	get valueSchema() {
+		return this._def.valueType;
+	}
+	_parse(e) {
+		let { status: t, ctx: n } = this._processInputParams(e);
+		if (n.parsedType !== u.map) return h(n, {
+			code: f.invalid_type,
+			expected: u.map,
+			received: n.parsedType
+		}), _;
+		let r = this._def.keyType, i = this._def.valueType, a = [...n.data.entries()].map(([e, t], a) => ({
+			key: r._parse(new S(n, e, n.path, [a, "key"])),
+			value: i._parse(new S(n, t, n.path, [a, "value"]))
+		}));
+		if (n.common.async) {
+			let e = /* @__PURE__ */ new Map();
+			return Promise.resolve().then(async () => {
+				for (let n of a) {
+					let r = await n.key, i = await n.value;
+					if (r.status === "aborted" || i.status === "aborted") return _;
+					(r.status === "dirty" || i.status === "dirty") && t.dirty(), e.set(r.value, i.value);
+				}
+				return {
+					status: t.value,
+					value: e
+				};
+			});
+		}
+		{
+			let e = /* @__PURE__ */ new Map();
+			for (let n of a) {
+				let r = n.key, i = n.value;
+				if (r.status === "aborted" || i.status === "aborted") return _;
+				(r.status === "dirty" || i.status === "dirty") && t.dirty(), e.set(r.value, i.value);
+			}
+			return {
+				status: t.value,
+				value: e
+			};
+		}
+	}
+};
+Je.create = (e, t, n) => new Je({
+	valueType: t,
+	keyType: e,
+	typeName: Z.ZodMap,
+	...C(n)
+});
+var Ye = class e extends w {
+	_parse(e) {
+		let { status: t, ctx: n } = this._processInputParams(e);
+		if (n.parsedType !== u.set) return h(n, {
+			code: f.invalid_type,
+			expected: u.set,
+			received: n.parsedType
+		}), _;
+		let r = this._def;
+		r.minSize !== null && n.data.size < r.minSize.value && (h(n, {
+			code: f.too_small,
+			minimum: r.minSize.value,
+			type: "set",
+			inclusive: !0,
+			exact: !1,
+			message: r.minSize.message
+		}), t.dirty()), r.maxSize !== null && n.data.size > r.maxSize.value && (h(n, {
+			code: f.too_big,
+			maximum: r.maxSize.value,
+			type: "set",
+			inclusive: !0,
+			exact: !1,
+			message: r.maxSize.message
+		}), t.dirty());
+		let i = this._def.valueType;
+		function a(e) {
+			let n = /* @__PURE__ */ new Set();
+			for (let r of e) {
+				if (r.status === "aborted") return _;
+				r.status === "dirty" && t.dirty(), n.add(r.value);
+			}
+			return {
+				status: t.value,
+				value: n
+			};
+		}
+		let o = [...n.data.values()].map((e, t) => i._parse(new S(n, e, n.path, t)));
+		return n.common.async ? Promise.all(o).then((e) => a(e)) : a(o);
+	}
+	min(t, n) {
+		return new e({
+			...this._def,
+			minSize: {
+				value: t,
+				message: x.toString(n)
+			}
+		});
+	}
+	max(t, n) {
+		return new e({
+			...this._def,
+			maxSize: {
+				value: t,
+				message: x.toString(n)
+			}
+		});
+	}
+	size(e, t) {
+		return this.min(e, t).max(e, t);
+	}
+	nonempty(e) {
+		return this.min(1, e);
+	}
+};
+Ye.create = (e, t) => new Ye({
+	valueType: e,
+	minSize: null,
+	maxSize: null,
+	typeName: Z.ZodSet,
+	...C(t)
+});
+var Xe = class e extends w {
+	constructor() {
+		super(...arguments), this.validate = this.implement;
+	}
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e);
+		if (t.parsedType !== u.function) return h(t, {
+			code: f.invalid_type,
+			expected: u.function,
+			received: t.parsedType
+		}), _;
+		function n(e, n) {
+			return ue({
+				data: e,
+				path: t.path,
+				errorMaps: [
+					t.common.contextualErrorMap,
+					t.schemaErrorMap,
+					le(),
+					m
+				].filter((e) => !!e),
+				issueData: {
+					code: f.invalid_arguments,
+					argumentsError: n
+				}
+			});
+		}
+		function r(e, n) {
+			return ue({
+				data: e,
+				path: t.path,
+				errorMaps: [
+					t.common.contextualErrorMap,
+					t.schemaErrorMap,
+					le(),
+					m
+				].filter((e) => !!e),
+				issueData: {
+					code: f.invalid_return_type,
+					returnTypeError: n
+				}
+			});
+		}
+		let i = { errorMap: t.common.contextualErrorMap }, a = t.data;
+		if (this._def.returns instanceof U) {
+			let e = this;
+			return v(async function(...t) {
+				let o = new p([]), s = await e._def.args.parseAsync(t, i).catch((e) => {
+					throw o.addIssue(n(t, e)), o;
+				}), c = await Reflect.apply(a, this, s);
+				return await e._def.returns._def.type.parseAsync(c, i).catch((e) => {
+					throw o.addIssue(r(c, e)), o;
+				});
+			});
+		}
+		{
+			let e = this;
+			return v(function(...t) {
+				let o = e._def.args.safeParse(t, i);
+				if (!o.success) throw new p([n(t, o.error)]);
+				let s = Reflect.apply(a, this, o.data), c = e._def.returns.safeParse(s, i);
+				if (!c.success) throw new p([r(s, c.error)]);
+				return c.data;
+			});
+		}
+	}
+	parameters() {
+		return this._def.args;
+	}
+	returnType() {
+		return this._def.returns;
+	}
+	args(...t) {
+		return new e({
+			...this._def,
+			args: R.create(t).rest(A.create())
+		});
+	}
+	returns(t) {
+		return new e({
+			...this._def,
+			returns: t
+		});
+	}
+	implement(e) {
+		return this.parse(e);
+	}
+	strictImplement(e) {
+		return this.parse(e);
+	}
+	static create(t, n, r) {
+		return new e({
+			args: t || R.create([]).rest(A.create()),
+			returns: n || A.create(),
+			typeName: Z.ZodFunction,
+			...C(r)
+		});
+	}
+}, z = class extends w {
+	get schema() {
+		return this._def.getter();
+	}
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e);
+		return this._def.getter()._parse({
+			data: t.data,
+			path: t.path,
+			parent: t
+		});
+	}
+};
+z.create = (e, t) => new z({
+	getter: e,
+	typeName: Z.ZodLazy,
+	...C(t)
+});
+var B = class extends w {
+	_parse(e) {
+		if (e.data !== this._def.value) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				received: t.data,
+				code: f.invalid_literal,
+				expected: this._def.value
+			}), _;
+		}
+		return {
+			status: "valid",
+			value: e.data
+		};
+	}
+	get value() {
+		return this._def.value;
+	}
+};
+B.create = (e, t) => new B({
+	value: e,
+	typeName: Z.ZodLiteral,
+	...C(t)
+});
+function Ze(e, t) {
+	return new V({
+		values: e,
+		typeName: Z.ZodEnum,
+		...C(t)
+	});
+}
+var V = class e extends w {
+	_parse(e) {
+		if (typeof e.data != "string") {
+			let t = this._getOrReturnCtx(e), n = this._def.values;
+			return h(t, {
+				expected: l.joinValues(n),
+				received: t.parsedType,
+				code: f.invalid_type
+			}), _;
+		}
+		if (this._cache ||= new Set(this._def.values), !this._cache.has(e.data)) {
+			let t = this._getOrReturnCtx(e), n = this._def.values;
+			return h(t, {
+				received: t.data,
+				code: f.invalid_enum_value,
+				options: n
+			}), _;
+		}
+		return v(e.data);
+	}
+	get options() {
+		return this._def.values;
+	}
+	get enum() {
+		let e = {};
+		for (let t of this._def.values) e[t] = t;
+		return e;
+	}
+	get Values() {
+		let e = {};
+		for (let t of this._def.values) e[t] = t;
+		return e;
+	}
+	get Enum() {
+		let e = {};
+		for (let t of this._def.values) e[t] = t;
+		return e;
+	}
+	extract(t, n = this._def) {
+		return e.create(t, {
+			...this._def,
+			...n
+		});
+	}
+	exclude(t, n = this._def) {
+		return e.create(this.options.filter((e) => !t.includes(e)), {
+			...this._def,
+			...n
+		});
+	}
+};
+V.create = Ze;
+var H = class extends w {
+	_parse(e) {
+		let t = l.getValidEnumValues(this._def.values), n = this._getOrReturnCtx(e);
+		if (n.parsedType !== u.string && n.parsedType !== u.number) {
+			let e = l.objectValues(t);
+			return h(n, {
+				expected: l.joinValues(e),
+				received: n.parsedType,
+				code: f.invalid_type
+			}), _;
+		}
+		if (this._cache ||= new Set(l.getValidEnumValues(this._def.values)), !this._cache.has(e.data)) {
+			let e = l.objectValues(t);
+			return h(n, {
+				received: n.data,
+				code: f.invalid_enum_value,
+				options: e
+			}), _;
+		}
+		return v(e.data);
+	}
+	get enum() {
+		return this._def.values;
+	}
+};
+H.create = (e, t) => new H({
+	values: e,
+	typeName: Z.ZodNativeEnum,
+	...C(t)
+});
+var U = class extends w {
+	unwrap() {
+		return this._def.type;
+	}
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e);
+		return t.parsedType !== u.promise && t.common.async === !1 ? (h(t, {
+			code: f.invalid_type,
+			expected: u.promise,
+			received: t.parsedType
+		}), _) : v((t.parsedType === u.promise ? t.data : Promise.resolve(t.data)).then((e) => this._def.type.parseAsync(e, {
+			path: t.path,
+			errorMap: t.common.contextualErrorMap
+		})));
+	}
+};
+U.create = (e, t) => new U({
+	type: e,
+	typeName: Z.ZodPromise,
+	...C(t)
+});
+var W = class extends w {
+	innerType() {
+		return this._def.schema;
+	}
+	sourceType() {
+		return this._def.schema._def.typeName === Z.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+	}
+	_parse(e) {
+		let { status: t, ctx: n } = this._processInputParams(e), r = this._def.effect || null, i = {
+			addIssue: (e) => {
+				h(n, e), e.fatal ? t.abort() : t.dirty();
+			},
+			get path() {
+				return n.path;
+			}
+		};
+		if (i.addIssue = i.addIssue.bind(i), r.type === "preprocess") {
+			let e = r.transform(n.data, i);
+			if (n.common.async) return Promise.resolve(e).then(async (e) => {
+				if (t.value === "aborted") return _;
+				let r = await this._def.schema._parseAsync({
+					data: e,
+					path: n.path,
+					parent: n
+				});
+				return r.status === "aborted" ? _ : r.status === "dirty" || t.value === "dirty" ? de(r.value) : r;
+			});
+			{
+				if (t.value === "aborted") return _;
+				let r = this._def.schema._parseSync({
+					data: e,
+					path: n.path,
+					parent: n
+				});
+				return r.status === "aborted" ? _ : r.status === "dirty" || t.value === "dirty" ? de(r.value) : r;
+			}
+		}
+		if (r.type === "refinement") {
+			let e = (e) => {
+				let t = r.refinement(e, i);
+				if (n.common.async) return Promise.resolve(t);
+				if (t instanceof Promise) throw Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+				return e;
+			};
+			if (n.common.async === !1) {
+				let r = this._def.schema._parseSync({
+					data: n.data,
+					path: n.path,
+					parent: n
+				});
+				return r.status === "aborted" ? _ : (r.status === "dirty" && t.dirty(), e(r.value), {
+					status: t.value,
+					value: r.value
+				});
+			}
+			return this._def.schema._parseAsync({
+				data: n.data,
+				path: n.path,
+				parent: n
+			}).then((n) => n.status === "aborted" ? _ : (n.status === "dirty" && t.dirty(), e(n.value).then(() => ({
+				status: t.value,
+				value: n.value
+			}))));
+		}
+		if (r.type === "transform") {
+			if (n.common.async === !1) {
+				let e = this._def.schema._parseSync({
+					data: n.data,
+					path: n.path,
+					parent: n
+				});
+				if (!y(e)) return _;
+				let a = r.transform(e.value, i);
+				if (a instanceof Promise) throw Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.");
+				return {
+					status: t.value,
+					value: a
+				};
+			}
+			return this._def.schema._parseAsync({
+				data: n.data,
+				path: n.path,
+				parent: n
+			}).then((e) => y(e) ? Promise.resolve(r.transform(e.value, i)).then((e) => ({
+				status: t.value,
+				value: e
+			})) : _);
+		}
+		l.assertNever(r);
+	}
+};
+W.create = (e, t, n) => new W({
+	schema: e,
+	typeName: Z.ZodEffects,
+	effect: t,
+	...C(n)
+}), W.createWithPreprocess = (e, t, n) => new W({
+	schema: t,
+	effect: {
+		type: "preprocess",
+		transform: e
+	},
+	typeName: Z.ZodEffects,
+	...C(n)
+});
+var G = class extends w {
+	_parse(e) {
+		return this._getType(e) === u.undefined ? v(void 0) : this._def.innerType._parse(e);
+	}
+	unwrap() {
+		return this._def.innerType;
+	}
+};
+G.create = (e, t) => new G({
+	innerType: e,
+	typeName: Z.ZodOptional,
+	...C(t)
+});
+var K = class extends w {
+	_parse(e) {
+		return this._getType(e) === u.null ? v(null) : this._def.innerType._parse(e);
+	}
+	unwrap() {
+		return this._def.innerType;
+	}
+};
+K.create = (e, t) => new K({
+	innerType: e,
+	typeName: Z.ZodNullable,
+	...C(t)
+});
+var q = class extends w {
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e), n = t.data;
+		return t.parsedType === u.undefined && (n = this._def.defaultValue()), this._def.innerType._parse({
+			data: n,
+			path: t.path,
+			parent: t
+		});
+	}
+	removeDefault() {
+		return this._def.innerType;
+	}
+};
+q.create = (e, t) => new q({
+	innerType: e,
+	typeName: Z.ZodDefault,
+	defaultValue: typeof t.default == "function" ? t.default : () => t.default,
+	...C(t)
+});
+var J = class extends w {
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e), n = {
+			...t,
+			common: {
+				...t.common,
+				issues: []
+			}
+		}, r = this._def.innerType._parse({
+			data: n.data,
+			path: n.path,
+			parent: { ...n }
+		});
+		return b(r) ? r.then((e) => ({
+			status: "valid",
+			value: e.status === "valid" ? e.value : this._def.catchValue({
+				get error() {
+					return new p(n.common.issues);
+				},
+				input: n.data
+			})
+		})) : {
+			status: "valid",
+			value: r.status === "valid" ? r.value : this._def.catchValue({
+				get error() {
+					return new p(n.common.issues);
+				},
+				input: n.data
+			})
+		};
+	}
+	removeCatch() {
+		return this._def.innerType;
+	}
+};
+J.create = (e, t) => new J({
+	innerType: e,
+	typeName: Z.ZodCatch,
+	catchValue: typeof t.catch == "function" ? t.catch : () => t.catch,
+	...C(t)
+});
+var Y = class extends w {
+	_parse(e) {
+		if (this._getType(e) !== u.nan) {
+			let t = this._getOrReturnCtx(e);
+			return h(t, {
+				code: f.invalid_type,
+				expected: u.nan,
+				received: t.parsedType
+			}), _;
+		}
+		return {
+			status: "valid",
+			value: e.data
+		};
+	}
+};
+Y.create = (e) => new Y({
+	typeName: Z.ZodNaN,
+	...C(e)
+});
+var Qe = class extends w {
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e), n = t.data;
+		return this._def.type._parse({
+			data: n,
+			path: t.path,
+			parent: t
+		});
+	}
+	unwrap() {
+		return this._def.type;
+	}
+}, $e = class e extends w {
+	_parse(e) {
+		let { status: t, ctx: n } = this._processInputParams(e);
+		if (n.common.async) return (async () => {
+			let e = await this._def.in._parseAsync({
+				data: n.data,
+				path: n.path,
+				parent: n
+			});
+			return e.status === "aborted" ? _ : e.status === "dirty" ? (t.dirty(), de(e.value)) : this._def.out._parseAsync({
+				data: e.value,
+				path: n.path,
+				parent: n
+			});
+		})();
+		{
+			let e = this._def.in._parseSync({
+				data: n.data,
+				path: n.path,
+				parent: n
+			});
+			return e.status === "aborted" ? _ : e.status === "dirty" ? (t.dirty(), {
+				status: "dirty",
+				value: e.value
+			}) : this._def.out._parseSync({
+				data: e.value,
+				path: n.path,
+				parent: n
+			});
+		}
+	}
+	static create(t, n) {
+		return new e({
+			in: t,
+			out: n,
+			typeName: Z.ZodPipeline
+		});
+	}
+}, X = class extends w {
+	_parse(e) {
+		let t = this._def.innerType._parse(e), n = (e) => (y(e) && (e.value = Object.freeze(e.value)), e);
+		return b(t) ? t.then((e) => n(e)) : n(t);
+	}
+	unwrap() {
+		return this._def.innerType;
+	}
+};
+X.create = (e, t) => new X({
+	innerType: e,
+	typeName: Z.ZodReadonly,
+	...C(t)
+}), P.lazycreate;
+var Z;
+(function(e) {
+	e.ZodString = "ZodString", e.ZodNumber = "ZodNumber", e.ZodNaN = "ZodNaN", e.ZodBigInt = "ZodBigInt", e.ZodBoolean = "ZodBoolean", e.ZodDate = "ZodDate", e.ZodSymbol = "ZodSymbol", e.ZodUndefined = "ZodUndefined", e.ZodNull = "ZodNull", e.ZodAny = "ZodAny", e.ZodUnknown = "ZodUnknown", e.ZodNever = "ZodNever", e.ZodVoid = "ZodVoid", e.ZodArray = "ZodArray", e.ZodObject = "ZodObject", e.ZodUnion = "ZodUnion", e.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", e.ZodIntersection = "ZodIntersection", e.ZodTuple = "ZodTuple", e.ZodRecord = "ZodRecord", e.ZodMap = "ZodMap", e.ZodSet = "ZodSet", e.ZodFunction = "ZodFunction", e.ZodLazy = "ZodLazy", e.ZodLiteral = "ZodLiteral", e.ZodEnum = "ZodEnum", e.ZodEffects = "ZodEffects", e.ZodNativeEnum = "ZodNativeEnum", e.ZodOptional = "ZodOptional", e.ZodNullable = "ZodNullable", e.ZodDefault = "ZodDefault", e.ZodCatch = "ZodCatch", e.ZodPromise = "ZodPromise", e.ZodBranded = "ZodBranded", e.ZodPipeline = "ZodPipeline", e.ZodReadonly = "ZodReadonly";
+})(Z ||= {});
+var Q = T.create, et = E.create;
+Y.create, D.create, Be.create, Ve.create, He.create, O.create, k.create, Ue.create, A.create, j.create, We.create;
+var tt = M.create, $ = P.create;
+P.strictCreate, F.create, Ge.create, L.create, R.create, qe.create, Je.create, Ye.create, Xe.create, z.create, B.create;
+var nt = V.create;
+H.create, U.create, W.create, G.create, K.create, W.createWithPreprocess, $e.create;
+var rt = [
+	{
+		name: "list_projects",
+		title: "List Projects",
+		description: "Retrieve all projects in the workspace.",
+		zodSchema: $({}),
+		inputSchema: {
+			type: "object",
+			properties: {},
+			additionalProperties: !1
+		},
+		annotations: { readOnlyHint: !0 },
+		execute: async (e, t) => t.getProjects()
+	},
+	{
+		name: "get_project",
+		title: "Get Project",
+		description: "Get details of a specific project by its ID.",
+		zodSchema: $({ id: Q().describe("The project ID") }),
+		inputSchema: {
+			type: "object",
+			properties: { id: {
+				type: "string",
+				description: "The project ID"
+			} },
+			required: ["id"],
+			additionalProperties: !1
+		},
+		annotations: { readOnlyHint: !0 },
+		execute: async (e, t) => t.getProject(e.id)
+	},
+	{
+		name: "create_project",
+		title: "Create Project",
+		description: "Create a new project workspace.",
+		zodSchema: $({
+			name: Q().describe("Name of the project"),
+			description: Q().optional().describe("Description of the project"),
+			key: Q().optional().describe("Short project key/prefix (e.g. \"PROJ\")")
+		}),
+		inputSchema: {
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Name of the project"
+				},
+				description: {
+					type: "string",
+					description: "Description of the project"
+				},
+				key: {
+					type: "string",
+					description: "Short project key/prefix (e.g. \"PROJ\")"
+				}
+			},
+			required: ["name"],
+			additionalProperties: !1
+		},
+		execute: async (e, t) => t.createProject(e)
+	},
+	{
+		name: "list_tasks",
+		title: "List Tasks",
+		description: "List tasks, optionally filtered by project, status, priority, or assignee.",
+		zodSchema: $({
+			projectId: Q().optional().describe("Filter by project ID"),
+			status: Q().optional().describe("Filter by task status key"),
+			priority: nt([
+				"urgent",
+				"high",
+				"medium",
+				"low",
+				"none"
+			]).optional().describe("Filter by priority"),
+			assigneeId: Q().optional().describe("Filter by assignee ID")
+		}),
+		inputSchema: {
+			type: "object",
+			properties: {
+				projectId: {
+					type: "string",
+					description: "Filter by project ID"
+				},
+				status: {
+					type: "string",
+					description: "Filter by task status key"
+				},
+				priority: {
+					type: "string",
+					enum: [
+						"urgent",
+						"high",
+						"medium",
+						"low",
+						"none"
+					],
+					description: "Filter by priority"
+				},
+				assigneeId: {
+					type: "string",
+					description: "Filter by assignee ID"
+				}
+			},
+			additionalProperties: !1
+		},
+		annotations: { readOnlyHint: !0 },
+		execute: async (e, t, n) => {
+			let r = e.projectId || n?.projectId, i = await t.getTasks(r);
+			return e.status && (i = i.filter((t) => t.status === e.status)), e.priority && (i = i.filter((t) => t.priority === e.priority)), e.assigneeId && (i = i.filter((t) => t.assigneeId === e.assigneeId)), i;
+		}
+	},
+	{
+		name: "get_task",
+		title: "Get Task",
+		description: "Get task details by ID.",
+		zodSchema: $({ id: Q().describe("The task ID") }),
+		inputSchema: {
+			type: "object",
+			properties: { id: {
+				type: "string",
+				description: "The task ID"
+			} },
+			required: ["id"],
+			additionalProperties: !1
+		},
+		annotations: { readOnlyHint: !0 },
+		execute: async (e, t) => t.getTask(e.id)
+	},
+	{
+		name: "create_task",
+		title: "Create Task",
+		description: "Create a new task within a project.",
+		zodSchema: $({
+			projectId: Q().optional().describe("Project ID (inferred from active view in browser if omitted)"),
+			title: Q().describe("Title of the task"),
+			description: Q().optional().describe("Detailed description / markdown"),
+			status: Q().optional().describe("Status (defaults to \"todo\" or first workflow status)"),
+			priority: nt([
+				"urgent",
+				"high",
+				"medium",
+				"low",
+				"none"
+			]).optional().default("none").describe("Task priority"),
+			assigneeId: Q().optional().describe("User ID to assign task to"),
+			dueDate: Q().optional().describe("Due date (ISO string)"),
+			tags: tt(Q()).optional().describe("Tags for categorization"),
+			estimatedHours: et().optional().describe("Estimated hours to complete")
+		}),
+		inputSchema: {
+			type: "object",
+			properties: {
+				projectId: {
+					type: "string",
+					description: "Project ID (inferred from active view if omitted)"
+				},
+				title: {
+					type: "string",
+					description: "Title of the task"
+				},
+				description: {
+					type: "string",
+					description: "Detailed description"
+				},
+				status: {
+					type: "string",
+					description: "Status key"
+				},
+				priority: {
+					type: "string",
+					enum: [
+						"urgent",
+						"high",
+						"medium",
+						"low",
+						"none"
+					]
+				},
+				assigneeId: {
+					type: "string",
+					description: "User ID of assignee"
+				},
+				dueDate: {
+					type: "string",
+					description: "Due date in ISO 8601 format"
+				},
+				tags: {
+					type: "array",
+					items: { type: "string" }
+				},
+				estimatedHours: { type: "number" }
+			},
+			required: ["title"],
+			additionalProperties: !1
+		},
+		execute: async (e, t, n) => {
+			let r = e.projectId || n?.projectId;
+			if (!r) throw Error("projectId is required to create a task, but none was provided or active in context.");
+			let i = {
+				projectId: r,
+				title: e.title,
+				description: e.description,
+				status: e.status || "todo",
+				priority: e.priority || "none",
+				assigneeId: e.assigneeId,
+				dueDate: e.dueDate,
+				tags: e.tags || [],
+				estimatedHours: e.estimatedHours
+			};
+			return t.createTask(i);
+		}
+	},
+	{
+		name: "update_task",
+		title: "Update Task",
+		description: "Update fields of an existing task (e.g. title, status, priority, assignee).",
+		zodSchema: $({
+			id: Q().describe("The task ID"),
+			title: Q().optional(),
+			description: Q().optional(),
+			status: Q().optional(),
+			priority: nt([
+				"urgent",
+				"high",
+				"medium",
+				"low",
+				"none"
+			]).optional(),
+			assigneeId: Q().optional(),
+			dueDate: Q().optional(),
+			tags: tt(Q()).optional(),
+			estimatedHours: et().optional(),
+			loggedHours: et().optional()
+		}),
+		inputSchema: {
+			type: "object",
+			properties: {
+				id: {
+					type: "string",
+					description: "Task ID"
+				},
+				title: { type: "string" },
+				description: { type: "string" },
+				status: { type: "string" },
+				priority: {
+					type: "string",
+					enum: [
+						"urgent",
+						"high",
+						"medium",
+						"low",
+						"none"
+					]
+				},
+				assigneeId: { type: "string" },
+				dueDate: { type: "string" },
+				tags: {
+					type: "array",
+					items: { type: "string" }
+				},
+				estimatedHours: { type: "number" },
+				loggedHours: { type: "number" }
+			},
+			required: ["id"],
+			additionalProperties: !1
+		},
+		execute: async (e, t) => {
+			let { id: n, ...r } = e;
+			return t.updateTask(n, r);
+		}
+	},
+	{
+		name: "delete_task",
+		title: "Delete Task",
+		description: "Delete a task by ID.",
+		zodSchema: $({ id: Q().describe("The task ID to delete") }),
+		inputSchema: {
+			type: "object",
+			properties: { id: {
+				type: "string",
+				description: "The task ID"
+			} },
+			required: ["id"],
+			additionalProperties: !1
+		},
+		annotations: { requiresConfirmation: !0 },
+		execute: async (e, t) => ({ success: await t.deleteTask(e.id) })
+	},
+	{
+		name: "list_deliverables",
+		title: "List Deliverables",
+		description: "List deliverables/milestones for a project.",
+		zodSchema: $({ projectId: Q().optional().describe("Project ID") }),
+		inputSchema: {
+			type: "object",
+			properties: { projectId: {
+				type: "string",
+				description: "Project ID"
+			} },
+			additionalProperties: !1
+		},
+		annotations: { readOnlyHint: !0 },
+		execute: async (e, t, n) => {
+			let r = e.projectId || n?.projectId;
+			if (!r) throw Error("projectId is required to list deliverables.");
+			return "getDeliverables" in t && typeof t.getDeliverables == "function" ? t.getDeliverables(r) : [];
+		}
+	},
+	{
+		name: "create_deliverable",
+		title: "Create Deliverable",
+		description: "Create a milestone deliverable within a project.",
+		zodSchema: $({
+			projectId: Q().optional(),
+			title: Q(),
+			description: Q().optional(),
+			dueDate: Q().optional(),
+			taskIds: tt(Q()).optional()
+		}),
+		inputSchema: {
+			type: "object",
+			properties: {
+				projectId: { type: "string" },
+				title: { type: "string" },
+				description: { type: "string" },
+				dueDate: { type: "string" },
+				taskIds: {
+					type: "array",
+					items: { type: "string" }
+				}
+			},
+			required: ["title"],
+			additionalProperties: !1
+		},
+		execute: async (e, t, n) => {
+			let r = e.projectId || n?.projectId;
+			if (!r) throw Error("projectId is required to create a deliverable.");
+			if ("createDeliverable" in t && typeof t.createDeliverable == "function") return t.createDeliverable({
+				...e,
+				projectId: r
+			});
+			throw Error("createDeliverable is not supported by this backend target.");
+		}
+	},
+	{
+		name: "list_comments",
+		title: "List Comments",
+		description: "List comments associated with a task.",
+		zodSchema: $({ taskId: Q().describe("The task ID") }),
+		inputSchema: {
+			type: "object",
+			properties: { taskId: {
+				type: "string",
+				description: "The task ID"
+			} },
+			required: ["taskId"],
+			additionalProperties: !1
+		},
+		annotations: { readOnlyHint: !0 },
+		execute: async (e, t) => "getComments" in t && typeof t.getComments == "function" ? t.getComments(e.taskId) : []
+	},
+	{
+		name: "add_comment",
+		title: "Add Comment",
+		description: "Add a comment to a task.",
+		zodSchema: $({
+			taskId: Q().describe("The task ID"),
+			content: Q().describe("Comment body/markdown"),
+			authorId: Q().describe("Author user ID")
+		}),
+		inputSchema: {
+			type: "object",
+			properties: {
+				taskId: {
+					type: "string",
+					description: "The task ID"
+				},
+				content: {
+					type: "string",
+					description: "Comment body/markdown"
+				},
+				authorId: {
+					type: "string",
+					description: "Author user ID"
+				}
+			},
+			required: [
+				"taskId",
+				"content",
+				"authorId"
+			],
+			additionalProperties: !1
+		},
+		execute: async (e, t) => t.addComment({
+			taskId: e.taskId,
+			content: e.content,
+			authorId: e.authorId
+		})
+	}
+];
+new Map(rt.map((e) => [e.name, e]));
+//#endregion
+//#region ../mcp/dist/web/index.js
+function it(e = typeof document < "u" ? document : null) {
+	if (!e) return null;
+	if (!e.modelContext) {
+		let t = /* @__PURE__ */ new Map();
+		e.modelContext = {
+			registerTool(e, n) {
+				t.set(e.name, e), n?.signal && n.signal.addEventListener("abort", () => {
+					t.delete(e.name);
+				}, { once: !0 });
+			},
+			unregisterTool(e) {
+				t.delete(e);
+			},
+			async getTools() {
+				return Array.from(t.values());
+			},
+			async executeTool(e, n) {
+				let r = t.get(e);
+				if (!r) throw Error(`Tool "${e}" is not registered on modelContext.`);
+				return r.execute(n || {});
+			}
+		};
+	}
+	return e.modelContext;
+}
+function at(e) {
+	let t = e.document ?? (typeof document < "u" ? document : null), n = e.navigator ?? (typeof navigator < "u" ? navigator : null), r = e.window ?? (typeof window < "u" ? window : null), i;
+	t?.modelContext ? i = t.modelContext : n?.modelContext ? i = n.modelContext : t && (i = it(t) ?? void 0);
+	let a = e.tools ? rt.filter((t) => e.tools.includes(t.name)) : rt, o = [], s = new AbortController();
+	e.signal && e.signal.addEventListener("abort", () => s.abort(), { once: !0 });
+	for (let t of a) {
+		let n = {
+			name: t.name,
+			title: t.title,
+			description: t.description,
+			inputSchema: t.inputSchema,
+			annotations: t.annotations,
+			execute: async (n) => {
+				let r = e.projectId ? { projectId: e.projectId } : void 0, i = await t.execute(n, e.client, r);
+				return e.onToolExecuted?.(t.name, n, i), i;
+			}
+		};
+		if (o.push(n), i?.registerTool) try {
+			i.registerTool(n, { signal: s.signal });
+		} catch (e) {
+			console.warn(`[Critical Path WebMCP] Failed to register tool "${n.name}":`, e);
+		}
+	}
+	return r && (r.__CRITICAL_PATH_WEBMCP__ = {
+		projectId: e.projectId,
+		tools: o,
+		execute: async (e, t) => {
+			let n = o.find((t) => t.name === e);
+			if (!n) throw Error(`WebMCP tool "${e}" not found in Critical Path registry.`);
+			return n.execute(t);
+		}
+	}), {
+		unregister: () => {
+			if (s.abort(), i?.unregisterTool) for (let e of o) i.unregisterTool(e.name);
+			r && r.__CRITICAL_PATH_WEBMCP__?.tools === o && delete r.__CRITICAL_PATH_WEBMCP__;
+		},
+		getRegisteredTools: () => o
+	};
+}
+//#endregion
+//#region src/webmcp-state.svelte.ts
+var ot = class {
+	client;
+	options;
+	#e = t.state(!1);
+	get registered() {
+		return t.get(this.#e);
+	}
+	set registered(e) {
+		t.set(this.#e, e, !0);
+	}
+	#t = t.state(void 0);
+	get activeProjectId() {
+		return t.get(this.#t);
+	}
+	set activeProjectId(e) {
+		t.set(this.#t, e, !0);
+	}
+	#n = t.state(t.proxy([]));
+	get tools() {
+		return t.get(this.#n);
+	}
+	set tools(e) {
+		t.set(this.#n, e, !0);
+	}
+	#r = t.state(null);
+	get error() {
+		return t.get(this.#r);
+	}
+	set error(e) {
+		t.set(this.#r, e, !0);
+	}
+	handle = null;
+	abortController = null;
+	constructor(e, t = {}) {
+		this.client = e, this.options = t, this.activeProjectId = t.projectId, (t.autoRegister ?? !0) && this.register();
+	}
+	register() {
+		if (!this.registered) {
+			this.error = null;
+			try {
+				this.abortController = new AbortController(), this.handle = at({
+					client: this.client,
+					projectId: this.activeProjectId,
+					tools: this.options.tools,
+					signal: this.abortController.signal,
+					document: this.options.document,
+					navigator: this.options.navigator,
+					window: this.options.window,
+					onToolExecuted: (e, t, n) => {
+						this.options.onToolExecuted?.(e, t, n);
+					}
+				}), this.tools = this.handle.getRegisteredTools().map((e) => e.name), this.registered = !0;
+			} catch (e) {
+				this.error = e instanceof Error ? e : Error(String(e)), this.registered = !1;
+			}
+		}
+	}
+	unregister() {
+		this.registered && (this.abortController?.abort(), this.handle?.unregister(), this.handle = null, this.abortController = null, this.registered = !1, this.tools = []);
+	}
+	setProjectId(e) {
+		this.activeProjectId !== e && (this.activeProjectId = e, this.registered && (this.unregister(), this.register()));
+	}
+};
+function st(e, t) {
+	return new ot(e, t);
 }
 //#endregion
 //#region src/index.ts
-function g(t) {
+function ct(t) {
 	return new e(t);
 }
 //#endregion
-export { u as AttachmentState, c as CommentState, m as DeliverableState, n as ProjectState, f as TaskActivityState, i as TaskState, o as WorkflowState, d as createAttachmentState, l as createCommentState, g as createCriticalPathClient, h as createDeliverableState, r as createProjectState, p as createTaskActivityState, a as createTaskState, s as createWorkflowState };
+export { te as AttachmentState, c as CommentState, ae as DeliverableState, n as ProjectState, re as TaskActivityState, i as TaskState, ot as WebMcpState, o as WorkflowState, ne as createAttachmentState, ee as createCommentState, ct as createCriticalPathClient, oe as createDeliverableState, r as createProjectState, ie as createTaskActivityState, a as createTaskState, st as createWebMcpState, s as createWorkflowState };