Elementor Website Builder – more than just a page builder / 4.3.2

Elementor Website Builder – more than just a page builder v4.3.2

elementor / assets / js / packages / elementor-mcp-common / elementor-mcp-common.js

elementor-mcp-common.js in Elementor Website Builder – more than just a page builder 4.3.2, at assets/js/packages/elementor-mcp-common/elementor-mcp-common.js

19,791 lines 670.5 KB

Raw Download Zip

1	(function() {
2
3	//#region \0rolldown/runtime.js
4	var __create = Object.create;
5	var __defProp = Object.defineProperty;
6	var __name = (target, value) => __defProp(target, "name", {
7	value,
8	configurable: true
9	});
10	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
11	var __getOwnPropNames = Object.getOwnPropertyNames;
12	var __getProtoOf = Object.getPrototypeOf;
13	var __hasOwnProp = Object.prototype.hasOwnProperty;
14	var __esmMin = (fn, res, err) => () => {
15	if (err) throw err[0];
16	try {
17	return fn && (res = fn(fn = 0)), res;
18	} catch (e) {
19	throw err = [e], e;
20	}
21	};
22	var __commonJSMin = (cb, mod) => () => (mod \|\| (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
23	var __exportAll = (all, no_symbols) => {
24	let target = {};
25	for (var name in all) {
26	__defProp(target, name, {
27	get: all[name],
28	enumerable: true
29	});
30	}
31	if (!no_symbols) {
32	__defProp(target, Symbol.toStringTag, { value: "Module" });
33	}
34	return target;
35	};
36	var __copyProps = (to, from, except, desc) => {
37	if (from && typeof from === "object" \|\| typeof from === "function") {
38	for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
39	key = keys[i];
40	if (!__hasOwnProp.call(to, key) && key !== except) {
41	__defProp(to, key, {
42	get: ((k) => from[k]).bind(null, key),
43	enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable
44	});
45	}
46	}
47	}
48	return to;
49	};
50	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", {
51	value: mod,
52	enumerable: true
53	}) : target, mod));
54	var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
55
56	//#endregion
57
58	//#region node_modules/zod/v3/helpers/util.js
59	var util;
60	(function(util) {
61	util.assertEqual = (_) => {};
62	function assertIs(_arg) {}
63	util.assertIs = assertIs;
64	function assertNever(_x) {
65	throw new Error();
66	}
67	util.assertNever = assertNever;
68	util.arrayToEnum = (items) => {
69	const obj = {};
70	for (const item of items) obj[item] = item;
71	return obj;
72	};
73	util.getValidEnumValues = (obj) => {
74	const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
75	const filtered = {};
76	for (const k of validKeys) filtered[k] = obj[k];
77	return util.objectValues(filtered);
78	};
79	util.objectValues = (obj) => {
80	return util.objectKeys(obj).map(function(e) {
81	return obj[e];
82	});
83	};
84	util.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
85	const keys = [];
86	for (const key in object) if (Object.prototype.hasOwnProperty.call(object, key)) keys.push(key);
87	return keys;
88	};
89	util.find = (arr, checker) => {
90	for (const item of arr) if (checker(item)) return item;
91	};
92	util.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
93	function joinValues(array, separator = " \| ") {
94	return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
95	}
96	util.joinValues = joinValues;
97	util.jsonStringifyReplacer = (_, value) => {
98	if (typeof value === "bigint") return value.toString();
99	return value;
100	};
101	})(util \|\| (util = {}));
102	var objectUtil;
103	(function(objectUtil) {
104	objectUtil.mergeShapes = (first, second) => {
105	return {
106	...first,
107	...second
108	};
109	};
110	})(objectUtil \|\| (objectUtil = {}));
111	var ZodParsedType = util.arrayToEnum([
112	"string",
113	"nan",
114	"number",
115	"integer",
116	"float",
117	"boolean",
118	"date",
119	"bigint",
120	"symbol",
121	"function",
122	"undefined",
123	"null",
124	"array",
125	"object",
126	"unknown",
127	"promise",
128	"void",
129	"never",
130	"map",
131	"set"
132	]);
133	var getParsedType = (data) => {
134	switch (typeof data) {
135	case "undefined": return ZodParsedType.undefined;
136	case "string": return ZodParsedType.string;
137	case "number": return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
138	case "boolean": return ZodParsedType.boolean;
139	case "function": return ZodParsedType.function;
140	case "bigint": return ZodParsedType.bigint;
141	case "symbol": return ZodParsedType.symbol;
142	case "object":
143	if (Array.isArray(data)) return ZodParsedType.array;
144	if (data === null) return ZodParsedType.null;
145	if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") return ZodParsedType.promise;
146	if (typeof Map !== "undefined" && data instanceof Map) return ZodParsedType.map;
147	if (typeof Set !== "undefined" && data instanceof Set) return ZodParsedType.set;
148	if (typeof Date !== "undefined" && data instanceof Date) return ZodParsedType.date;
149	return ZodParsedType.object;
150	default: return ZodParsedType.unknown;
151	}
152	};
153
154	//#endregion
155	//#region node_modules/zod/v3/ZodError.js
156	var ZodIssueCode = util.arrayToEnum([
157	"invalid_type",
158	"invalid_literal",
159	"custom",
160	"invalid_union",
161	"invalid_union_discriminator",
162	"invalid_enum_value",
163	"unrecognized_keys",
164	"invalid_arguments",
165	"invalid_return_type",
166	"invalid_date",
167	"invalid_string",
168	"too_small",
169	"too_big",
170	"invalid_intersection_types",
171	"not_multiple_of",
172	"not_finite"
173	]);
174	var ZodError$1 = class ZodError$1 extends Error {
175	static {
176	__name(this, "ZodError");
177	}
178	get errors() {
179	return this.issues;
180	}
181	constructor(issues) {
182	super();
183	this.issues = [];
184	this.addIssue = (sub) => {
185	this.issues = [...this.issues, sub];
186	};
187	this.addIssues = (subs = []) => {
188	this.issues = [...this.issues, ...subs];
189	};
190	const actualProto = new.target.prototype;
191	if (Object.setPrototypeOf) Object.setPrototypeOf(this, actualProto);
192	else this.__proto__ = actualProto;
193	this.name = "ZodError";
194	this.issues = issues;
195	}
196	format(_mapper) {
197	const mapper = _mapper \|\| function(issue) {
198	return issue.message;
199	};
200	const fieldErrors = { _errors: [] };
201	const processError = (error) => {
202	for (const issue of error.issues) if (issue.code === "invalid_union") issue.unionErrors.map(processError);
203	else if (issue.code === "invalid_return_type") processError(issue.returnTypeError);
204	else if (issue.code === "invalid_arguments") processError(issue.argumentsError);
205	else if (issue.path.length === 0) fieldErrors._errors.push(mapper(issue));
206	else {
207	let curr = fieldErrors;
208	let i = 0;
209	while (i < issue.path.length) {
210	const el = issue.path[i];
211	if (!(i === issue.path.length - 1)) curr[el] = curr[el] \|\| { _errors: [] };
212	else {
213	curr[el] = curr[el] \|\| { _errors: [] };
214	curr[el]._errors.push(mapper(issue));
215	}
216	curr = curr[el];
217	i++;
218	}
219	}
220	};
221	processError(this);
222	return fieldErrors;
223	}
224	static assert(value) {
225	if (!(value instanceof ZodError$1)) throw new Error(`Not a ZodError: ${value}`);
226	}
227	toString() {
228	return this.message;
229	}
230	get message() {
231	return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
232	}
233	get isEmpty() {
234	return this.issues.length === 0;
235	}
236	flatten(mapper = (issue) => issue.message) {
237	const fieldErrors = {};
238	const formErrors = [];
239	for (const sub of this.issues) if (sub.path.length > 0) {
240	const firstEl = sub.path[0];
241	fieldErrors[firstEl] = fieldErrors[firstEl] \|\| [];
242	fieldErrors[firstEl].push(mapper(sub));
243	} else formErrors.push(mapper(sub));
244	return {
245	formErrors,
246	fieldErrors
247	};
248	}
249	get formErrors() {
250	return this.flatten();
251	}
252	};
253	ZodError$1.create = (issues) => {
254	return new ZodError$1(issues);
255	};
256
257	//#endregion
258	//#region node_modules/zod/v3/locales/en.js
259	var errorMap = (issue, _ctx) => {
260	let message;
261	switch (issue.code) {
262	case ZodIssueCode.invalid_type:
263	if (issue.received === ZodParsedType.undefined) message = "Required";
264	else message = `Expected ${issue.expected}, received ${issue.received}`;
265	break;
266	case ZodIssueCode.invalid_literal:
267	message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
268	break;
269	case ZodIssueCode.unrecognized_keys:
270	message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
271	break;
272	case ZodIssueCode.invalid_union:
273	message = `Invalid input`;
274	break;
275	case ZodIssueCode.invalid_union_discriminator:
276	message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
277	break;
278	case ZodIssueCode.invalid_enum_value:
279	message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
280	break;
281	case ZodIssueCode.invalid_arguments:
282	message = `Invalid function arguments`;
283	break;
284	case ZodIssueCode.invalid_return_type:
285	message = `Invalid function return type`;
286	break;
287	case ZodIssueCode.invalid_date:
288	message = `Invalid date`;
289	break;
290	case ZodIssueCode.invalid_string:
291	if (typeof issue.validation === "object") if ("includes" in issue.validation) {
292	message = `Invalid input: must include "${issue.validation.includes}"`;
293	if (typeof issue.validation.position === "number") message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
294	} else if ("startsWith" in issue.validation) message = `Invalid input: must start with "${issue.validation.startsWith}"`;
295	else if ("endsWith" in issue.validation) message = `Invalid input: must end with "${issue.validation.endsWith}"`;
296	else util.assertNever(issue.validation);
297	else if (issue.validation !== "regex") message = `Invalid ${issue.validation}`;
298	else message = "Invalid";
299	break;
300	case ZodIssueCode.too_small:
301	if (issue.type === "array") message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
302	else if (issue.type === "string") message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
303	else if (issue.type === "number") message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
304	else if (issue.type === "bigint") message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
305	else if (issue.type === "date") message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
306	else message = "Invalid input";
307	break;
308	case ZodIssueCode.too_big:
309	if (issue.type === "array") message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
310	else if (issue.type === "string") message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
311	else if (issue.type === "number") message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
312	else if (issue.type === "bigint") message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
313	else if (issue.type === "date") message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
314	else message = "Invalid input";
315	break;
316	case ZodIssueCode.custom:
317	message = `Invalid input`;
318	break;
319	case ZodIssueCode.invalid_intersection_types:
320	message = `Intersection results could not be merged`;
321	break;
322	case ZodIssueCode.not_multiple_of:
323	message = `Number must be a multiple of ${issue.multipleOf}`;
324	break;
325	case ZodIssueCode.not_finite:
326	message = "Number must be finite";
327	break;
328	default:
329	message = _ctx.defaultError;
330	util.assertNever(issue);
331	}
332	return { message };
333	};
334
335	//#endregion
336	//#region node_modules/zod/v3/errors.js
337	var overrideErrorMap = errorMap;
338	function getErrorMap() {
339	return overrideErrorMap;
340	}
341
342	//#endregion
343	//#region node_modules/zod/v3/helpers/parseUtil.js
344	var makeIssue = (params) => {
345	const { data, path, errorMaps, issueData } = params;
346	const fullPath = [...path, ...issueData.path \|\| []];
347	const fullIssue = {
348	...issueData,
349	path: fullPath
350	};
351	if (issueData.message !== void 0) return {
352	...issueData,
353	path: fullPath,
354	message: issueData.message
355	};
356	let errorMessage = "";
357	const maps = errorMaps.filter((m) => !!m).slice().reverse();
358	for (const map of maps) errorMessage = map(fullIssue, {
359	data,
360	defaultError: errorMessage
361	}).message;
362	return {
363	...issueData,
364	path: fullPath,
365	message: errorMessage
366	};
367	};
368	function addIssueToContext(ctx, issueData) {
369	const overrideMap = getErrorMap();
370	const issue = makeIssue({
371	issueData,
372	data: ctx.data,
373	path: ctx.path,
374	errorMaps: [
375	ctx.common.contextualErrorMap,
376	ctx.schemaErrorMap,
377	overrideMap,
378	overrideMap === errorMap ? void 0 : errorMap
379	].filter((x) => !!x)
380	});
381	ctx.common.issues.push(issue);
382	}
383	var ParseStatus = class ParseStatus {
384	constructor() {
385	this.value = "valid";
386	}
387	dirty() {
388	if (this.value === "valid") this.value = "dirty";
389	}
390	abort() {
391	if (this.value !== "aborted") this.value = "aborted";
392	}
393	static mergeArray(status, results) {
394	const arrayValue = [];
395	for (const s of results) {
396	if (s.status === "aborted") return INVALID;
397	if (s.status === "dirty") status.dirty();
398	arrayValue.push(s.value);
399	}
400	return {
401	status: status.value,
402	value: arrayValue
403	};
404	}
405	static async mergeObjectAsync(status, pairs) {
406	const syncPairs = [];
407	for (const pair of pairs) {
408	const key = await pair.key;
409	const value = await pair.value;
410	syncPairs.push({
411	key,
412	value
413	});
414	}
415	return ParseStatus.mergeObjectSync(status, syncPairs);
416	}
417	static mergeObjectSync(status, pairs) {
418	const finalObject = {};
419	for (const pair of pairs) {
420	const { key, value } = pair;
421	if (key.status === "aborted") return INVALID;
422	if (value.status === "aborted") return INVALID;
423	if (key.status === "dirty") status.dirty();
424	if (value.status === "dirty") status.dirty();
425	if (key.value !== "__proto__" && (typeof value.value !== "undefined" \|\| pair.alwaysSet)) finalObject[key.value] = value.value;
426	}
427	return {
428	status: status.value,
429	value: finalObject
430	};
431	}
432	};
433	var INVALID = Object.freeze({ status: "aborted" });
434	var DIRTY = (value) => ({
435	status: "dirty",
436	value
437	});
438	var OK = (value) => ({
439	status: "valid",
440	value
441	});
442	var isAborted = (x) => x.status === "aborted";
443	var isDirty = (x) => x.status === "dirty";
444	var isValid = (x) => x.status === "valid";
445	var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
446
447	//#endregion
448	//#region node_modules/zod/v3/helpers/errorUtil.js
449	var errorUtil;
450	(function(errorUtil) {
451	errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message \|\| {};
452	errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
453	})(errorUtil \|\| (errorUtil = {}));
454
455	//#endregion
456	//#region node_modules/zod/v3/types.js
457	var ParseInputLazyPath = class {
458	constructor(parent, value, path, key) {
459	this._cachedPath = [];
460	this.parent = parent;
461	this.data = value;
462	this._path = path;
463	this._key = key;
464	}
465	get path() {
466	if (!this._cachedPath.length) if (Array.isArray(this._key)) this._cachedPath.push(...this._path, ...this._key);
467	else this._cachedPath.push(...this._path, this._key);
468	return this._cachedPath;
469	}
470	};
471	var handleResult = (ctx, result) => {
472	if (isValid(result)) return {
473	success: true,
474	data: result.value
475	};
476	else {
477	if (!ctx.common.issues.length) throw new Error("Validation failed but no issues detected.");
478	return {
479	success: false,
480	get error() {
481	if (this._error) return this._error;
482	const error = new ZodError$1(ctx.common.issues);
483	this._error = error;
484	return this._error;
485	}
486	};
487	}
488	};
489	function processCreateParams(params) {
490	if (!params) return {};
491	const { errorMap, invalid_type_error, required_error, description } = params;
492	if (errorMap && (invalid_type_error \|\| required_error)) throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
493	if (errorMap) return {
494	errorMap,
495	description
496	};
497	const customMap = (iss, ctx) => {
498	const { message } = params;
499	if (iss.code === "invalid_enum_value") return { message: message ?? ctx.defaultError };
500	if (typeof ctx.data === "undefined") return { message: message ?? required_error ?? ctx.defaultError };
501	if (iss.code !== "invalid_type") return { message: ctx.defaultError };
502	return { message: message ?? invalid_type_error ?? ctx.defaultError };
503	};
504	return {
505	errorMap: customMap,
506	description
507	};
508	}
509	var ZodType$1 = class {
510	static {
511	__name(this, "ZodType");
512	}
513	get description() {
514	return this._def.description;
515	}
516	_getType(input) {
517	return getParsedType(input.data);
518	}
519	_getOrReturnCtx(input, ctx) {
520	return ctx \|\| {
521	common: input.parent.common,
522	data: input.data,
523	parsedType: getParsedType(input.data),
524	schemaErrorMap: this._def.errorMap,
525	path: input.path,
526	parent: input.parent
527	};
528	}
529	_processInputParams(input) {
530	return {
531	status: new ParseStatus(),
532	ctx: {
533	common: input.parent.common,
534	data: input.data,
535	parsedType: getParsedType(input.data),
536	schemaErrorMap: this._def.errorMap,
537	path: input.path,
538	parent: input.parent
539	}
540	};
541	}
542	_parseSync(input) {
543	const result = this._parse(input);
544	if (isAsync(result)) throw new Error("Synchronous parse encountered promise.");
545	return result;
546	}
547	_parseAsync(input) {
548	const result = this._parse(input);
549	return Promise.resolve(result);
550	}
551	parse(data, params) {
552	const result = this.safeParse(data, params);
553	if (result.success) return result.data;
554	throw result.error;
555	}
556	safeParse(data, params) {
557	const ctx = {
558	common: {
559	issues: [],
560	async: params?.async ?? false,
561	contextualErrorMap: params?.errorMap
562	},
563	path: params?.path \|\| [],
564	schemaErrorMap: this._def.errorMap,
565	parent: null,
566	data,
567	parsedType: getParsedType(data)
568	};
569	const result = this._parseSync({
570	data,
571	path: ctx.path,
572	parent: ctx
573	});
574	return handleResult(ctx, result);
575	}
576	"~validate"(data) {
577	const ctx = {
578	common: {
579	issues: [],
580	async: !!this["~standard"].async
581	},
582	path: [],
583	schemaErrorMap: this._def.errorMap,
584	parent: null,
585	data,
586	parsedType: getParsedType(data)
587	};
588	if (!this["~standard"].async) try {
589	const result = this._parseSync({
590	data,
591	path: [],
592	parent: ctx
593	});
594	return isValid(result) ? { value: result.value } : { issues: ctx.common.issues };
595	} catch (err) {
596	if (err?.message?.toLowerCase()?.includes("encountered")) this["~standard"].async = true;
597	ctx.common = {
598	issues: [],
599	async: true
600	};
601	}
602	return this._parseAsync({
603	data,
604	path: [],
605	parent: ctx
606	}).then((result) => isValid(result) ? { value: result.value } : { issues: ctx.common.issues });
607	}
608	async parseAsync(data, params) {
609	const result = await this.safeParseAsync(data, params);
610	if (result.success) return result.data;
611	throw result.error;
612	}
613	async safeParseAsync(data, params) {
614	const ctx = {
615	common: {
616	issues: [],
617	contextualErrorMap: params?.errorMap,
618	async: true
619	},
620	path: params?.path \|\| [],
621	schemaErrorMap: this._def.errorMap,
622	parent: null,
623	data,
624	parsedType: getParsedType(data)
625	};
626	const maybeAsyncResult = this._parse({
627	data,
628	path: ctx.path,
629	parent: ctx
630	});
631	const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
632	return handleResult(ctx, result);
633	}
634	refine(check, message) {
635	const getIssueProperties = (val) => {
636	if (typeof message === "string" \|\| typeof message === "undefined") return { message };
637	else if (typeof message === "function") return message(val);
638	else return message;
639	};
640	return this._refinement((val, ctx) => {
641	const result = check(val);
642	const setError = () => ctx.addIssue({
643	code: ZodIssueCode.custom,
644	...getIssueProperties(val)
645	});
646	if (typeof Promise !== "undefined" && result instanceof Promise) return result.then((data) => {
647	if (!data) {
648	setError();
649	return false;
650	} else return true;
651	});
652	if (!result) {
653	setError();
654	return false;
655	} else return true;
656	});
657	}
658	refinement(check, refinementData) {
659	return this._refinement((val, ctx) => {
660	if (!check(val)) {
661	ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
662	return false;
663	} else return true;
664	});
665	}
666	_refinement(refinement) {
667	return new ZodEffects({
668	schema: this,
669	typeName: ZodFirstPartyTypeKind.ZodEffects,
670	effect: {
671	type: "refinement",
672	refinement
673	}
674	});
675	}
676	superRefine(refinement) {
677	return this._refinement(refinement);
678	}
679	constructor(def) {
680	/** Alias of safeParseAsync */
681	this.spa = this.safeParseAsync;
682	this._def = def;
683	this.parse = this.parse.bind(this);
684	this.safeParse = this.safeParse.bind(this);
685	this.parseAsync = this.parseAsync.bind(this);
686	this.safeParseAsync = this.safeParseAsync.bind(this);
687	this.spa = this.spa.bind(this);
688	this.refine = this.refine.bind(this);
689	this.refinement = this.refinement.bind(this);
690	this.superRefine = this.superRefine.bind(this);
691	this.optional = this.optional.bind(this);
692	this.nullable = this.nullable.bind(this);
693	this.nullish = this.nullish.bind(this);
694	this.array = this.array.bind(this);
695	this.promise = this.promise.bind(this);
696	this.or = this.or.bind(this);
697	this.and = this.and.bind(this);
698	this.transform = this.transform.bind(this);
699	this.brand = this.brand.bind(this);
700	this.default = this.default.bind(this);
701	this.catch = this.catch.bind(this);
702	this.describe = this.describe.bind(this);
703	this.pipe = this.pipe.bind(this);
704	this.readonly = this.readonly.bind(this);
705	this.isNullable = this.isNullable.bind(this);
706	this.isOptional = this.isOptional.bind(this);
707	this["~standard"] = {
708	version: 1,
709	vendor: "zod",
710	validate: (data) => this["~validate"](data)
711	};
712	}
713	optional() {
714	return ZodOptional$1.create(this, this._def);
715	}
716	nullable() {
717	return ZodNullable$1.create(this, this._def);
718	}
719	nullish() {
720	return this.nullable().optional();
721	}
722	array() {
723	return ZodArray$1.create(this);
724	}
725	promise() {
726	return ZodPromise.create(this, this._def);
727	}
728	or(option) {
729	return ZodUnion$1.create([this, option], this._def);
730	}
731	and(incoming) {
732	return ZodIntersection$1.create(this, incoming, this._def);
733	}
734	transform(transform) {
735	return new ZodEffects({
736	...processCreateParams(this._def),
737	schema: this,
738	typeName: ZodFirstPartyTypeKind.ZodEffects,
739	effect: {
740	type: "transform",
741	transform
742	}
743	});
744	}
745	default(def) {
746	const defaultValueFunc = typeof def === "function" ? def : () => def;
747	return new ZodDefault$1({
748	...processCreateParams(this._def),
749	innerType: this,
750	defaultValue: defaultValueFunc,
751	typeName: ZodFirstPartyTypeKind.ZodDefault
752	});
753	}
754	brand() {
755	return new ZodBranded({
756	typeName: ZodFirstPartyTypeKind.ZodBranded,
757	type: this,
758	...processCreateParams(this._def)
759	});
760	}
761	catch(def) {
762	const catchValueFunc = typeof def === "function" ? def : () => def;
763	return new ZodCatch$1({
764	...processCreateParams(this._def),
765	innerType: this,
766	catchValue: catchValueFunc,
767	typeName: ZodFirstPartyTypeKind.ZodCatch
768	});
769	}
770	describe(description) {
771	const This = this.constructor;
772	return new This({
773	...this._def,
774	description
775	});
776	}
777	pipe(target) {
778	return ZodPipeline.create(this, target);
779	}
780	readonly() {
781	return ZodReadonly$1.create(this);
782	}
783	isOptional() {
784	return this.safeParse(void 0).success;
785	}
786	isNullable() {
787	return this.safeParse(null).success;
788	}
789	};
790	var cuidRegex = /^c[^\s-]{8,}$/i;
791	var cuid2Regex = /^[0-9a-z]+$/;
792	var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
793	var uuidRegex = /^[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;
794	var nanoidRegex = /^[a-z0-9_-]{21}$/i;
795	var jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
796	var durationRegex = /^[-+]?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)?)??$/;
797	var emailRegex = /^(?!\.)(?!.\.\.)([A-Z0-9_'+\-\.])[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
798	var _emojiRegex = `^(\\p{Extended_Pictographic}\|\\p{Emoji_Component})+$`;
799	var emojiRegex$1;
800	var ipv4Regex = /^(?:(?: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])$/;
801	var ipv4CidrRegex = /^(?:(?: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])$/;
802	var ipv6Regex = /^(([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]))$/;
803	var ipv6CidrRegex = /^(([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])$/;
804	var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)\|([0-9a-zA-Z+/]{3}=))?$/;
805	var base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)\|([0-9a-zA-Z-_]{3}(=)?))?$/;
806	var dateRegexSource = `((\\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])))`;
807	var dateRegex = new RegExp(`^${dateRegexSource}$`);
808	function timeRegexSource(args) {
809	let secondsRegexSource = `[0-5]\\d`;
810	if (args.precision) secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
811	else if (args.precision == null) secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
812	const secondsQuantifier = args.precision ? "+" : "?";
813	return `([01]\\d\|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
814	}
815	function timeRegex(args) {
816	return new RegExp(`^${timeRegexSource(args)}$`);
817	}
818	function datetimeRegex(args) {
819	let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
820	const opts = [];
821	opts.push(args.local ? `Z?` : `Z`);
822	if (args.offset) opts.push(`([+-]\\d{2}:?\\d{2})`);
823	regex = `${regex}(${opts.join("\|")})`;
824	return new RegExp(`^${regex}$`);
825	}
826	function isValidIP(ip, version) {
827	if ((version === "v4" \|\| !version) && ipv4Regex.test(ip)) return true;
828	if ((version === "v6" \|\| !version) && ipv6Regex.test(ip)) return true;
829	return false;
830	}
831	function isValidJWT$1(jwt, alg) {
832	if (!jwtRegex.test(jwt)) return false;
833	try {
834	const [header] = jwt.split(".");
835	if (!header) return false;
836	const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
837	const decoded = JSON.parse(atob(base64));
838	if (typeof decoded !== "object" \|\| decoded === null) return false;
839	if ("typ" in decoded && decoded?.typ !== "JWT") return false;
840	if (!decoded.alg) return false;
841	if (alg && decoded.alg !== alg) return false;
842	return true;
843	} catch {
844	return false;
845	}
846	}
847	__name(isValidJWT$1, "isValidJWT");
848	function isValidCidr(ip, version) {
849	if ((version === "v4" \|\| !version) && ipv4CidrRegex.test(ip)) return true;
850	if ((version === "v6" \|\| !version) && ipv6CidrRegex.test(ip)) return true;
851	return false;
852	}
853	var ZodString$1 = class ZodString$1 extends ZodType$1 {
854	static {
855	__name(this, "ZodString");
856	}
857	_parse(input) {
858	if (this._def.coerce) input.data = String(input.data);
859	if (this._getType(input) !== ZodParsedType.string) {
860	const ctx = this._getOrReturnCtx(input);
861	addIssueToContext(ctx, {
862	code: ZodIssueCode.invalid_type,
863	expected: ZodParsedType.string,
864	received: ctx.parsedType
865	});
866	return INVALID;
867	}
868	const status = new ParseStatus();
869	let ctx = void 0;
870	for (const check of this._def.checks) if (check.kind === "min") {
871	if (input.data.length < check.value) {
872	ctx = this._getOrReturnCtx(input, ctx);
873	addIssueToContext(ctx, {
874	code: ZodIssueCode.too_small,
875	minimum: check.value,
876	type: "string",
877	inclusive: true,
878	exact: false,
879	message: check.message
880	});
881	status.dirty();
882	}
883	} else if (check.kind === "max") {
884	if (input.data.length > check.value) {
885	ctx = this._getOrReturnCtx(input, ctx);
886	addIssueToContext(ctx, {
887	code: ZodIssueCode.too_big,
888	maximum: check.value,
889	type: "string",
890	inclusive: true,
891	exact: false,
892	message: check.message
893	});
894	status.dirty();
895	}
896	} else if (check.kind === "length") {
897	const tooBig = input.data.length > check.value;
898	const tooSmall = input.data.length < check.value;
899	if (tooBig \|\| tooSmall) {
900	ctx = this._getOrReturnCtx(input, ctx);
901	if (tooBig) addIssueToContext(ctx, {
902	code: ZodIssueCode.too_big,
903	maximum: check.value,
904	type: "string",
905	inclusive: true,
906	exact: true,
907	message: check.message
908	});
909	else if (tooSmall) addIssueToContext(ctx, {
910	code: ZodIssueCode.too_small,
911	minimum: check.value,
912	type: "string",
913	inclusive: true,
914	exact: true,
915	message: check.message
916	});
917	status.dirty();
918	}
919	} else if (check.kind === "email") {
920	if (!emailRegex.test(input.data)) {
921	ctx = this._getOrReturnCtx(input, ctx);
922	addIssueToContext(ctx, {
923	validation: "email",
924	code: ZodIssueCode.invalid_string,
925	message: check.message
926	});
927	status.dirty();
928	}
929	} else if (check.kind === "emoji") {
930	if (!emojiRegex$1) emojiRegex$1 = new RegExp(_emojiRegex, "u");
931	if (!emojiRegex$1.test(input.data)) {
932	ctx = this._getOrReturnCtx(input, ctx);
933	addIssueToContext(ctx, {
934	validation: "emoji",
935	code: ZodIssueCode.invalid_string,
936	message: check.message
937	});
938	status.dirty();
939	}
940	} else if (check.kind === "uuid") {
941	if (!uuidRegex.test(input.data)) {
942	ctx = this._getOrReturnCtx(input, ctx);
943	addIssueToContext(ctx, {
944	validation: "uuid",
945	code: ZodIssueCode.invalid_string,
946	message: check.message
947	});
948	status.dirty();
949	}
950	} else if (check.kind === "nanoid") {
951	if (!nanoidRegex.test(input.data)) {
952	ctx = this._getOrReturnCtx(input, ctx);
953	addIssueToContext(ctx, {
954	validation: "nanoid",
955	code: ZodIssueCode.invalid_string,
956	message: check.message
957	});
958	status.dirty();
959	}
960	} else if (check.kind === "cuid") {
961	if (!cuidRegex.test(input.data)) {
962	ctx = this._getOrReturnCtx(input, ctx);
963	addIssueToContext(ctx, {
964	validation: "cuid",
965	code: ZodIssueCode.invalid_string,
966	message: check.message
967	});
968	status.dirty();
969	}
970	} else if (check.kind === "cuid2") {
971	if (!cuid2Regex.test(input.data)) {
972	ctx = this._getOrReturnCtx(input, ctx);
973	addIssueToContext(ctx, {
974	validation: "cuid2",
975	code: ZodIssueCode.invalid_string,
976	message: check.message
977	});
978	status.dirty();
979	}
980	} else if (check.kind === "ulid") {
981	if (!ulidRegex.test(input.data)) {
982	ctx = this._getOrReturnCtx(input, ctx);
983	addIssueToContext(ctx, {
984	validation: "ulid",
985	code: ZodIssueCode.invalid_string,
986	message: check.message
987	});
988	status.dirty();
989	}
990	} else if (check.kind === "url") try {
991	new URL(input.data);
992	} catch {
993	ctx = this._getOrReturnCtx(input, ctx);
994	addIssueToContext(ctx, {
995	validation: "url",
996	code: ZodIssueCode.invalid_string,
997	message: check.message
998	});
999	status.dirty();
1000	}
1001	else if (check.kind === "regex") {
1002	check.regex.lastIndex = 0;
1003	if (!check.regex.test(input.data)) {
1004	ctx = this._getOrReturnCtx(input, ctx);
1005	addIssueToContext(ctx, {
1006	validation: "regex",
1007	code: ZodIssueCode.invalid_string,
1008	message: check.message
1009	});
1010	status.dirty();
1011	}
1012	} else if (check.kind === "trim") input.data = input.data.trim();
1013	else if (check.kind === "includes") {
1014	if (!input.data.includes(check.value, check.position)) {
1015	ctx = this._getOrReturnCtx(input, ctx);
1016	addIssueToContext(ctx, {
1017	code: ZodIssueCode.invalid_string,
1018	validation: {
1019	includes: check.value,
1020	position: check.position
1021	},
1022	message: check.message
1023	});
1024	status.dirty();
1025	}
1026	} else if (check.kind === "toLowerCase") input.data = input.data.toLowerCase();
1027	else if (check.kind === "toUpperCase") input.data = input.data.toUpperCase();
1028	else if (check.kind === "startsWith") {
1029	if (!input.data.startsWith(check.value)) {
1030	ctx = this._getOrReturnCtx(input, ctx);
1031	addIssueToContext(ctx, {
1032	code: ZodIssueCode.invalid_string,
1033	validation: { startsWith: check.value },
1034	message: check.message
1035	});
1036	status.dirty();
1037	}
1038	} else if (check.kind === "endsWith") {
1039	if (!input.data.endsWith(check.value)) {
1040	ctx = this._getOrReturnCtx(input, ctx);
1041	addIssueToContext(ctx, {
1042	code: ZodIssueCode.invalid_string,
1043	validation: { endsWith: check.value },
1044	message: check.message
1045	});
1046	status.dirty();
1047	}
1048	} else if (check.kind === "datetime") {
1049	if (!datetimeRegex(check).test(input.data)) {
1050	ctx = this._getOrReturnCtx(input, ctx);
1051	addIssueToContext(ctx, {
1052	code: ZodIssueCode.invalid_string,
1053	validation: "datetime",
1054	message: check.message
1055	});
1056	status.dirty();
1057	}
1058	} else if (check.kind === "date") {
1059	if (!dateRegex.test(input.data)) {
1060	ctx = this._getOrReturnCtx(input, ctx);
1061	addIssueToContext(ctx, {
1062	code: ZodIssueCode.invalid_string,
1063	validation: "date",
1064	message: check.message
1065	});
1066	status.dirty();
1067	}
1068	} else if (check.kind === "time") {
1069	if (!timeRegex(check).test(input.data)) {
1070	ctx = this._getOrReturnCtx(input, ctx);
1071	addIssueToContext(ctx, {
1072	code: ZodIssueCode.invalid_string,
1073	validation: "time",
1074	message: check.message
1075	});
1076	status.dirty();
1077	}
1078	} else if (check.kind === "duration") {
1079	if (!durationRegex.test(input.data)) {
1080	ctx = this._getOrReturnCtx(input, ctx);
1081	addIssueToContext(ctx, {
1082	validation: "duration",
1083	code: ZodIssueCode.invalid_string,
1084	message: check.message
1085	});
1086	status.dirty();
1087	}
1088	} else if (check.kind === "ip") {
1089	if (!isValidIP(input.data, check.version)) {
1090	ctx = this._getOrReturnCtx(input, ctx);
1091	addIssueToContext(ctx, {
1092	validation: "ip",
1093	code: ZodIssueCode.invalid_string,
1094	message: check.message
1095	});
1096	status.dirty();
1097	}
1098	} else if (check.kind === "jwt") {
1099	if (!isValidJWT$1(input.data, check.alg)) {
1100	ctx = this._getOrReturnCtx(input, ctx);
1101	addIssueToContext(ctx, {
1102	validation: "jwt",
1103	code: ZodIssueCode.invalid_string,
1104	message: check.message
1105	});
1106	status.dirty();
1107	}
1108	} else if (check.kind === "cidr") {
1109	if (!isValidCidr(input.data, check.version)) {
1110	ctx = this._getOrReturnCtx(input, ctx);
1111	addIssueToContext(ctx, {
1112	validation: "cidr",
1113	code: ZodIssueCode.invalid_string,
1114	message: check.message
1115	});
1116	status.dirty();
1117	}
1118	} else if (check.kind === "base64") {
1119	if (!base64Regex.test(input.data)) {
1120	ctx = this._getOrReturnCtx(input, ctx);
1121	addIssueToContext(ctx, {
1122	validation: "base64",
1123	code: ZodIssueCode.invalid_string,
1124	message: check.message
1125	});
1126	status.dirty();
1127	}
1128	} else if (check.kind === "base64url") {
1129	if (!base64urlRegex.test(input.data)) {
1130	ctx = this._getOrReturnCtx(input, ctx);
1131	addIssueToContext(ctx, {
1132	validation: "base64url",
1133	code: ZodIssueCode.invalid_string,
1134	message: check.message
1135	});
1136	status.dirty();
1137	}
1138	} else util.assertNever(check);
1139	return {
1140	status: status.value,
1141	value: input.data
1142	};
1143	}
1144	_regex(regex, validation, message) {
1145	return this.refinement((data) => regex.test(data), {
1146	validation,
1147	code: ZodIssueCode.invalid_string,
1148	...errorUtil.errToObj(message)
1149	});
1150	}
1151	_addCheck(check) {
1152	return new ZodString$1({
1153	...this._def,
1154	checks: [...this._def.checks, check]
1155	});
1156	}
1157	email(message) {
1158	return this._addCheck({
1159	kind: "email",
1160	...errorUtil.errToObj(message)
1161	});
1162	}
1163	url(message) {
1164	return this._addCheck({
1165	kind: "url",
1166	...errorUtil.errToObj(message)
1167	});
1168	}
1169	emoji(message) {
1170	return this._addCheck({
1171	kind: "emoji",
1172	...errorUtil.errToObj(message)
1173	});
1174	}
1175	uuid(message) {
1176	return this._addCheck({
1177	kind: "uuid",
1178	...errorUtil.errToObj(message)
1179	});
1180	}
1181	nanoid(message) {
1182	return this._addCheck({
1183	kind: "nanoid",
1184	...errorUtil.errToObj(message)
1185	});
1186	}
1187	cuid(message) {
1188	return this._addCheck({
1189	kind: "cuid",
1190	...errorUtil.errToObj(message)
1191	});
1192	}
1193	cuid2(message) {
1194	return this._addCheck({
1195	kind: "cuid2",
1196	...errorUtil.errToObj(message)
1197	});
1198	}
1199	ulid(message) {
1200	return this._addCheck({
1201	kind: "ulid",
1202	...errorUtil.errToObj(message)
1203	});
1204	}
1205	base64(message) {
1206	return this._addCheck({
1207	kind: "base64",
1208	...errorUtil.errToObj(message)
1209	});
1210	}
1211	base64url(message) {
1212	return this._addCheck({
1213	kind: "base64url",
1214	...errorUtil.errToObj(message)
1215	});
1216	}
1217	jwt(options) {
1218	return this._addCheck({
1219	kind: "jwt",
1220	...errorUtil.errToObj(options)
1221	});
1222	}
1223	ip(options) {
1224	return this._addCheck({
1225	kind: "ip",
1226	...errorUtil.errToObj(options)
1227	});
1228	}
1229	cidr(options) {
1230	return this._addCheck({
1231	kind: "cidr",
1232	...errorUtil.errToObj(options)
1233	});
1234	}
1235	datetime(options) {
1236	if (typeof options === "string") return this._addCheck({
1237	kind: "datetime",
1238	precision: null,
1239	offset: false,
1240	local: false,
1241	message: options
1242	});
1243	return this._addCheck({
1244	kind: "datetime",
1245	precision: typeof options?.precision === "undefined" ? null : options?.precision,
1246	offset: options?.offset ?? false,
1247	local: options?.local ?? false,
1248	...errorUtil.errToObj(options?.message)
1249	});
1250	}
1251	date(message) {
1252	return this._addCheck({
1253	kind: "date",
1254	message
1255	});
1256	}
1257	time(options) {
1258	if (typeof options === "string") return this._addCheck({
1259	kind: "time",
1260	precision: null,
1261	message: options
1262	});
1263	return this._addCheck({
1264	kind: "time",
1265	precision: typeof options?.precision === "undefined" ? null : options?.precision,
1266	...errorUtil.errToObj(options?.message)
1267	});
1268	}
1269	duration(message) {
1270	return this._addCheck({
1271	kind: "duration",
1272	...errorUtil.errToObj(message)
1273	});
1274	}
1275	regex(regex, message) {
1276	return this._addCheck({
1277	kind: "regex",
1278	regex,
1279	...errorUtil.errToObj(message)
1280	});
1281	}
1282	includes(value, options) {
1283	return this._addCheck({
1284	kind: "includes",
1285	value,
1286	position: options?.position,
1287	...errorUtil.errToObj(options?.message)
1288	});
1289	}
1290	startsWith(value, message) {
1291	return this._addCheck({
1292	kind: "startsWith",
1293	value,
1294	...errorUtil.errToObj(message)
1295	});
1296	}
1297	endsWith(value, message) {
1298	return this._addCheck({
1299	kind: "endsWith",
1300	value,
1301	...errorUtil.errToObj(message)
1302	});
1303	}
1304	min(minLength, message) {
1305	return this._addCheck({
1306	kind: "min",
1307	value: minLength,
1308	...errorUtil.errToObj(message)
1309	});
1310	}
1311	max(maxLength, message) {
1312	return this._addCheck({
1313	kind: "max",
1314	value: maxLength,
1315	...errorUtil.errToObj(message)
1316	});
1317	}
1318	length(len, message) {
1319	return this._addCheck({
1320	kind: "length",
1321	value: len,
1322	...errorUtil.errToObj(message)
1323	});
1324	}
1325	/**
1326	* Equivalent to `.min(1)`
1327	*/
1328	nonempty(message) {
1329	return this.min(1, errorUtil.errToObj(message));
1330	}
1331	trim() {
1332	return new ZodString$1({
1333	...this._def,
1334	checks: [...this._def.checks, { kind: "trim" }]
1335	});
1336	}
1337	toLowerCase() {
1338	return new ZodString$1({
1339	...this._def,
1340	checks: [...this._def.checks, { kind: "toLowerCase" }]
1341	});
1342	}
1343	toUpperCase() {
1344	return new ZodString$1({
1345	...this._def,
1346	checks: [...this._def.checks, { kind: "toUpperCase" }]
1347	});
1348	}
1349	get isDatetime() {
1350	return !!this._def.checks.find((ch) => ch.kind === "datetime");
1351	}
1352	get isDate() {
1353	return !!this._def.checks.find((ch) => ch.kind === "date");
1354	}
1355	get isTime() {
1356	return !!this._def.checks.find((ch) => ch.kind === "time");
1357	}
1358	get isDuration() {
1359	return !!this._def.checks.find((ch) => ch.kind === "duration");
1360	}
1361	get isEmail() {
1362	return !!this._def.checks.find((ch) => ch.kind === "email");
1363	}
1364	get isURL() {
1365	return !!this._def.checks.find((ch) => ch.kind === "url");
1366	}
1367	get isEmoji() {
1368	return !!this._def.checks.find((ch) => ch.kind === "emoji");
1369	}
1370	get isUUID() {
1371	return !!this._def.checks.find((ch) => ch.kind === "uuid");
1372	}
1373	get isNANOID() {
1374	return !!this._def.checks.find((ch) => ch.kind === "nanoid");
1375	}
1376	get isCUID() {
1377	return !!this._def.checks.find((ch) => ch.kind === "cuid");
1378	}
1379	get isCUID2() {
1380	return !!this._def.checks.find((ch) => ch.kind === "cuid2");
1381	}
1382	get isULID() {
1383	return !!this._def.checks.find((ch) => ch.kind === "ulid");
1384	}
1385	get isIP() {
1386	return !!this._def.checks.find((ch) => ch.kind === "ip");
1387	}
1388	get isCIDR() {
1389	return !!this._def.checks.find((ch) => ch.kind === "cidr");
1390	}
1391	get isBase64() {
1392	return !!this._def.checks.find((ch) => ch.kind === "base64");
1393	}
1394	get isBase64url() {
1395	return !!this._def.checks.find((ch) => ch.kind === "base64url");
1396	}
1397	get minLength() {
1398	let min = null;
1399	for (const ch of this._def.checks) if (ch.kind === "min") {
1400	if (min === null \|\| ch.value > min) min = ch.value;
1401	}
1402	return min;
1403	}
1404	get maxLength() {
1405	let max = null;
1406	for (const ch of this._def.checks) if (ch.kind === "max") {
1407	if (max === null \|\| ch.value < max) max = ch.value;
1408	}
1409	return max;
1410	}
1411	};
1412	ZodString$1.create = (params) => {
1413	return new ZodString$1({
1414	checks: [],
1415	typeName: ZodFirstPartyTypeKind.ZodString,
1416	coerce: params?.coerce ?? false,
1417	...processCreateParams(params)
1418	});
1419	};
1420	function floatSafeRemainder$1(val, step) {
1421	const valDecCount = (val.toString().split(".")[1] \|\| "").length;
1422	const stepDecCount = (step.toString().split(".")[1] \|\| "").length;
1423	const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
1424	return Number.parseInt(val.toFixed(decCount).replace(".", "")) % Number.parseInt(step.toFixed(decCount).replace(".", "")) / 10 ** decCount;
1425	}
1426	__name(floatSafeRemainder$1, "floatSafeRemainder");
1427	var ZodNumber$1 = class ZodNumber$1 extends ZodType$1 {
1428	static {
1429	__name(this, "ZodNumber");
1430	}
1431	constructor() {
1432	super(...arguments);
1433	this.min = this.gte;
1434	this.max = this.lte;
1435	this.step = this.multipleOf;
1436	}
1437	_parse(input) {
1438	if (this._def.coerce) input.data = Number(input.data);
1439	if (this._getType(input) !== ZodParsedType.number) {
1440	const ctx = this._getOrReturnCtx(input);
1441	addIssueToContext(ctx, {
1442	code: ZodIssueCode.invalid_type,
1443	expected: ZodParsedType.number,
1444	received: ctx.parsedType
1445	});
1446	return INVALID;
1447	}
1448	let ctx = void 0;
1449	const status = new ParseStatus();
1450	for (const check of this._def.checks) if (check.kind === "int") {
1451	if (!util.isInteger(input.data)) {
1452	ctx = this._getOrReturnCtx(input, ctx);
1453	addIssueToContext(ctx, {
1454	code: ZodIssueCode.invalid_type,
1455	expected: "integer",
1456	received: "float",
1457	message: check.message
1458	});
1459	status.dirty();
1460	}
1461	} else if (check.kind === "min") {
1462	if (check.inclusive ? input.data < check.value : input.data <= check.value) {
1463	ctx = this._getOrReturnCtx(input, ctx);
1464	addIssueToContext(ctx, {
1465	code: ZodIssueCode.too_small,
1466	minimum: check.value,
1467	type: "number",
1468	inclusive: check.inclusive,
1469	exact: false,
1470	message: check.message
1471	});
1472	status.dirty();
1473	}
1474	} else if (check.kind === "max") {
1475	if (check.inclusive ? input.data > check.value : input.data >= check.value) {
1476	ctx = this._getOrReturnCtx(input, ctx);
1477	addIssueToContext(ctx, {
1478	code: ZodIssueCode.too_big,
1479	maximum: check.value,
1480	type: "number",
1481	inclusive: check.inclusive,
1482	exact: false,
1483	message: check.message
1484	});
1485	status.dirty();
1486	}
1487	} else if (check.kind === "multipleOf") {
1488	if (floatSafeRemainder$1(input.data, check.value) !== 0) {
1489	ctx = this._getOrReturnCtx(input, ctx);
1490	addIssueToContext(ctx, {
1491	code: ZodIssueCode.not_multiple_of,
1492	multipleOf: check.value,
1493	message: check.message
1494	});
1495	status.dirty();
1496	}
1497	} else if (check.kind === "finite") {
1498	if (!Number.isFinite(input.data)) {
1499	ctx = this._getOrReturnCtx(input, ctx);
1500	addIssueToContext(ctx, {
1501	code: ZodIssueCode.not_finite,
1502	message: check.message
1503	});
1504	status.dirty();
1505	}
1506	} else util.assertNever(check);
1507	return {
1508	status: status.value,
1509	value: input.data
1510	};
1511	}
1512	gte(value, message) {
1513	return this.setLimit("min", value, true, errorUtil.toString(message));
1514	}
1515	gt(value, message) {
1516	return this.setLimit("min", value, false, errorUtil.toString(message));
1517	}
1518	lte(value, message) {
1519	return this.setLimit("max", value, true, errorUtil.toString(message));
1520	}
1521	lt(value, message) {
1522	return this.setLimit("max", value, false, errorUtil.toString(message));
1523	}
1524	setLimit(kind, value, inclusive, message) {
1525	return new ZodNumber$1({
1526	...this._def,
1527	checks: [...this._def.checks, {
1528	kind,
1529	value,
1530	inclusive,
1531	message: errorUtil.toString(message)
1532	}]
1533	});
1534	}
1535	_addCheck(check) {
1536	return new ZodNumber$1({
1537	...this._def,
1538	checks: [...this._def.checks, check]
1539	});
1540	}
1541	int(message) {
1542	return this._addCheck({
1543	kind: "int",
1544	message: errorUtil.toString(message)
1545	});
1546	}
1547	positive(message) {
1548	return this._addCheck({
1549	kind: "min",
1550	value: 0,
1551	inclusive: false,
1552	message: errorUtil.toString(message)
1553	});
1554	}
1555	negative(message) {
1556	return this._addCheck({
1557	kind: "max",
1558	value: 0,
1559	inclusive: false,
1560	message: errorUtil.toString(message)
1561	});
1562	}
1563	nonpositive(message) {
1564	return this._addCheck({
1565	kind: "max",
1566	value: 0,
1567	inclusive: true,
1568	message: errorUtil.toString(message)
1569	});
1570	}
1571	nonnegative(message) {
1572	return this._addCheck({
1573	kind: "min",
1574	value: 0,
1575	inclusive: true,
1576	message: errorUtil.toString(message)
1577	});
1578	}
1579	multipleOf(value, message) {
1580	return this._addCheck({
1581	kind: "multipleOf",
1582	value,
1583	message: errorUtil.toString(message)
1584	});
1585	}
1586	finite(message) {
1587	return this._addCheck({
1588	kind: "finite",
1589	message: errorUtil.toString(message)
1590	});
1591	}
1592	safe(message) {
1593	return this._addCheck({
1594	kind: "min",
1595	inclusive: true,
1596	value: Number.MIN_SAFE_INTEGER,
1597	message: errorUtil.toString(message)
1598	})._addCheck({
1599	kind: "max",
1600	inclusive: true,
1601	value: Number.MAX_SAFE_INTEGER,
1602	message: errorUtil.toString(message)
1603	});
1604	}
1605	get minValue() {
1606	let min = null;
1607	for (const ch of this._def.checks) if (ch.kind === "min") {
1608	if (min === null \|\| ch.value > min) min = ch.value;
1609	}
1610	return min;
1611	}
1612	get maxValue() {
1613	let max = null;
1614	for (const ch of this._def.checks) if (ch.kind === "max") {
1615	if (max === null \|\| ch.value < max) max = ch.value;
1616	}
1617	return max;
1618	}
1619	get isInt() {
1620	return !!this._def.checks.find((ch) => ch.kind === "int" \|\| ch.kind === "multipleOf" && util.isInteger(ch.value));
1621	}
1622	get isFinite() {
1623	let max = null;
1624	let min = null;
1625	for (const ch of this._def.checks) if (ch.kind === "finite" \|\| ch.kind === "int" \|\| ch.kind === "multipleOf") return true;
1626	else if (ch.kind === "min") {
1627	if (min === null \|\| ch.value > min) min = ch.value;
1628	} else if (ch.kind === "max") {
1629	if (max === null \|\| ch.value < max) max = ch.value;
1630	}
1631	return Number.isFinite(min) && Number.isFinite(max);
1632	}
1633	};
1634	ZodNumber$1.create = (params) => {
1635	return new ZodNumber$1({
1636	checks: [],
1637	typeName: ZodFirstPartyTypeKind.ZodNumber,
1638	coerce: params?.coerce \|\| false,
1639	...processCreateParams(params)
1640	});
1641	};
1642	var ZodBigInt = class ZodBigInt extends ZodType$1 {
1643	constructor() {
1644	super(...arguments);
1645	this.min = this.gte;
1646	this.max = this.lte;
1647	}
1648	_parse(input) {
1649	if (this._def.coerce) try {
1650	input.data = BigInt(input.data);
1651	} catch {
1652	return this._getInvalidInput(input);
1653	}
1654	if (this._getType(input) !== ZodParsedType.bigint) return this._getInvalidInput(input);
1655	let ctx = void 0;
1656	const status = new ParseStatus();
1657	for (const check of this._def.checks) if (check.kind === "min") {
1658	if (check.inclusive ? input.data < check.value : input.data <= check.value) {
1659	ctx = this._getOrReturnCtx(input, ctx);
1660	addIssueToContext(ctx, {
1661	code: ZodIssueCode.too_small,
1662	type: "bigint",
1663	minimum: check.value,
1664	inclusive: check.inclusive,
1665	message: check.message
1666	});
1667	status.dirty();
1668	}
1669	} else if (check.kind === "max") {
1670	if (check.inclusive ? input.data > check.value : input.data >= check.value) {
1671	ctx = this._getOrReturnCtx(input, ctx);
1672	addIssueToContext(ctx, {
1673	code: ZodIssueCode.too_big,
1674	type: "bigint",
1675	maximum: check.value,
1676	inclusive: check.inclusive,
1677	message: check.message
1678	});
1679	status.dirty();
1680	}
1681	} else if (check.kind === "multipleOf") {
1682	if (input.data % check.value !== BigInt(0)) {
1683	ctx = this._getOrReturnCtx(input, ctx);
1684	addIssueToContext(ctx, {
1685	code: ZodIssueCode.not_multiple_of,
1686	multipleOf: check.value,
1687	message: check.message
1688	});
1689	status.dirty();
1690	}
1691	} else util.assertNever(check);
1692	return {
1693	status: status.value,
1694	value: input.data
1695	};
1696	}
1697	_getInvalidInput(input) {
1698	const ctx = this._getOrReturnCtx(input);
1699	addIssueToContext(ctx, {
1700	code: ZodIssueCode.invalid_type,
1701	expected: ZodParsedType.bigint,
1702	received: ctx.parsedType
1703	});
1704	return INVALID;
1705	}
1706	gte(value, message) {
1707	return this.setLimit("min", value, true, errorUtil.toString(message));
1708	}
1709	gt(value, message) {
1710	return this.setLimit("min", value, false, errorUtil.toString(message));
1711	}
1712	lte(value, message) {
1713	return this.setLimit("max", value, true, errorUtil.toString(message));
1714	}
1715	lt(value, message) {
1716	return this.setLimit("max", value, false, errorUtil.toString(message));
1717	}
1718	setLimit(kind, value, inclusive, message) {
1719	return new ZodBigInt({
1720	...this._def,
1721	checks: [...this._def.checks, {
1722	kind,
1723	value,
1724	inclusive,
1725	message: errorUtil.toString(message)
1726	}]
1727	});
1728	}
1729	_addCheck(check) {
1730	return new ZodBigInt({
1731	...this._def,
1732	checks: [...this._def.checks, check]
1733	});
1734	}
1735	positive(message) {
1736	return this._addCheck({
1737	kind: "min",
1738	value: BigInt(0),
1739	inclusive: false,
1740	message: errorUtil.toString(message)
1741	});
1742	}
1743	negative(message) {
1744	return this._addCheck({
1745	kind: "max",
1746	value: BigInt(0),
1747	inclusive: false,
1748	message: errorUtil.toString(message)
1749	});
1750	}
1751	nonpositive(message) {
1752	return this._addCheck({
1753	kind: "max",
1754	value: BigInt(0),
1755	inclusive: true,
1756	message: errorUtil.toString(message)
1757	});
1758	}
1759	nonnegative(message) {
1760	return this._addCheck({
1761	kind: "min",
1762	value: BigInt(0),
1763	inclusive: true,
1764	message: errorUtil.toString(message)
1765	});
1766	}
1767	multipleOf(value, message) {
1768	return this._addCheck({
1769	kind: "multipleOf",
1770	value,
1771	message: errorUtil.toString(message)
1772	});
1773	}
1774	get minValue() {
1775	let min = null;
1776	for (const ch of this._def.checks) if (ch.kind === "min") {
1777	if (min === null \|\| ch.value > min) min = ch.value;
1778	}
1779	return min;
1780	}
1781	get maxValue() {
1782	let max = null;
1783	for (const ch of this._def.checks) if (ch.kind === "max") {
1784	if (max === null \|\| ch.value < max) max = ch.value;
1785	}
1786	return max;
1787	}
1788	};
1789	ZodBigInt.create = (params) => {
1790	return new ZodBigInt({
1791	checks: [],
1792	typeName: ZodFirstPartyTypeKind.ZodBigInt,
1793	coerce: params?.coerce ?? false,
1794	...processCreateParams(params)
1795	});
1796	};
1797	var ZodBoolean$1 = class extends ZodType$1 {
1798	static {
1799	__name(this, "ZodBoolean");
1800	}
1801	_parse(input) {
1802	if (this._def.coerce) input.data = Boolean(input.data);
1803	if (this._getType(input) !== ZodParsedType.boolean) {
1804	const ctx = this._getOrReturnCtx(input);
1805	addIssueToContext(ctx, {
1806	code: ZodIssueCode.invalid_type,
1807	expected: ZodParsedType.boolean,
1808	received: ctx.parsedType
1809	});
1810	return INVALID;
1811	}
1812	return OK(input.data);
1813	}
1814	};
1815	ZodBoolean$1.create = (params) => {
1816	return new ZodBoolean$1({
1817	typeName: ZodFirstPartyTypeKind.ZodBoolean,
1818	coerce: params?.coerce \|\| false,
1819	...processCreateParams(params)
1820	});
1821	};
1822	var ZodDate = class ZodDate extends ZodType$1 {
1823	_parse(input) {
1824	if (this._def.coerce) input.data = new Date(input.data);
1825	if (this._getType(input) !== ZodParsedType.date) {
1826	const ctx = this._getOrReturnCtx(input);
1827	addIssueToContext(ctx, {
1828	code: ZodIssueCode.invalid_type,
1829	expected: ZodParsedType.date,
1830	received: ctx.parsedType
1831	});
1832	return INVALID;
1833	}
1834	if (Number.isNaN(input.data.getTime())) {
1835	addIssueToContext(this._getOrReturnCtx(input), { code: ZodIssueCode.invalid_date });
1836	return INVALID;
1837	}
1838	const status = new ParseStatus();
1839	let ctx = void 0;
1840	for (const check of this._def.checks) if (check.kind === "min") {
1841	if (input.data.getTime() < check.value) {
1842	ctx = this._getOrReturnCtx(input, ctx);
1843	addIssueToContext(ctx, {
1844	code: ZodIssueCode.too_small,
1845	message: check.message,
1846	inclusive: true,
1847	exact: false,
1848	minimum: check.value,
1849	type: "date"
1850	});
1851	status.dirty();
1852	}
1853	} else if (check.kind === "max") {
1854	if (input.data.getTime() > check.value) {
1855	ctx = this._getOrReturnCtx(input, ctx);
1856	addIssueToContext(ctx, {
1857	code: ZodIssueCode.too_big,
1858	message: check.message,
1859	inclusive: true,
1860	exact: false,
1861	maximum: check.value,
1862	type: "date"
1863	});
1864	status.dirty();
1865	}
1866	} else util.assertNever(check);
1867	return {
1868	status: status.value,
1869	value: new Date(input.data.getTime())
1870	};
1871	}
1872	_addCheck(check) {
1873	return new ZodDate({
1874	...this._def,
1875	checks: [...this._def.checks, check]
1876	});
1877	}
1878	min(minDate, message) {
1879	return this._addCheck({
1880	kind: "min",
1881	value: minDate.getTime(),
1882	message: errorUtil.toString(message)
1883	});
1884	}
1885	max(maxDate, message) {
1886	return this._addCheck({
1887	kind: "max",
1888	value: maxDate.getTime(),
1889	message: errorUtil.toString(message)
1890	});
1891	}
1892	get minDate() {
1893	let min = null;
1894	for (const ch of this._def.checks) if (ch.kind === "min") {
1895	if (min === null \|\| ch.value > min) min = ch.value;
1896	}
1897	return min != null ? new Date(min) : null;
1898	}
1899	get maxDate() {
1900	let max = null;
1901	for (const ch of this._def.checks) if (ch.kind === "max") {
1902	if (max === null \|\| ch.value < max) max = ch.value;
1903	}
1904	return max != null ? new Date(max) : null;
1905	}
1906	};
1907	ZodDate.create = (params) => {
1908	return new ZodDate({
1909	checks: [],
1910	coerce: params?.coerce \|\| false,
1911	typeName: ZodFirstPartyTypeKind.ZodDate,
1912	...processCreateParams(params)
1913	});
1914	};
1915	var ZodSymbol = class extends ZodType$1 {
1916	_parse(input) {
1917	if (this._getType(input) !== ZodParsedType.symbol) {
1918	const ctx = this._getOrReturnCtx(input);
1919	addIssueToContext(ctx, {
1920	code: ZodIssueCode.invalid_type,
1921	expected: ZodParsedType.symbol,
1922	received: ctx.parsedType
1923	});
1924	return INVALID;
1925	}
1926	return OK(input.data);
1927	}
1928	};
1929	ZodSymbol.create = (params) => {
1930	return new ZodSymbol({
1931	typeName: ZodFirstPartyTypeKind.ZodSymbol,
1932	...processCreateParams(params)
1933	});
1934	};
1935	var ZodUndefined = class extends ZodType$1 {
1936	_parse(input) {
1937	if (this._getType(input) !== ZodParsedType.undefined) {
1938	const ctx = this._getOrReturnCtx(input);
1939	addIssueToContext(ctx, {
1940	code: ZodIssueCode.invalid_type,
1941	expected: ZodParsedType.undefined,
1942	received: ctx.parsedType
1943	});
1944	return INVALID;
1945	}
1946	return OK(input.data);
1947	}
1948	};
1949	ZodUndefined.create = (params) => {
1950	return new ZodUndefined({
1951	typeName: ZodFirstPartyTypeKind.ZodUndefined,
1952	...processCreateParams(params)
1953	});
1954	};
1955	var ZodNull$1 = class extends ZodType$1 {
1956	static {
1957	__name(this, "ZodNull");
1958	}
1959	_parse(input) {
1960	if (this._getType(input) !== ZodParsedType.null) {
1961	const ctx = this._getOrReturnCtx(input);
1962	addIssueToContext(ctx, {
1963	code: ZodIssueCode.invalid_type,
1964	expected: ZodParsedType.null,
1965	received: ctx.parsedType
1966	});
1967	return INVALID;
1968	}
1969	return OK(input.data);
1970	}
1971	};
1972	ZodNull$1.create = (params) => {
1973	return new ZodNull$1({
1974	typeName: ZodFirstPartyTypeKind.ZodNull,
1975	...processCreateParams(params)
1976	});
1977	};
1978	var ZodAny = class extends ZodType$1 {
1979	constructor() {
1980	super(...arguments);
1981	this._any = true;
1982	}
1983	_parse(input) {
1984	return OK(input.data);
1985	}
1986	};
1987	ZodAny.create = (params) => {
1988	return new ZodAny({
1989	typeName: ZodFirstPartyTypeKind.ZodAny,
1990	...processCreateParams(params)
1991	});
1992	};
1993	var ZodUnknown$1 = class extends ZodType$1 {
1994	static {
1995	__name(this, "ZodUnknown");
1996	}
1997	constructor() {
1998	super(...arguments);
1999	this._unknown = true;
2000	}
2001	_parse(input) {
2002	return OK(input.data);
2003	}
2004	};
2005	ZodUnknown$1.create = (params) => {
2006	return new ZodUnknown$1({
2007	typeName: ZodFirstPartyTypeKind.ZodUnknown,
2008	...processCreateParams(params)
2009	});
2010	};
2011	var ZodNever$1 = class extends ZodType$1 {
2012	static {
2013	__name(this, "ZodNever");
2014	}
2015	_parse(input) {
2016	const ctx = this._getOrReturnCtx(input);
2017	addIssueToContext(ctx, {
2018	code: ZodIssueCode.invalid_type,
2019	expected: ZodParsedType.never,
2020	received: ctx.parsedType
2021	});
2022	return INVALID;
2023	}
2024	};
2025	ZodNever$1.create = (params) => {
2026	return new ZodNever$1({
2027	typeName: ZodFirstPartyTypeKind.ZodNever,
2028	...processCreateParams(params)
2029	});
2030	};
2031	var ZodVoid = class extends ZodType$1 {
2032	_parse(input) {
2033	if (this._getType(input) !== ZodParsedType.undefined) {
2034	const ctx = this._getOrReturnCtx(input);
2035	addIssueToContext(ctx, {
2036	code: ZodIssueCode.invalid_type,
2037	expected: ZodParsedType.void,
2038	received: ctx.parsedType
2039	});
2040	return INVALID;
2041	}
2042	return OK(input.data);
2043	}
2044	};
2045	ZodVoid.create = (params) => {
2046	return new ZodVoid({
2047	typeName: ZodFirstPartyTypeKind.ZodVoid,
2048	...processCreateParams(params)
2049	});
2050	};
2051	var ZodArray$1 = class ZodArray$1 extends ZodType$1 {
2052	static {
2053	__name(this, "ZodArray");
2054	}
2055	_parse(input) {
2056	const { ctx, status } = this._processInputParams(input);
2057	const def = this._def;
2058	if (ctx.parsedType !== ZodParsedType.array) {
2059	addIssueToContext(ctx, {
2060	code: ZodIssueCode.invalid_type,
2061	expected: ZodParsedType.array,
2062	received: ctx.parsedType
2063	});
2064	return INVALID;
2065	}
2066	if (def.exactLength !== null) {
2067	const tooBig = ctx.data.length > def.exactLength.value;
2068	const tooSmall = ctx.data.length < def.exactLength.value;
2069	if (tooBig \|\| tooSmall) {
2070	addIssueToContext(ctx, {
2071	code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
2072	minimum: tooSmall ? def.exactLength.value : void 0,
2073	maximum: tooBig ? def.exactLength.value : void 0,
2074	type: "array",
2075	inclusive: true,
2076	exact: true,
2077	message: def.exactLength.message
2078	});
2079	status.dirty();
2080	}
2081	}
2082	if (def.minLength !== null) {
2083	if (ctx.data.length < def.minLength.value) {
2084	addIssueToContext(ctx, {
2085	code: ZodIssueCode.too_small,
2086	minimum: def.minLength.value,
2087	type: "array",
2088	inclusive: true,
2089	exact: false,
2090	message: def.minLength.message
2091	});
2092	status.dirty();
2093	}
2094	}
2095	if (def.maxLength !== null) {
2096	if (ctx.data.length > def.maxLength.value) {
2097	addIssueToContext(ctx, {
2098	code: ZodIssueCode.too_big,
2099	maximum: def.maxLength.value,
2100	type: "array",
2101	inclusive: true,
2102	exact: false,
2103	message: def.maxLength.message
2104	});
2105	status.dirty();
2106	}
2107	}
2108	if (ctx.common.async) return Promise.all([...ctx.data].map((item, i) => {
2109	return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
2110	})).then((result) => {
2111	return ParseStatus.mergeArray(status, result);
2112	});
2113	const result = [...ctx.data].map((item, i) => {
2114	return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
2115	});
2116	return ParseStatus.mergeArray(status, result);
2117	}
2118	get element() {
2119	return this._def.type;
2120	}
2121	min(minLength, message) {
2122	return new ZodArray$1({
2123	...this._def,
2124	minLength: {
2125	value: minLength,
2126	message: errorUtil.toString(message)
2127	}
2128	});
2129	}
2130	max(maxLength, message) {
2131	return new ZodArray$1({
2132	...this._def,
2133	maxLength: {
2134	value: maxLength,
2135	message: errorUtil.toString(message)
2136	}
2137	});
2138	}
2139	length(len, message) {
2140	return new ZodArray$1({
2141	...this._def,
2142	exactLength: {
2143	value: len,
2144	message: errorUtil.toString(message)
2145	}
2146	});
2147	}
2148	nonempty(message) {
2149	return this.min(1, message);
2150	}
2151	};
2152	ZodArray$1.create = (schema, params) => {
2153	return new ZodArray$1({
2154	type: schema,
2155	minLength: null,
2156	maxLength: null,
2157	exactLength: null,
2158	typeName: ZodFirstPartyTypeKind.ZodArray,
2159	...processCreateParams(params)
2160	});
2161	};
2162	function deepPartialify(schema) {
2163	if (schema instanceof ZodObject$1) {
2164	const newShape = {};
2165	for (const key in schema.shape) {
2166	const fieldSchema = schema.shape[key];
2167	newShape[key] = ZodOptional$1.create(deepPartialify(fieldSchema));
2168	}
2169	return new ZodObject$1({
2170	...schema._def,
2171	shape: () => newShape
2172	});
2173	} else if (schema instanceof ZodArray$1) return new ZodArray$1({
2174	...schema._def,
2175	type: deepPartialify(schema.element)
2176	});
2177	else if (schema instanceof ZodOptional$1) return ZodOptional$1.create(deepPartialify(schema.unwrap()));
2178	else if (schema instanceof ZodNullable$1) return ZodNullable$1.create(deepPartialify(schema.unwrap()));
2179	else if (schema instanceof ZodTuple) return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
2180	else return schema;
2181	}
2182	var ZodObject$1 = class ZodObject$1 extends ZodType$1 {
2183	static {
2184	__name(this, "ZodObject");
2185	}
2186	constructor() {
2187	super(...arguments);
2188	this._cached = null;
2189	/**
2190	* @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
2191	* If you want to pass through unknown properties, use `.passthrough()` instead.
2192	*/
2193	this.nonstrict = this.passthrough;
2194	/**
2195	* @deprecated Use `.extend` instead
2196	* */
2197	this.augment = this.extend;
2198	}
2199	_getCached() {
2200	if (this._cached !== null) return this._cached;
2201	const shape = this._def.shape();
2202	const keys = util.objectKeys(shape);
2203	this._cached = {
2204	shape,
2205	keys
2206	};
2207	return this._cached;
2208	}
2209	_parse(input) {
2210	if (this._getType(input) !== ZodParsedType.object) {
2211	const ctx = this._getOrReturnCtx(input);
2212	addIssueToContext(ctx, {
2213	code: ZodIssueCode.invalid_type,
2214	expected: ZodParsedType.object,
2215	received: ctx.parsedType
2216	});
2217	return INVALID;
2218	}
2219	const { status, ctx } = this._processInputParams(input);
2220	const { shape, keys: shapeKeys } = this._getCached();
2221	const extraKeys = [];
2222	if (!(this._def.catchall instanceof ZodNever$1 && this._def.unknownKeys === "strip")) {
2223	for (const key in ctx.data) if (!shapeKeys.includes(key)) extraKeys.push(key);
2224	}
2225	const pairs = [];
2226	for (const key of shapeKeys) {
2227	const keyValidator = shape[key];
2228	const value = ctx.data[key];
2229	pairs.push({
2230	key: {
2231	status: "valid",
2232	value: key
2233	},
2234	value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
2235	alwaysSet: key in ctx.data
2236	});
2237	}
2238	if (this._def.catchall instanceof ZodNever$1) {
2239	const unknownKeys = this._def.unknownKeys;
2240	if (unknownKeys === "passthrough") for (const key of extraKeys) pairs.push({
2241	key: {
2242	status: "valid",
2243	value: key
2244	},
2245	value: {
2246	status: "valid",
2247	value: ctx.data[key]
2248	}
2249	});
2250	else if (unknownKeys === "strict") {
2251	if (extraKeys.length > 0) {
2252	addIssueToContext(ctx, {
2253	code: ZodIssueCode.unrecognized_keys,
2254	keys: extraKeys
2255	});
2256	status.dirty();
2257	}
2258	} else if (unknownKeys === "strip") {} else throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
2259	} else {
2260	const catchall = this._def.catchall;
2261	for (const key of extraKeys) {
2262	const value = ctx.data[key];
2263	pairs.push({
2264	key: {
2265	status: "valid",
2266	value: key
2267	},
2268	value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
2269	alwaysSet: key in ctx.data
2270	});
2271	}
2272	}
2273	if (ctx.common.async) return Promise.resolve().then(async () => {
2274	const syncPairs = [];
2275	for (const pair of pairs) {
2276	const key = await pair.key;
2277	const value = await pair.value;
2278	syncPairs.push({
2279	key,
2280	value,
2281	alwaysSet: pair.alwaysSet
2282	});
2283	}
2284	return syncPairs;
2285	}).then((syncPairs) => {
2286	return ParseStatus.mergeObjectSync(status, syncPairs);
2287	});
2288	else return ParseStatus.mergeObjectSync(status, pairs);
2289	}
2290	get shape() {
2291	return this._def.shape();
2292	}
2293	strict(message) {
2294	errorUtil.errToObj;
2295	return new ZodObject$1({
2296	...this._def,
2297	unknownKeys: "strict",
2298	...message !== void 0 ? { errorMap: (issue, ctx) => {
2299	const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
2300	if (issue.code === "unrecognized_keys") return { message: errorUtil.errToObj(message).message ?? defaultError };
2301	return { message: defaultError };
2302	} } : {}
2303	});
2304	}
2305	strip() {
2306	return new ZodObject$1({
2307	...this._def,
2308	unknownKeys: "strip"
2309	});
2310	}
2311	passthrough() {
2312	return new ZodObject$1({
2313	...this._def,
2314	unknownKeys: "passthrough"
2315	});
2316	}
2317	extend(augmentation) {
2318	return new ZodObject$1({
2319	...this._def,
2320	shape: () => ({
2321	...this._def.shape(),
2322	...augmentation
2323	})
2324	});
2325	}
2326	/**
2327	* Prior to [email protected] there was a bug in the
2328	* inferred type of merged objects. Please
2329	* upgrade if you are experiencing issues.
2330	*/
2331	merge(merging) {
2332	return new ZodObject$1({
2333	unknownKeys: merging._def.unknownKeys,
2334	catchall: merging._def.catchall,
2335	shape: () => ({
2336	...this._def.shape(),
2337	...merging._def.shape()
2338	}),
2339	typeName: ZodFirstPartyTypeKind.ZodObject
2340	});
2341	}
2342	setKey(key, schema) {
2343	return this.augment({ [key]: schema });
2344	}
2345	catchall(index) {
2346	return new ZodObject$1({
2347	...this._def,
2348	catchall: index
2349	});
2350	}
2351	pick(mask) {
2352	const shape = {};
2353	for (const key of util.objectKeys(mask)) if (mask[key] && this.shape[key]) shape[key] = this.shape[key];
2354	return new ZodObject$1({
2355	...this._def,
2356	shape: () => shape
2357	});
2358	}
2359	omit(mask) {
2360	const shape = {};
2361	for (const key of util.objectKeys(this.shape)) if (!mask[key]) shape[key] = this.shape[key];
2362	return new ZodObject$1({
2363	...this._def,
2364	shape: () => shape
2365	});
2366	}
2367	/**
2368	* @deprecated
2369	*/
2370	deepPartial() {
2371	return deepPartialify(this);
2372	}
2373	partial(mask) {
2374	const newShape = {};
2375	for (const key of util.objectKeys(this.shape)) {
2376	const fieldSchema = this.shape[key];
2377	if (mask && !mask[key]) newShape[key] = fieldSchema;
2378	else newShape[key] = fieldSchema.optional();
2379	}
2380	return new ZodObject$1({
2381	...this._def,
2382	shape: () => newShape
2383	});
2384	}
2385	required(mask) {
2386	const newShape = {};
2387	for (const key of util.objectKeys(this.shape)) if (mask && !mask[key]) newShape[key] = this.shape[key];
2388	else {
2389	let newField = this.shape[key];
2390	while (newField instanceof ZodOptional$1) newField = newField._def.innerType;
2391	newShape[key] = newField;
2392	}
2393	return new ZodObject$1({
2394	...this._def,
2395	shape: () => newShape
2396	});
2397	}
2398	keyof() {
2399	return createZodEnum(util.objectKeys(this.shape));
2400	}
2401	};
2402	ZodObject$1.create = (shape, params) => {
2403	return new ZodObject$1({
2404	shape: () => shape,
2405	unknownKeys: "strip",
2406	catchall: ZodNever$1.create(),
2407	typeName: ZodFirstPartyTypeKind.ZodObject,
2408	...processCreateParams(params)
2409	});
2410	};
2411	ZodObject$1.strictCreate = (shape, params) => {
2412	return new ZodObject$1({
2413	shape: () => shape,
2414	unknownKeys: "strict",
2415	catchall: ZodNever$1.create(),
2416	typeName: ZodFirstPartyTypeKind.ZodObject,
2417	...processCreateParams(params)
2418	});
2419	};
2420	ZodObject$1.lazycreate = (shape, params) => {
2421	return new ZodObject$1({
2422	shape,
2423	unknownKeys: "strip",
2424	catchall: ZodNever$1.create(),
2425	typeName: ZodFirstPartyTypeKind.ZodObject,
2426	...processCreateParams(params)
2427	});
2428	};
2429	var ZodUnion$1 = class extends ZodType$1 {
2430	static {
2431	__name(this, "ZodUnion");
2432	}
2433	_parse(input) {
2434	const { ctx } = this._processInputParams(input);
2435	const options = this._def.options;
2436	function handleResults(results) {
2437	for (const result of results) if (result.result.status === "valid") return result.result;
2438	for (const result of results) if (result.result.status === "dirty") {
2439	ctx.common.issues.push(...result.ctx.common.issues);
2440	return result.result;
2441	}
2442	const unionErrors = results.map((result) => new ZodError$1(result.ctx.common.issues));
2443	addIssueToContext(ctx, {
2444	code: ZodIssueCode.invalid_union,
2445	unionErrors
2446	});
2447	return INVALID;
2448	}
2449	if (ctx.common.async) return Promise.all(options.map(async (option) => {
2450	const childCtx = {
2451	...ctx,
2452	common: {
2453	...ctx.common,
2454	issues: []
2455	},
2456	parent: null
2457	};
2458	return {
2459	result: await option._parseAsync({
2460	data: ctx.data,
2461	path: ctx.path,
2462	parent: childCtx
2463	}),
2464	ctx: childCtx
2465	};
2466	})).then(handleResults);
2467	else {
2468	let dirty = void 0;
2469	const issues = [];
2470	for (const option of options) {
2471	const childCtx = {
2472	...ctx,
2473	common: {
2474	...ctx.common,
2475	issues: []
2476	},
2477	parent: null
2478	};
2479	const result = option._parseSync({
2480	data: ctx.data,
2481	path: ctx.path,
2482	parent: childCtx
2483	});
2484	if (result.status === "valid") return result;
2485	else if (result.status === "dirty" && !dirty) dirty = {
2486	result,
2487	ctx: childCtx
2488	};
2489	if (childCtx.common.issues.length) issues.push(childCtx.common.issues);
2490	}
2491	if (dirty) {
2492	ctx.common.issues.push(...dirty.ctx.common.issues);
2493	return dirty.result;
2494	}
2495	const unionErrors = issues.map((issues) => new ZodError$1(issues));
2496	addIssueToContext(ctx, {
2497	code: ZodIssueCode.invalid_union,
2498	unionErrors
2499	});
2500	return INVALID;
2501	}
2502	}
2503	get options() {
2504	return this._def.options;
2505	}
2506	};
2507	ZodUnion$1.create = (types, params) => {
2508	return new ZodUnion$1({
2509	options: types,
2510	typeName: ZodFirstPartyTypeKind.ZodUnion,
2511	...processCreateParams(params)
2512	});
2513	};
2514	var getDiscriminator = (type) => {
2515	if (type instanceof ZodLazy) return getDiscriminator(type.schema);
2516	else if (type instanceof ZodEffects) return getDiscriminator(type.innerType());
2517	else if (type instanceof ZodLiteral$1) return [type.value];
2518	else if (type instanceof ZodEnum$1) return type.options;
2519	else if (type instanceof ZodNativeEnum) return util.objectValues(type.enum);
2520	else if (type instanceof ZodDefault$1) return getDiscriminator(type._def.innerType);
2521	else if (type instanceof ZodUndefined) return [void 0];
2522	else if (type instanceof ZodNull$1) return [null];
2523	else if (type instanceof ZodOptional$1) return [void 0, ...getDiscriminator(type.unwrap())];
2524	else if (type instanceof ZodNullable$1) return [null, ...getDiscriminator(type.unwrap())];
2525	else if (type instanceof ZodBranded) return getDiscriminator(type.unwrap());
2526	else if (type instanceof ZodReadonly$1) return getDiscriminator(type.unwrap());
2527	else if (type instanceof ZodCatch$1) return getDiscriminator(type._def.innerType);
2528	else return [];
2529	};
2530	var ZodDiscriminatedUnion$1 = class ZodDiscriminatedUnion$1 extends ZodType$1 {
2531	static {
2532	__name(this, "ZodDiscriminatedUnion");
2533	}
2534	_parse(input) {
2535	const { ctx } = this._processInputParams(input);
2536	if (ctx.parsedType !== ZodParsedType.object) {
2537	addIssueToContext(ctx, {
2538	code: ZodIssueCode.invalid_type,
2539	expected: ZodParsedType.object,
2540	received: ctx.parsedType
2541	});
2542	return INVALID;
2543	}
2544	const discriminator = this.discriminator;
2545	const discriminatorValue = ctx.data[discriminator];
2546	const option = this.optionsMap.get(discriminatorValue);
2547	if (!option) {
2548	addIssueToContext(ctx, {
2549	code: ZodIssueCode.invalid_union_discriminator,
2550	options: Array.from(this.optionsMap.keys()),
2551	path: [discriminator]
2552	});
2553	return INVALID;
2554	}
2555	if (ctx.common.async) return option._parseAsync({
2556	data: ctx.data,
2557	path: ctx.path,
2558	parent: ctx
2559	});
2560	else return option._parseSync({
2561	data: ctx.data,
2562	path: ctx.path,
2563	parent: ctx
2564	});
2565	}
2566	get discriminator() {
2567	return this._def.discriminator;
2568	}
2569	get options() {
2570	return this._def.options;
2571	}
2572	get optionsMap() {
2573	return this._def.optionsMap;
2574	}
2575	/**
2576	* The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
2577	* However, it only allows a union of objects, all of which need to share a discriminator property. This property must
2578	* have a different value for each object in the union.
2579	* @param discriminator the name of the discriminator property
2580	* @param types an array of object schemas
2581	* @param params
2582	*/
2583	static create(discriminator, options, params) {
2584	const optionsMap = /* @__PURE__ */ new Map();
2585	for (const type of options) {
2586	const discriminatorValues = getDiscriminator(type.shape[discriminator]);
2587	if (!discriminatorValues.length) throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
2588	for (const value of discriminatorValues) {
2589	if (optionsMap.has(value)) throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
2590	optionsMap.set(value, type);
2591	}
2592	}
2593	return new ZodDiscriminatedUnion$1({
2594	typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
2595	discriminator,
2596	options,
2597	optionsMap,
2598	...processCreateParams(params)
2599	});
2600	}
2601	};
2602	function mergeValues$1(a, b) {
2603	const aType = getParsedType(a);
2604	const bType = getParsedType(b);
2605	if (a === b) return {
2606	valid: true,
2607	data: a
2608	};
2609	else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
2610	const bKeys = util.objectKeys(b);
2611	const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
2612	const newObj = {
2613	...a,
2614	...b
2615	};
2616	for (const key of sharedKeys) {
2617	const sharedValue = mergeValues$1(a[key], b[key]);
2618	if (!sharedValue.valid) return { valid: false };
2619	newObj[key] = sharedValue.data;
2620	}
2621	return {
2622	valid: true,
2623	data: newObj
2624	};
2625	} else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
2626	if (a.length !== b.length) return { valid: false };
2627	const newArray = [];
2628	for (let index = 0; index < a.length; index++) {
2629	const itemA = a[index];
2630	const itemB = b[index];
2631	const sharedValue = mergeValues$1(itemA, itemB);
2632	if (!sharedValue.valid) return { valid: false };
2633	newArray.push(sharedValue.data);
2634	}
2635	return {
2636	valid: true,
2637	data: newArray
2638	};
2639	} else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) return {
2640	valid: true,
2641	data: a
2642	};
2643	else return { valid: false };
2644	}
2645	__name(mergeValues$1, "mergeValues");
2646	var ZodIntersection$1 = class extends ZodType$1 {
2647	static {
2648	__name(this, "ZodIntersection");
2649	}
2650	_parse(input) {
2651	const { status, ctx } = this._processInputParams(input);
2652	const handleParsed = (parsedLeft, parsedRight) => {
2653	if (isAborted(parsedLeft) \|\| isAborted(parsedRight)) return INVALID;
2654	const merged = mergeValues$1(parsedLeft.value, parsedRight.value);
2655	if (!merged.valid) {
2656	addIssueToContext(ctx, { code: ZodIssueCode.invalid_intersection_types });
2657	return INVALID;
2658	}
2659	if (isDirty(parsedLeft) \|\| isDirty(parsedRight)) status.dirty();
2660	return {
2661	status: status.value,
2662	value: merged.data
2663	};
2664	};
2665	if (ctx.common.async) return Promise.all([this._def.left._parseAsync({
2666	data: ctx.data,
2667	path: ctx.path,
2668	parent: ctx
2669	}), this._def.right._parseAsync({
2670	data: ctx.data,
2671	path: ctx.path,
2672	parent: ctx
2673	})]).then(([left, right]) => handleParsed(left, right));
2674	else return handleParsed(this._def.left._parseSync({
2675	data: ctx.data,
2676	path: ctx.path,
2677	parent: ctx
2678	}), this._def.right._parseSync({
2679	data: ctx.data,
2680	path: ctx.path,
2681	parent: ctx
2682	}));
2683	}
2684	};
2685	ZodIntersection$1.create = (left, right, params) => {
2686	return new ZodIntersection$1({
2687	left,
2688	right,
2689	typeName: ZodFirstPartyTypeKind.ZodIntersection,
2690	...processCreateParams(params)
2691	});
2692	};
2693	var ZodTuple = class ZodTuple extends ZodType$1 {
2694	_parse(input) {
2695	const { status, ctx } = this._processInputParams(input);
2696	if (ctx.parsedType !== ZodParsedType.array) {
2697	addIssueToContext(ctx, {
2698	code: ZodIssueCode.invalid_type,
2699	expected: ZodParsedType.array,
2700	received: ctx.parsedType
2701	});
2702	return INVALID;
2703	}
2704	if (ctx.data.length < this._def.items.length) {
2705	addIssueToContext(ctx, {
2706	code: ZodIssueCode.too_small,
2707	minimum: this._def.items.length,
2708	inclusive: true,
2709	exact: false,
2710	type: "array"
2711	});
2712	return INVALID;
2713	}
2714	if (!this._def.rest && ctx.data.length > this._def.items.length) {
2715	addIssueToContext(ctx, {
2716	code: ZodIssueCode.too_big,
2717	maximum: this._def.items.length,
2718	inclusive: true,
2719	exact: false,
2720	type: "array"
2721	});
2722	status.dirty();
2723	}
2724	const items = [...ctx.data].map((item, itemIndex) => {
2725	const schema = this._def.items[itemIndex] \|\| this._def.rest;
2726	if (!schema) return null;
2727	return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
2728	}).filter((x) => !!x);
2729	if (ctx.common.async) return Promise.all(items).then((results) => {
2730	return ParseStatus.mergeArray(status, results);
2731	});
2732	else return ParseStatus.mergeArray(status, items);
2733	}
2734	get items() {
2735	return this._def.items;
2736	}
2737	rest(rest) {
2738	return new ZodTuple({
2739	...this._def,
2740	rest
2741	});
2742	}
2743	};
2744	ZodTuple.create = (schemas, params) => {
2745	if (!Array.isArray(schemas)) throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
2746	return new ZodTuple({
2747	items: schemas,
2748	typeName: ZodFirstPartyTypeKind.ZodTuple,
2749	rest: null,
2750	...processCreateParams(params)
2751	});
2752	};
2753	var ZodRecord$1 = class ZodRecord$1 extends ZodType$1 {
2754	static {
2755	__name(this, "ZodRecord");
2756	}
2757	get keySchema() {
2758	return this._def.keyType;
2759	}
2760	get valueSchema() {
2761	return this._def.valueType;
2762	}
2763	_parse(input) {
2764	const { status, ctx } = this._processInputParams(input);
2765	if (ctx.parsedType !== ZodParsedType.object) {
2766	addIssueToContext(ctx, {
2767	code: ZodIssueCode.invalid_type,
2768	expected: ZodParsedType.object,
2769	received: ctx.parsedType
2770	});
2771	return INVALID;
2772	}
2773	const pairs = [];
2774	const keyType = this._def.keyType;
2775	const valueType = this._def.valueType;
2776	for (const key in ctx.data) pairs.push({
2777	key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
2778	value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
2779	alwaysSet: key in ctx.data
2780	});
2781	if (ctx.common.async) return ParseStatus.mergeObjectAsync(status, pairs);
2782	else return ParseStatus.mergeObjectSync(status, pairs);
2783	}
2784	get element() {
2785	return this._def.valueType;
2786	}
2787	static create(first, second, third) {
2788	if (second instanceof ZodType$1) return new ZodRecord$1({
2789	keyType: first,
2790	valueType: second,
2791	typeName: ZodFirstPartyTypeKind.ZodRecord,
2792	...processCreateParams(third)
2793	});
2794	return new ZodRecord$1({
2795	keyType: ZodString$1.create(),
2796	valueType: first,
2797	typeName: ZodFirstPartyTypeKind.ZodRecord,
2798	...processCreateParams(second)
2799	});
2800	}
2801	};
2802	var ZodMap = class extends ZodType$1 {
2803	get keySchema() {
2804	return this._def.keyType;
2805	}
2806	get valueSchema() {
2807	return this._def.valueType;
2808	}
2809	_parse(input) {
2810	const { status, ctx } = this._processInputParams(input);
2811	if (ctx.parsedType !== ZodParsedType.map) {
2812	addIssueToContext(ctx, {
2813	code: ZodIssueCode.invalid_type,
2814	expected: ZodParsedType.map,
2815	received: ctx.parsedType
2816	});
2817	return INVALID;
2818	}
2819	const keyType = this._def.keyType;
2820	const valueType = this._def.valueType;
2821	const pairs = [...ctx.data.entries()].map(([key, value], index) => {
2822	return {
2823	key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
2824	value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
2825	};
2826	});
2827	if (ctx.common.async) {
2828	const finalMap = /* @__PURE__ */ new Map();
2829	return Promise.resolve().then(async () => {
2830	for (const pair of pairs) {
2831	const key = await pair.key;
2832	const value = await pair.value;
2833	if (key.status === "aborted" \|\| value.status === "aborted") return INVALID;
2834	if (key.status === "dirty" \|\| value.status === "dirty") status.dirty();
2835	finalMap.set(key.value, value.value);
2836	}
2837	return {
2838	status: status.value,
2839	value: finalMap
2840	};
2841	});
2842	} else {
2843	const finalMap = /* @__PURE__ */ new Map();
2844	for (const pair of pairs) {
2845	const key = pair.key;
2846	const value = pair.value;
2847	if (key.status === "aborted" \|\| value.status === "aborted") return INVALID;
2848	if (key.status === "dirty" \|\| value.status === "dirty") status.dirty();
2849	finalMap.set(key.value, value.value);
2850	}
2851	return {
2852	status: status.value,
2853	value: finalMap
2854	};
2855	}
2856	}
2857	};
2858	ZodMap.create = (keyType, valueType, params) => {
2859	return new ZodMap({
2860	valueType,
2861	keyType,
2862	typeName: ZodFirstPartyTypeKind.ZodMap,
2863	...processCreateParams(params)
2864	});
2865	};
2866	var ZodSet = class ZodSet extends ZodType$1 {
2867	_parse(input) {
2868	const { status, ctx } = this._processInputParams(input);
2869	if (ctx.parsedType !== ZodParsedType.set) {
2870	addIssueToContext(ctx, {
2871	code: ZodIssueCode.invalid_type,
2872	expected: ZodParsedType.set,
2873	received: ctx.parsedType
2874	});
2875	return INVALID;
2876	}
2877	const def = this._def;
2878	if (def.minSize !== null) {
2879	if (ctx.data.size < def.minSize.value) {
2880	addIssueToContext(ctx, {
2881	code: ZodIssueCode.too_small,
2882	minimum: def.minSize.value,
2883	type: "set",
2884	inclusive: true,
2885	exact: false,
2886	message: def.minSize.message
2887	});
2888	status.dirty();
2889	}
2890	}
2891	if (def.maxSize !== null) {
2892	if (ctx.data.size > def.maxSize.value) {
2893	addIssueToContext(ctx, {
2894	code: ZodIssueCode.too_big,
2895	maximum: def.maxSize.value,
2896	type: "set",
2897	inclusive: true,
2898	exact: false,
2899	message: def.maxSize.message
2900	});
2901	status.dirty();
2902	}
2903	}
2904	const valueType = this._def.valueType;
2905	function finalizeSet(elements) {
2906	const parsedSet = /* @__PURE__ */ new Set();
2907	for (const element of elements) {
2908	if (element.status === "aborted") return INVALID;
2909	if (element.status === "dirty") status.dirty();
2910	parsedSet.add(element.value);
2911	}
2912	return {
2913	status: status.value,
2914	value: parsedSet
2915	};
2916	}
2917	const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
2918	if (ctx.common.async) return Promise.all(elements).then((elements) => finalizeSet(elements));
2919	else return finalizeSet(elements);
2920	}
2921	min(minSize, message) {
2922	return new ZodSet({
2923	...this._def,
2924	minSize: {
2925	value: minSize,
2926	message: errorUtil.toString(message)
2927	}
2928	});
2929	}
2930	max(maxSize, message) {
2931	return new ZodSet({
2932	...this._def,
2933	maxSize: {
2934	value: maxSize,
2935	message: errorUtil.toString(message)
2936	}
2937	});
2938	}
2939	size(size, message) {
2940	return this.min(size, message).max(size, message);
2941	}
2942	nonempty(message) {
2943	return this.min(1, message);
2944	}
2945	};
2946	ZodSet.create = (valueType, params) => {
2947	return new ZodSet({
2948	valueType,
2949	minSize: null,
2950	maxSize: null,
2951	typeName: ZodFirstPartyTypeKind.ZodSet,
2952	...processCreateParams(params)
2953	});
2954	};
2955	var ZodFunction = class ZodFunction extends ZodType$1 {
2956	constructor() {
2957	super(...arguments);
2958	this.validate = this.implement;
2959	}
2960	_parse(input) {
2961	const { ctx } = this._processInputParams(input);
2962	if (ctx.parsedType !== ZodParsedType.function) {
2963	addIssueToContext(ctx, {
2964	code: ZodIssueCode.invalid_type,
2965	expected: ZodParsedType.function,
2966	received: ctx.parsedType
2967	});
2968	return INVALID;
2969	}
2970	function makeArgsIssue(args, error) {
2971	return makeIssue({
2972	data: args,
2973	path: ctx.path,
2974	errorMaps: [
2975	ctx.common.contextualErrorMap,
2976	ctx.schemaErrorMap,
2977	getErrorMap(),
2978	errorMap
2979	].filter((x) => !!x),
2980	issueData: {
2981	code: ZodIssueCode.invalid_arguments,
2982	argumentsError: error
2983	}
2984	});
2985	}
2986	function makeReturnsIssue(returns, error) {
2987	return makeIssue({
2988	data: returns,
2989	path: ctx.path,
2990	errorMaps: [
2991	ctx.common.contextualErrorMap,
2992	ctx.schemaErrorMap,
2993	getErrorMap(),
2994	errorMap
2995	].filter((x) => !!x),
2996	issueData: {
2997	code: ZodIssueCode.invalid_return_type,
2998	returnTypeError: error
2999	}
3000	});
3001	}
3002	const params = { errorMap: ctx.common.contextualErrorMap };
3003	const fn = ctx.data;
3004	if (this._def.returns instanceof ZodPromise) {
3005	const me = this;
3006	return OK(async function(...args) {
3007	const error = new ZodError$1([]);
3008	const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
3009	error.addIssue(makeArgsIssue(args, e));
3010	throw error;
3011	});
3012	const result = await Reflect.apply(fn, this, parsedArgs);
3013	return await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
3014	error.addIssue(makeReturnsIssue(result, e));
3015	throw error;
3016	});
3017	});
3018	} else {
3019	const me = this;
3020	return OK(function(...args) {
3021	const parsedArgs = me._def.args.safeParse(args, params);
3022	if (!parsedArgs.success) throw new ZodError$1([makeArgsIssue(args, parsedArgs.error)]);
3023	const result = Reflect.apply(fn, this, parsedArgs.data);
3024	const parsedReturns = me._def.returns.safeParse(result, params);
3025	if (!parsedReturns.success) throw new ZodError$1([makeReturnsIssue(result, parsedReturns.error)]);
3026	return parsedReturns.data;
3027	});
3028	}
3029	}
3030	parameters() {
3031	return this._def.args;
3032	}
3033	returnType() {
3034	return this._def.returns;
3035	}
3036	args(...items) {
3037	return new ZodFunction({
3038	...this._def,
3039	args: ZodTuple.create(items).rest(ZodUnknown$1.create())
3040	});
3041	}
3042	returns(returnType) {
3043	return new ZodFunction({
3044	...this._def,
3045	returns: returnType
3046	});
3047	}
3048	implement(func) {
3049	return this.parse(func);
3050	}
3051	strictImplement(func) {
3052	return this.parse(func);
3053	}
3054	static create(args, returns, params) {
3055	return new ZodFunction({
3056	args: args ? args : ZodTuple.create([]).rest(ZodUnknown$1.create()),
3057	returns: returns \|\| ZodUnknown$1.create(),
3058	typeName: ZodFirstPartyTypeKind.ZodFunction,
3059	...processCreateParams(params)
3060	});
3061	}
3062	};
3063	var ZodLazy = class extends ZodType$1 {
3064	get schema() {
3065	return this._def.getter();
3066	}
3067	_parse(input) {
3068	const { ctx } = this._processInputParams(input);
3069	return this._def.getter()._parse({
3070	data: ctx.data,
3071	path: ctx.path,
3072	parent: ctx
3073	});
3074	}
3075	};
3076	ZodLazy.create = (getter, params) => {
3077	return new ZodLazy({
3078	getter,
3079	typeName: ZodFirstPartyTypeKind.ZodLazy,
3080	...processCreateParams(params)
3081	});
3082	};
3083	var ZodLiteral$1 = class extends ZodType$1 {
3084	static {
3085	__name(this, "ZodLiteral");
3086	}
3087	_parse(input) {
3088	if (input.data !== this._def.value) {
3089	const ctx = this._getOrReturnCtx(input);
3090	addIssueToContext(ctx, {
3091	received: ctx.data,
3092	code: ZodIssueCode.invalid_literal,
3093	expected: this._def.value
3094	});
3095	return INVALID;
3096	}
3097	return {
3098	status: "valid",
3099	value: input.data
3100	};
3101	}
3102	get value() {
3103	return this._def.value;
3104	}
3105	};
3106	ZodLiteral$1.create = (value, params) => {
3107	return new ZodLiteral$1({
3108	value,
3109	typeName: ZodFirstPartyTypeKind.ZodLiteral,
3110	...processCreateParams(params)
3111	});
3112	};
3113	function createZodEnum(values, params) {
3114	return new ZodEnum$1({
3115	values,
3116	typeName: ZodFirstPartyTypeKind.ZodEnum,
3117	...processCreateParams(params)
3118	});
3119	}
3120	var ZodEnum$1 = class ZodEnum$1 extends ZodType$1 {
3121	static {
3122	__name(this, "ZodEnum");
3123	}
3124	_parse(input) {
3125	if (typeof input.data !== "string") {
3126	const ctx = this._getOrReturnCtx(input);
3127	const expectedValues = this._def.values;
3128	addIssueToContext(ctx, {
3129	expected: util.joinValues(expectedValues),
3130	received: ctx.parsedType,
3131	code: ZodIssueCode.invalid_type
3132	});
3133	return INVALID;
3134	}
3135	if (!this._cache) this._cache = new Set(this._def.values);
3136	if (!this._cache.has(input.data)) {
3137	const ctx = this._getOrReturnCtx(input);
3138	const expectedValues = this._def.values;
3139	addIssueToContext(ctx, {
3140	received: ctx.data,
3141	code: ZodIssueCode.invalid_enum_value,
3142	options: expectedValues
3143	});
3144	return INVALID;
3145	}
3146	return OK(input.data);
3147	}
3148	get options() {
3149	return this._def.values;
3150	}
3151	get enum() {
3152	const enumValues = {};
3153	for (const val of this._def.values) enumValues[val] = val;
3154	return enumValues;
3155	}
3156	get Values() {
3157	const enumValues = {};
3158	for (const val of this._def.values) enumValues[val] = val;
3159	return enumValues;
3160	}
3161	get Enum() {
3162	const enumValues = {};
3163	for (const val of this._def.values) enumValues[val] = val;
3164	return enumValues;
3165	}
3166	extract(values, newDef = this._def) {
3167	return ZodEnum$1.create(values, {
3168	...this._def,
3169	...newDef
3170	});
3171	}
3172	exclude(values, newDef = this._def) {
3173	return ZodEnum$1.create(this.options.filter((opt) => !values.includes(opt)), {
3174	...this._def,
3175	...newDef
3176	});
3177	}
3178	};
3179	ZodEnum$1.create = createZodEnum;
3180	var ZodNativeEnum = class extends ZodType$1 {
3181	_parse(input) {
3182	const nativeEnumValues = util.getValidEnumValues(this._def.values);
3183	const ctx = this._getOrReturnCtx(input);
3184	if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
3185	const expectedValues = util.objectValues(nativeEnumValues);
3186	addIssueToContext(ctx, {
3187	expected: util.joinValues(expectedValues),
3188	received: ctx.parsedType,
3189	code: ZodIssueCode.invalid_type
3190	});
3191	return INVALID;
3192	}
3193	if (!this._cache) this._cache = new Set(util.getValidEnumValues(this._def.values));
3194	if (!this._cache.has(input.data)) {
3195	const expectedValues = util.objectValues(nativeEnumValues);
3196	addIssueToContext(ctx, {
3197	received: ctx.data,
3198	code: ZodIssueCode.invalid_enum_value,
3199	options: expectedValues
3200	});
3201	return INVALID;
3202	}
3203	return OK(input.data);
3204	}
3205	get enum() {
3206	return this._def.values;
3207	}
3208	};
3209	ZodNativeEnum.create = (values, params) => {
3210	return new ZodNativeEnum({
3211	values,
3212	typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
3213	...processCreateParams(params)
3214	});
3215	};
3216	var ZodPromise = class extends ZodType$1 {
3217	unwrap() {
3218	return this._def.type;
3219	}
3220	_parse(input) {
3221	const { ctx } = this._processInputParams(input);
3222	if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
3223	addIssueToContext(ctx, {
3224	code: ZodIssueCode.invalid_type,
3225	expected: ZodParsedType.promise,
3226	received: ctx.parsedType
3227	});
3228	return INVALID;
3229	}
3230	return OK((ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data)).then((data) => {
3231	return this._def.type.parseAsync(data, {
3232	path: ctx.path,
3233	errorMap: ctx.common.contextualErrorMap
3234	});
3235	}));
3236	}
3237	};
3238	ZodPromise.create = (schema, params) => {
3239	return new ZodPromise({
3240	type: schema,
3241	typeName: ZodFirstPartyTypeKind.ZodPromise,
3242	...processCreateParams(params)
3243	});
3244	};
3245	var ZodEffects = class extends ZodType$1 {
3246	innerType() {
3247	return this._def.schema;
3248	}
3249	sourceType() {
3250	return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
3251	}
3252	_parse(input) {
3253	const { status, ctx } = this._processInputParams(input);
3254	const effect = this._def.effect \|\| null;
3255	const checkCtx = {
3256	addIssue: (arg) => {
3257	addIssueToContext(ctx, arg);
3258	if (arg.fatal) status.abort();
3259	else status.dirty();
3260	},
3261	get path() {
3262	return ctx.path;
3263	}
3264	};
3265	checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
3266	if (effect.type === "preprocess") {
3267	const processed = effect.transform(ctx.data, checkCtx);
3268	if (ctx.common.async) return Promise.resolve(processed).then(async (processed) => {
3269	if (status.value === "aborted") return INVALID;
3270	const result = await this._def.schema._parseAsync({
3271	data: processed,
3272	path: ctx.path,
3273	parent: ctx
3274	});
3275	if (result.status === "aborted") return INVALID;
3276	if (result.status === "dirty") return DIRTY(result.value);
3277	if (status.value === "dirty") return DIRTY(result.value);
3278	return result;
3279	});
3280	else {
3281	if (status.value === "aborted") return INVALID;
3282	const result = this._def.schema._parseSync({
3283	data: processed,
3284	path: ctx.path,
3285	parent: ctx
3286	});
3287	if (result.status === "aborted") return INVALID;
3288	if (result.status === "dirty") return DIRTY(result.value);
3289	if (status.value === "dirty") return DIRTY(result.value);
3290	return result;
3291	}
3292	}
3293	if (effect.type === "refinement") {
3294	const executeRefinement = (acc) => {
3295	const result = effect.refinement(acc, checkCtx);
3296	if (ctx.common.async) return Promise.resolve(result);
3297	if (result instanceof Promise) throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
3298	return acc;
3299	};
3300	if (ctx.common.async === false) {
3301	const inner = this._def.schema._parseSync({
3302	data: ctx.data,
3303	path: ctx.path,
3304	parent: ctx
3305	});
3306	if (inner.status === "aborted") return INVALID;
3307	if (inner.status === "dirty") status.dirty();
3308	executeRefinement(inner.value);
3309	return {
3310	status: status.value,
3311	value: inner.value
3312	};
3313	} else return this._def.schema._parseAsync({
3314	data: ctx.data,
3315	path: ctx.path,
3316	parent: ctx
3317	}).then((inner) => {
3318	if (inner.status === "aborted") return INVALID;
3319	if (inner.status === "dirty") status.dirty();
3320	return executeRefinement(inner.value).then(() => {
3321	return {
3322	status: status.value,
3323	value: inner.value
3324	};
3325	});
3326	});
3327	}
3328	if (effect.type === "transform") if (ctx.common.async === false) {
3329	const base = this._def.schema._parseSync({
3330	data: ctx.data,
3331	path: ctx.path,
3332	parent: ctx
3333	});
3334	if (!isValid(base)) return INVALID;
3335	const result = effect.transform(base.value, checkCtx);
3336	if (result instanceof Promise) throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
3337	return {
3338	status: status.value,
3339	value: result
3340	};
3341	} else return this._def.schema._parseAsync({
3342	data: ctx.data,
3343	path: ctx.path,
3344	parent: ctx
3345	}).then((base) => {
3346	if (!isValid(base)) return INVALID;
3347	return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
3348	status: status.value,
3349	value: result
3350	}));
3351	});
3352	util.assertNever(effect);
3353	}
3354	};
3355	ZodEffects.create = (schema, effect, params) => {
3356	return new ZodEffects({
3357	schema,
3358	typeName: ZodFirstPartyTypeKind.ZodEffects,
3359	effect,
3360	...processCreateParams(params)
3361	});
3362	};
3363	ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
3364	return new ZodEffects({
3365	schema,
3366	effect: {
3367	type: "preprocess",
3368	transform: preprocess
3369	},
3370	typeName: ZodFirstPartyTypeKind.ZodEffects,
3371	...processCreateParams(params)
3372	});
3373	};
3374	var ZodOptional$1 = class extends ZodType$1 {
3375	static {
3376	__name(this, "ZodOptional");
3377	}
3378	_parse(input) {
3379	if (this._getType(input) === ZodParsedType.undefined) return OK(void 0);
3380	return this._def.innerType._parse(input);
3381	}
3382	unwrap() {
3383	return this._def.innerType;
3384	}
3385	};
3386	ZodOptional$1.create = (type, params) => {
3387	return new ZodOptional$1({
3388	innerType: type,
3389	typeName: ZodFirstPartyTypeKind.ZodOptional,
3390	...processCreateParams(params)
3391	});
3392	};
3393	var ZodNullable$1 = class extends ZodType$1 {
3394	static {
3395	__name(this, "ZodNullable");
3396	}
3397	_parse(input) {
3398	if (this._getType(input) === ZodParsedType.null) return OK(null);
3399	return this._def.innerType._parse(input);
3400	}
3401	unwrap() {
3402	return this._def.innerType;
3403	}
3404	};
3405	ZodNullable$1.create = (type, params) => {
3406	return new ZodNullable$1({
3407	innerType: type,
3408	typeName: ZodFirstPartyTypeKind.ZodNullable,
3409	...processCreateParams(params)
3410	});
3411	};
3412	var ZodDefault$1 = class extends ZodType$1 {
3413	static {
3414	__name(this, "ZodDefault");
3415	}
3416	_parse(input) {
3417	const { ctx } = this._processInputParams(input);
3418	let data = ctx.data;
3419	if (ctx.parsedType === ZodParsedType.undefined) data = this._def.defaultValue();
3420	return this._def.innerType._parse({
3421	data,
3422	path: ctx.path,
3423	parent: ctx
3424	});
3425	}
3426	removeDefault() {
3427	return this._def.innerType;
3428	}
3429	};
3430	ZodDefault$1.create = (type, params) => {
3431	return new ZodDefault$1({
3432	innerType: type,
3433	typeName: ZodFirstPartyTypeKind.ZodDefault,
3434	defaultValue: typeof params.default === "function" ? params.default : () => params.default,
3435	...processCreateParams(params)
3436	});
3437	};
3438	var ZodCatch$1 = class extends ZodType$1 {
3439	static {
3440	__name(this, "ZodCatch");
3441	}
3442	_parse(input) {
3443	const { ctx } = this._processInputParams(input);
3444	const newCtx = {
3445	...ctx,
3446	common: {
3447	...ctx.common,
3448	issues: []
3449	}
3450	};
3451	const result = this._def.innerType._parse({
3452	data: newCtx.data,
3453	path: newCtx.path,
3454	parent: { ...newCtx }
3455	});
3456	if (isAsync(result)) return result.then((result) => {
3457	return {
3458	status: "valid",
3459	value: result.status === "valid" ? result.value : this._def.catchValue({
3460	get error() {
3461	return new ZodError$1(newCtx.common.issues);
3462	},
3463	input: newCtx.data
3464	})
3465	};
3466	});
3467	else return {
3468	status: "valid",
3469	value: result.status === "valid" ? result.value : this._def.catchValue({
3470	get error() {
3471	return new ZodError$1(newCtx.common.issues);
3472	},
3473	input: newCtx.data
3474	})
3475	};
3476	}
3477	removeCatch() {
3478	return this._def.innerType;
3479	}
3480	};
3481	ZodCatch$1.create = (type, params) => {
3482	return new ZodCatch$1({
3483	innerType: type,
3484	typeName: ZodFirstPartyTypeKind.ZodCatch,
3485	catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
3486	...processCreateParams(params)
3487	});
3488	};
3489	var ZodNaN = class extends ZodType$1 {
3490	_parse(input) {
3491	if (this._getType(input) !== ZodParsedType.nan) {
3492	const ctx = this._getOrReturnCtx(input);
3493	addIssueToContext(ctx, {
3494	code: ZodIssueCode.invalid_type,
3495	expected: ZodParsedType.nan,
3496	received: ctx.parsedType
3497	});
3498	return INVALID;
3499	}
3500	return {
3501	status: "valid",
3502	value: input.data
3503	};
3504	}
3505	};
3506	ZodNaN.create = (params) => {
3507	return new ZodNaN({
3508	typeName: ZodFirstPartyTypeKind.ZodNaN,
3509	...processCreateParams(params)
3510	});
3511	};
3512	var ZodBranded = class extends ZodType$1 {
3513	_parse(input) {
3514	const { ctx } = this._processInputParams(input);
3515	const data = ctx.data;
3516	return this._def.type._parse({
3517	data,
3518	path: ctx.path,
3519	parent: ctx
3520	});
3521	}
3522	unwrap() {
3523	return this._def.type;
3524	}
3525	};
3526	var ZodPipeline = class ZodPipeline extends ZodType$1 {
3527	_parse(input) {
3528	const { status, ctx } = this._processInputParams(input);
3529	if (ctx.common.async) {
3530	const handleAsync = async () => {
3531	const inResult = await this._def.in._parseAsync({
3532	data: ctx.data,
3533	path: ctx.path,
3534	parent: ctx
3535	});
3536	if (inResult.status === "aborted") return INVALID;
3537	if (inResult.status === "dirty") {
3538	status.dirty();
3539	return DIRTY(inResult.value);
3540	} else return this._def.out._parseAsync({
3541	data: inResult.value,
3542	path: ctx.path,
3543	parent: ctx
3544	});
3545	};
3546	return handleAsync();
3547	} else {
3548	const inResult = this._def.in._parseSync({
3549	data: ctx.data,
3550	path: ctx.path,
3551	parent: ctx
3552	});
3553	if (inResult.status === "aborted") return INVALID;
3554	if (inResult.status === "dirty") {
3555	status.dirty();
3556	return {
3557	status: "dirty",
3558	value: inResult.value
3559	};
3560	} else return this._def.out._parseSync({
3561	data: inResult.value,
3562	path: ctx.path,
3563	parent: ctx
3564	});
3565	}
3566	}
3567	static create(a, b) {
3568	return new ZodPipeline({
3569	in: a,
3570	out: b,
3571	typeName: ZodFirstPartyTypeKind.ZodPipeline
3572	});
3573	}
3574	};
3575	var ZodReadonly$1 = class extends ZodType$1 {
3576	static {
3577	__name(this, "ZodReadonly");
3578	}
3579	_parse(input) {
3580	const result = this._def.innerType._parse(input);
3581	const freeze = (data) => {
3582	if (isValid(data)) data.value = Object.freeze(data.value);
3583	return data;
3584	};
3585	return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
3586	}
3587	unwrap() {
3588	return this._def.innerType;
3589	}
3590	};
3591	ZodReadonly$1.create = (type, params) => {
3592	return new ZodReadonly$1({
3593	innerType: type,
3594	typeName: ZodFirstPartyTypeKind.ZodReadonly,
3595	...processCreateParams(params)
3596	});
3597	};
3598	var late = { object: ZodObject$1.lazycreate };
3599	var ZodFirstPartyTypeKind;
3600	(function(ZodFirstPartyTypeKind) {
3601	ZodFirstPartyTypeKind["ZodString"] = "ZodString";
3602	ZodFirstPartyTypeKind["ZodNumber"] = "ZodNumber";
3603	ZodFirstPartyTypeKind["ZodNaN"] = "ZodNaN";
3604	ZodFirstPartyTypeKind["ZodBigInt"] = "ZodBigInt";
3605	ZodFirstPartyTypeKind["ZodBoolean"] = "ZodBoolean";
3606	ZodFirstPartyTypeKind["ZodDate"] = "ZodDate";
3607	ZodFirstPartyTypeKind["ZodSymbol"] = "ZodSymbol";
3608	ZodFirstPartyTypeKind["ZodUndefined"] = "ZodUndefined";
3609	ZodFirstPartyTypeKind["ZodNull"] = "ZodNull";
3610	ZodFirstPartyTypeKind["ZodAny"] = "ZodAny";
3611	ZodFirstPartyTypeKind["ZodUnknown"] = "ZodUnknown";
3612	ZodFirstPartyTypeKind["ZodNever"] = "ZodNever";
3613	ZodFirstPartyTypeKind["ZodVoid"] = "ZodVoid";
3614	ZodFirstPartyTypeKind["ZodArray"] = "ZodArray";
3615	ZodFirstPartyTypeKind["ZodObject"] = "ZodObject";
3616	ZodFirstPartyTypeKind["ZodUnion"] = "ZodUnion";
3617	ZodFirstPartyTypeKind["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
3618	ZodFirstPartyTypeKind["ZodIntersection"] = "ZodIntersection";
3619	ZodFirstPartyTypeKind["ZodTuple"] = "ZodTuple";
3620	ZodFirstPartyTypeKind["ZodRecord"] = "ZodRecord";
3621	ZodFirstPartyTypeKind["ZodMap"] = "ZodMap";
3622	ZodFirstPartyTypeKind["ZodSet"] = "ZodSet";
3623	ZodFirstPartyTypeKind["ZodFunction"] = "ZodFunction";
3624	ZodFirstPartyTypeKind["ZodLazy"] = "ZodLazy";
3625	ZodFirstPartyTypeKind["ZodLiteral"] = "ZodLiteral";
3626	ZodFirstPartyTypeKind["ZodEnum"] = "ZodEnum";
3627	ZodFirstPartyTypeKind["ZodEffects"] = "ZodEffects";
3628	ZodFirstPartyTypeKind["ZodNativeEnum"] = "ZodNativeEnum";
3629	ZodFirstPartyTypeKind["ZodOptional"] = "ZodOptional";
3630	ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable";
3631	ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
3632	ZodFirstPartyTypeKind["ZodCatch"] = "ZodCatch";
3633	ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
3634	ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
3635	ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline";
3636	ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
3637	})(ZodFirstPartyTypeKind \|\| (ZodFirstPartyTypeKind = {}));
3638	var stringType = ZodString$1.create;
3639	var numberType = ZodNumber$1.create;
3640	var nanType = ZodNaN.create;
3641	var bigIntType = ZodBigInt.create;
3642	var booleanType = ZodBoolean$1.create;
3643	var dateType = ZodDate.create;
3644	var symbolType = ZodSymbol.create;
3645	var undefinedType = ZodUndefined.create;
3646	var nullType = ZodNull$1.create;
3647	var anyType = ZodAny.create;
3648	var unknownType = ZodUnknown$1.create;
3649	var neverType = ZodNever$1.create;
3650	var voidType = ZodVoid.create;
3651	var arrayType = ZodArray$1.create;
3652	var objectType = ZodObject$1.create;
3653	var strictObjectType = ZodObject$1.strictCreate;
3654	var unionType = ZodUnion$1.create;
3655	var discriminatedUnionType = ZodDiscriminatedUnion$1.create;
3656	var intersectionType = ZodIntersection$1.create;
3657	var tupleType = ZodTuple.create;
3658	var recordType = ZodRecord$1.create;
3659	var mapType = ZodMap.create;
3660	var setType = ZodSet.create;
3661	var functionType = ZodFunction.create;
3662	var lazyType = ZodLazy.create;
3663	var literalType = ZodLiteral$1.create;
3664	var enumType = ZodEnum$1.create;
3665	var nativeEnumType = ZodNativeEnum.create;
3666	var promiseType = ZodPromise.create;
3667	var effectsType = ZodEffects.create;
3668	var optionalType = ZodOptional$1.create;
3669	var nullableType = ZodNullable$1.create;
3670	var preprocessType = ZodEffects.createWithPreprocess;
3671	var pipelineType = ZodPipeline.create;
3672
3673	//#endregion
3674	//#region node_modules/zod/v4/core/core.js
3675	/** A special constant with type `never` */
3676	var NEVER = Object.freeze({ status: "aborted" });
3677	function $constructor(name, initializer, params) {
3678	function init(inst, def) {
3679	var _a;
3680	Object.defineProperty(inst, "_zod", {
3681	value: inst._zod ?? {},
3682	enumerable: false
3683	});
3684	(_a = inst._zod).traits ?? (_a.traits = /* @__PURE__ */ new Set());
3685	inst._zod.traits.add(name);
3686	initializer(inst, def);
3687	for (const k in _.prototype) if (!(k in inst)) Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
3688	inst._zod.constr = _;
3689	inst._zod.def = def;
3690	}
3691	const Parent = params?.Parent ?? Object;
3692	class Definition extends Parent {}
3693	Object.defineProperty(Definition, "name", { value: name });
3694	function _(def) {
3695	var _a;
3696	const inst = params?.Parent ? new Definition() : this;
3697	init(inst, def);
3698	(_a = inst._zod).deferred ?? (_a.deferred = []);
3699	for (const fn of inst._zod.deferred) fn();
3700	return inst;
3701	}
3702	Object.defineProperty(_, "init", { value: init });
3703	Object.defineProperty(_, Symbol.hasInstance, { value: (inst) => {
3704	if (params?.Parent && inst instanceof params.Parent) return true;
3705	return inst?._zod?.traits?.has(name);
3706	} });
3707	Object.defineProperty(_, "name", { value: name });
3708	return _;
3709	}
3710	var $ZodAsyncError = class extends Error {
3711	constructor() {
3712	super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
3713	}
3714	};
3715	var globalConfig = {};
3716	function config(newConfig) {
3717	if (newConfig) Object.assign(globalConfig, newConfig);
3718	return globalConfig;
3719	}
3720
3721	//#endregion
3722	//#region node_modules/zod/v4/core/util.js
3723	function getEnumValues(entries) {
3724	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
3725	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
3726	}
3727	function jsonStringifyReplacer(_, value) {
3728	if (typeof value === "bigint") return value.toString();
3729	return value;
3730	}
3731	function cached(getter) {
3732	return { get value() {
3733	{
3734	const value = getter();
3735	Object.defineProperty(this, "value", { value });
3736	return value;
3737	}
3738	} };
3739	}
3740	function nullish(input) {
3741	return input === null \|\| input === void 0;
3742	}
3743	function cleanRegex(source) {
3744	const start = source.startsWith("^") ? 1 : 0;
3745	const end = source.endsWith("$") ? source.length - 1 : source.length;
3746	return source.slice(start, end);
3747	}
3748	function floatSafeRemainder(val, step) {
3749	const valDecCount = (val.toString().split(".")[1] \|\| "").length;
3750	const stepDecCount = (step.toString().split(".")[1] \|\| "").length;
3751	const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
3752	return Number.parseInt(val.toFixed(decCount).replace(".", "")) % Number.parseInt(step.toFixed(decCount).replace(".", "")) / 10 ** decCount;
3753	}
3754	function defineLazy(object, key, getter) {
3755	Object.defineProperty(object, key, {
3756	get() {
3757	{
3758	const value = getter();
3759	object[key] = value;
3760	return value;
3761	}
3762	},
3763	set(v) {
3764	Object.defineProperty(object, key, { value: v });
3765	},
3766	configurable: true
3767	});
3768	}
3769	function assignProp(target, prop, value) {
3770	Object.defineProperty(target, prop, {
3771	value,
3772	writable: true,
3773	enumerable: true,
3774	configurable: true
3775	});
3776	}
3777	function esc(str) {
3778	return JSON.stringify(str);
3779	}
3780	var captureStackTrace = Error.captureStackTrace ? Error.captureStackTrace : (..._args) => {};
3781	function isObject(data) {
3782	return typeof data === "object" && data !== null && !Array.isArray(data);
3783	}
3784	var allowsEval = cached(() => {
3785	if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) return false;
3786	try {
3787	new Function("");
3788	return true;
3789	} catch (_) {
3790	return false;
3791	}
3792	});
3793	function isPlainObject$1(o) {
3794	if (isObject(o) === false) return false;
3795	const ctor = o.constructor;
3796	if (ctor === void 0) return true;
3797	const prot = ctor.prototype;
3798	if (isObject(prot) === false) return false;
3799	if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
3800	return true;
3801	}
3802	__name(isPlainObject$1, "isPlainObject");
3803	var propertyKeyTypes = /* @__PURE__ */ new Set([
3804	"string",
3805	"number",
3806	"symbol"
3807	]);
3808	function escapeRegex(str) {
3809	return str.replace(/[.*+?^${}()\|[\]\\]/g, "\\$&");
3810	}
3811	function clone(inst, def, params) {
3812	const cl = new inst._zod.constr(def ?? inst._zod.def);
3813	if (!def \|\| params?.parent) cl._zod.parent = inst;
3814	return cl;
3815	}
3816	function normalizeParams(_params) {
3817	const params = _params;
3818	if (!params) return {};
3819	if (typeof params === "string") return { error: () => params };
3820	if (params?.message !== void 0) {
3821	if (params?.error !== void 0) throw new Error("Cannot specify both `message` and `error` params");
3822	params.error = params.message;
3823	}
3824	delete params.message;
3825	if (typeof params.error === "string") return {
3826	...params,
3827	error: () => params.error
3828	};
3829	return params;
3830	}
3831	function optionalKeys(shape) {
3832	return Object.keys(shape).filter((k) => {
3833	return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
3834	});
3835	}
3836	var NUMBER_FORMAT_RANGES = {
3837	safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
3838	int32: [-2147483648, 2147483647],
3839	uint32: [0, 4294967295],
3840	float32: [-34028234663852886e22, 34028234663852886e22],
3841	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
3842	};
3843	function pick(schema, mask) {
3844	const newShape = {};
3845	const currDef = schema._zod.def;
3846	for (const key in mask) {
3847	if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
3848	if (!mask[key]) continue;
3849	newShape[key] = currDef.shape[key];
3850	}
3851	return clone(schema, {
3852	...schema._zod.def,
3853	shape: newShape,
3854	checks: []
3855	});
3856	}
3857	function omit(schema, mask) {
3858	const newShape = { ...schema._zod.def.shape };
3859	const currDef = schema._zod.def;
3860	for (const key in mask) {
3861	if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
3862	if (!mask[key]) continue;
3863	delete newShape[key];
3864	}
3865	return clone(schema, {
3866	...schema._zod.def,
3867	shape: newShape,
3868	checks: []
3869	});
3870	}
3871	function extend(schema, shape) {
3872	if (!isPlainObject$1(shape)) throw new Error("Invalid input to extend: expected a plain object");
3873	return clone(schema, {
3874	...schema._zod.def,
3875	get shape() {
3876	const _shape = {
3877	...schema._zod.def.shape,
3878	...shape
3879	};
3880	assignProp(this, "shape", _shape);
3881	return _shape;
3882	},
3883	checks: []
3884	});
3885	}
3886	function merge(a, b) {
3887	return clone(a, {
3888	...a._zod.def,
3889	get shape() {
3890	const _shape = {
3891	...a._zod.def.shape,
3892	...b._zod.def.shape
3893	};
3894	assignProp(this, "shape", _shape);
3895	return _shape;
3896	},
3897	catchall: b._zod.def.catchall,
3898	checks: []
3899	});
3900	}
3901	function partial(Class, schema, mask) {
3902	const oldShape = schema._zod.def.shape;
3903	const shape = { ...oldShape };
3904	if (mask) for (const key in mask) {
3905	if (!(key in oldShape)) throw new Error(`Unrecognized key: "${key}"`);
3906	if (!mask[key]) continue;
3907	shape[key] = Class ? new Class({
3908	type: "optional",
3909	innerType: oldShape[key]
3910	}) : oldShape[key];
3911	}
3912	else for (const key in oldShape) shape[key] = Class ? new Class({
3913	type: "optional",
3914	innerType: oldShape[key]
3915	}) : oldShape[key];
3916	return clone(schema, {
3917	...schema._zod.def,
3918	shape,
3919	checks: []
3920	});
3921	}
3922	function required$1(Class, schema, mask) {
3923	const oldShape = schema._zod.def.shape;
3924	const shape = { ...oldShape };
3925	if (mask) for (const key in mask) {
3926	if (!(key in shape)) throw new Error(`Unrecognized key: "${key}"`);
3927	if (!mask[key]) continue;
3928	shape[key] = new Class({
3929	type: "nonoptional",
3930	innerType: oldShape[key]
3931	});
3932	}
3933	else for (const key in oldShape) shape[key] = new Class({
3934	type: "nonoptional",
3935	innerType: oldShape[key]
3936	});
3937	return clone(schema, {
3938	...schema._zod.def,
3939	shape,
3940	checks: []
3941	});
3942	}
3943	__name(required$1, "required");
3944	function aborted(x, startIndex = 0) {
3945	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
3946	return false;
3947	}
3948	function prefixIssues(path, issues) {
3949	return issues.map((iss) => {
3950	var _a;
3951	(_a = iss).path ?? (_a.path = []);
3952	iss.path.unshift(path);
3953	return iss;
3954	});
3955	}
3956	function unwrapMessage(message) {
3957	return typeof message === "string" ? message : message?.message;
3958	}
3959	function finalizeIssue(iss, ctx, config) {
3960	const full = {
3961	...iss,
3962	path: iss.path ?? []
3963	};
3964	if (!iss.message) full.message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
3965	delete full.inst;
3966	delete full.continue;
3967	if (!ctx?.reportInput) delete full.input;
3968	return full;
3969	}
3970	function getLengthableOrigin(input) {
3971	if (Array.isArray(input)) return "array";
3972	if (typeof input === "string") return "string";
3973	return "unknown";
3974	}
3975	function issue(...args) {
3976	const [iss, input, inst] = args;
3977	if (typeof iss === "string") return {
3978	message: iss,
3979	code: "custom",
3980	input,
3981	inst
3982	};
3983	return { ...iss };
3984	}
3985
3986	//#endregion
3987	//#region node_modules/zod/v4/core/errors.js
3988	var initializer$1 = /* @__PURE__ */ __name((inst, def) => {
3989	inst.name = "$ZodError";
3990	Object.defineProperty(inst, "_zod", {
3991	value: inst._zod,
3992	enumerable: false
3993	});
3994	Object.defineProperty(inst, "issues", {
3995	value: def,
3996	enumerable: false
3997	});
3998	Object.defineProperty(inst, "message", {
3999	get() {
4000	return JSON.stringify(def, jsonStringifyReplacer, 2);
4001	},
4002	enumerable: true
4003	});
4004	Object.defineProperty(inst, "toString", {
4005	value: () => inst.message,
4006	enumerable: false
4007	});
4008	}, "initializer");
4009	var $ZodError = $constructor("$ZodError", initializer$1);
4010	var $ZodRealError = $constructor("$ZodError", initializer$1, { Parent: Error });
4011	function flattenError(error, mapper = (issue) => issue.message) {
4012	const fieldErrors = {};
4013	const formErrors = [];
4014	for (const sub of error.issues) if (sub.path.length > 0) {
4015	fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] \|\| [];
4016	fieldErrors[sub.path[0]].push(mapper(sub));
4017	} else formErrors.push(mapper(sub));
4018	return {
4019	formErrors,
4020	fieldErrors
4021	};
4022	}
4023	function formatError(error, _mapper) {
4024	const mapper = _mapper \|\| function(issue) {
4025	return issue.message;
4026	};
4027	const fieldErrors = { _errors: [] };
4028	const processError = (error) => {
4029	for (const issue of error.issues) if (issue.code === "invalid_union" && issue.errors.length) issue.errors.map((issues) => processError({ issues }));
4030	else if (issue.code === "invalid_key") processError({ issues: issue.issues });
4031	else if (issue.code === "invalid_element") processError({ issues: issue.issues });
4032	else if (issue.path.length === 0) fieldErrors._errors.push(mapper(issue));
4033	else {
4034	let curr = fieldErrors;
4035	let i = 0;
4036	while (i < issue.path.length) {
4037	const el = issue.path[i];
4038	if (!(i === issue.path.length - 1)) curr[el] = curr[el] \|\| { _errors: [] };
4039	else {
4040	curr[el] = curr[el] \|\| { _errors: [] };
4041	curr[el]._errors.push(mapper(issue));
4042	}
4043	curr = curr[el];
4044	i++;
4045	}
4046	}
4047	};
4048	processError(error);
4049	return fieldErrors;
4050	}
4051
4052	//#endregion
4053	//#region node_modules/zod/v4/core/parse.js
4054	var _parse = (_Err) => (schema, value, _ctx, _params) => {
4055	const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
4056	const result = schema._zod.run({
4057	value,
4058	issues: []
4059	}, ctx);
4060	if (result instanceof Promise) throw new $ZodAsyncError();
4061	if (result.issues.length) {
4062	const e = new ((_params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
4063	captureStackTrace(e, _params?.callee);
4064	throw e;
4065	}
4066	return result.value;
4067	};
4068	var parse$1 = /* @__PURE__*/ _parse($ZodRealError);
4069	var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
4070	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
4071	let result = schema._zod.run({
4072	value,
4073	issues: []
4074	}, ctx);
4075	if (result instanceof Promise) result = await result;
4076	if (result.issues.length) {
4077	const e = new ((params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
4078	captureStackTrace(e, params?.callee);
4079	throw e;
4080	}
4081	return result.value;
4082	};
4083	var parseAsync$1 = /* @__PURE__*/ _parseAsync($ZodRealError);
4084	var _safeParse = (_Err) => (schema, value, _ctx) => {
4085	const ctx = _ctx ? {
4086	..._ctx,
4087	async: false
4088	} : { async: false };
4089	const result = schema._zod.run({
4090	value,
4091	issues: []
4092	}, ctx);
4093	if (result instanceof Promise) throw new $ZodAsyncError();
4094	return result.issues.length ? {
4095	success: false,
4096	error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
4097	} : {
4098	success: true,
4099	data: result.value
4100	};
4101	};
4102	var safeParse$2 = /* @__PURE__*/ _safeParse($ZodRealError);
4103	var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
4104	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
4105	let result = schema._zod.run({
4106	value,
4107	issues: []
4108	}, ctx);
4109	if (result instanceof Promise) result = await result;
4110	return result.issues.length ? {
4111	success: false,
4112	error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
4113	} : {
4114	success: true,
4115	data: result.value
4116	};
4117	};
4118	var safeParseAsync$2 = /* @__PURE__*/ _safeParseAsync($ZodRealError);
4119
4120	//#endregion
4121	//#region node_modules/zod/v4/core/regexes.js
4122	var cuid = /^[cC][^\s-]{8,}$/;
4123	var cuid2 = /^[0-9a-z]+$/;
4124	var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
4125	var xid = /^[0-9a-vA-V]{20}$/;
4126	var ksuid = /^[A-Za-z0-9]{27}$/;
4127	var nanoid = /^[a-zA-Z0-9_-]{21}$/;
4128	/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
4129	var duration$1 = /^P(?:(\d+W)\|(?!.*W)(?=\d\|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
4130	/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
4131	var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
4132	/** Returns a regex for validating an RFC 4122 UUID.
4133	*
4134	* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
4135	var uuid = (version) => {
4136	if (!version) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\|00000000-0000-0000-0000-000000000000)$/;
4137	return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
4138	};
4139	/** Practical email validation */
4140	var email = /^(?!\.)(?!.\.\.)([A-Za-z0-9_'+\-\.])[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
4141	var _emoji$1 = `^(\\p{Extended_Pictographic}\|\\p{Emoji_Component})+$`;
4142	function emoji() {
4143	return new RegExp(_emoji$1, "u");
4144	}
4145	var ipv4 = /^(?:(?: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])$/;
4146	var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\|::\|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/;
4147	var cidrv4 = /^((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])\/([0-9]\|[1-2][0-9]\|3[0-2])$/;
4148	var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\|::\|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]\|1[01][0-9]\|[1-9]?[0-9])$/;
4149	var base64 = /^$\|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)\|(?:[0-9a-zA-Z+/]{3}=))?$/;
4150	var base64url = /^[A-Za-z0-9_-]*$/;
4151	var hostname = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
4152	var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
4153	var 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])))`;
4154	var date$1 = /@__PURE__/ new RegExp(`^${dateSource}$`);
4155	function timeSource(args) {
4156	const hhmm = `(?:[01]\\d\|2[0-3]):[0-5]\\d`;
4157	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+)?)?`;
4158	}
4159	function time$1(args) {
4160	return new RegExp(`^${timeSource(args)}$`);
4161	}
4162	__name(time$1, "time");
4163	function datetime$1(args) {
4164	const time = timeSource({ precision: args.precision });
4165	const opts = ["Z"];
4166	if (args.local) opts.push("");
4167	if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
4168	const timeRegex = `${time}(?:${opts.join("\|")})`;
4169	return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
4170	}
4171	__name(datetime$1, "datetime");
4172	var string$1 = /* @__PURE__ */ __name((params) => {
4173	const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
4174	return new RegExp(`^${regex}$`);
4175	}, "string");
4176	var integer = /^\d+$/;
4177	var number$1 = /^-?\d+(?:\.\d+)?/i;
4178	var boolean$1 = /true\|false/i;
4179	var _null$2 = /null/i;
4180	var lowercase = /^[^A-Z]*$/;
4181	var uppercase = /^[^a-z]*$/;
4182
4183	//#endregion
4184	//#region node_modules/zod/v4/core/checks.js
4185	var $ZodCheck = /@__PURE__/ $constructor("$ZodCheck", (inst, def) => {
4186	var _a;
4187	inst._zod ?? (inst._zod = {});
4188	inst._zod.def = def;
4189	(_a = inst._zod).onattach ?? (_a.onattach = []);
4190	});
4191	var numericOriginMap = {
4192	number: "number",
4193	bigint: "bigint",
4194	object: "date"
4195	};
4196	var $ZodCheckLessThan = /@__PURE__/ $constructor("$ZodCheckLessThan", (inst, def) => {
4197	$ZodCheck.init(inst, def);
4198	const origin = numericOriginMap[typeof def.value];
4199	inst._zod.onattach.push((inst) => {
4200	const bag = inst._zod.bag;
4201	const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
4202	if (def.value < curr) if (def.inclusive) bag.maximum = def.value;
4203	else bag.exclusiveMaximum = def.value;
4204	});
4205	inst._zod.check = (payload) => {
4206	if (def.inclusive ? payload.value <= def.value : payload.value < def.value) return;
4207	payload.issues.push({
4208	origin,
4209	code: "too_big",
4210	maximum: def.value,
4211	input: payload.value,
4212	inclusive: def.inclusive,
4213	inst,
4214	continue: !def.abort
4215	});
4216	};
4217	});
4218	var $ZodCheckGreaterThan = /@__PURE__/ $constructor("$ZodCheckGreaterThan", (inst, def) => {
4219	$ZodCheck.init(inst, def);
4220	const origin = numericOriginMap[typeof def.value];
4221	inst._zod.onattach.push((inst) => {
4222	const bag = inst._zod.bag;
4223	const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
4224	if (def.value > curr) if (def.inclusive) bag.minimum = def.value;
4225	else bag.exclusiveMinimum = def.value;
4226	});
4227	inst._zod.check = (payload) => {
4228	if (def.inclusive ? payload.value >= def.value : payload.value > def.value) return;
4229	payload.issues.push({
4230	origin,
4231	code: "too_small",
4232	minimum: def.value,
4233	input: payload.value,
4234	inclusive: def.inclusive,
4235	inst,
4236	continue: !def.abort
4237	});
4238	};
4239	});
4240	var $ZodCheckMultipleOf = /@__PURE__/ $constructor("$ZodCheckMultipleOf", (inst, def) => {
4241	$ZodCheck.init(inst, def);
4242	inst._zod.onattach.push((inst) => {
4243	var _a;
4244	(_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
4245	});
4246	inst._zod.check = (payload) => {
4247	if (typeof payload.value !== typeof def.value) throw new Error("Cannot mix number and bigint in multiple_of check.");
4248	if (typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0) return;
4249	payload.issues.push({
4250	origin: typeof payload.value,
4251	code: "not_multiple_of",
4252	divisor: def.value,
4253	input: payload.value,
4254	inst,
4255	continue: !def.abort
4256	});
4257	};
4258	});
4259	var $ZodCheckNumberFormat = /@__PURE__/ $constructor("$ZodCheckNumberFormat", (inst, def) => {
4260	$ZodCheck.init(inst, def);
4261	def.format = def.format \|\| "float64";
4262	const isInt = def.format?.includes("int");
4263	const origin = isInt ? "int" : "number";
4264	const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
4265	inst._zod.onattach.push((inst) => {
4266	const bag = inst._zod.bag;
4267	bag.format = def.format;
4268	bag.minimum = minimum;
4269	bag.maximum = maximum;
4270	if (isInt) bag.pattern = integer;
4271	});
4272	inst._zod.check = (payload) => {
4273	const input = payload.value;
4274	if (isInt) {
4275	if (!Number.isInteger(input)) {
4276	payload.issues.push({
4277	expected: origin,
4278	format: def.format,
4279	code: "invalid_type",
4280	input,
4281	inst
4282	});
4283	return;
4284	}
4285	if (!Number.isSafeInteger(input)) {
4286	if (input > 0) payload.issues.push({
4287	input,
4288	code: "too_big",
4289	maximum: Number.MAX_SAFE_INTEGER,
4290	note: "Integers must be within the safe integer range.",
4291	inst,
4292	origin,
4293	continue: !def.abort
4294	});
4295	else payload.issues.push({
4296	input,
4297	code: "too_small",
4298	minimum: Number.MIN_SAFE_INTEGER,
4299	note: "Integers must be within the safe integer range.",
4300	inst,
4301	origin,
4302	continue: !def.abort
4303	});
4304	return;
4305	}
4306	}
4307	if (input < minimum) payload.issues.push({
4308	origin: "number",
4309	input,
4310	code: "too_small",
4311	minimum,
4312	inclusive: true,
4313	inst,
4314	continue: !def.abort
4315	});
4316	if (input > maximum) payload.issues.push({
4317	origin: "number",
4318	input,
4319	code: "too_big",
4320	maximum,
4321	inst
4322	});
4323	};
4324	});
4325	var $ZodCheckMaxLength = /@__PURE__/ $constructor("$ZodCheckMaxLength", (inst, def) => {
4326	var _a;
4327	$ZodCheck.init(inst, def);
4328	(_a = inst._zod.def).when ?? (_a.when = (payload) => {
4329	const val = payload.value;
4330	return !nullish(val) && val.length !== void 0;
4331	});
4332	inst._zod.onattach.push((inst) => {
4333	const curr = inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
4334	if (def.maximum < curr) inst._zod.bag.maximum = def.maximum;
4335	});
4336	inst._zod.check = (payload) => {
4337	const input = payload.value;
4338	if (input.length <= def.maximum) return;
4339	const origin = getLengthableOrigin(input);
4340	payload.issues.push({
4341	origin,
4342	code: "too_big",
4343	maximum: def.maximum,
4344	inclusive: true,
4345	input,
4346	inst,
4347	continue: !def.abort
4348	});
4349	};
4350	});
4351	var $ZodCheckMinLength = /@__PURE__/ $constructor("$ZodCheckMinLength", (inst, def) => {
4352	var _a;
4353	$ZodCheck.init(inst, def);
4354	(_a = inst._zod.def).when ?? (_a.when = (payload) => {
4355	const val = payload.value;
4356	return !nullish(val) && val.length !== void 0;
4357	});
4358	inst._zod.onattach.push((inst) => {
4359	const curr = inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
4360	if (def.minimum > curr) inst._zod.bag.minimum = def.minimum;
4361	});
4362	inst._zod.check = (payload) => {
4363	const input = payload.value;
4364	if (input.length >= def.minimum) return;
4365	const origin = getLengthableOrigin(input);
4366	payload.issues.push({
4367	origin,
4368	code: "too_small",
4369	minimum: def.minimum,
4370	inclusive: true,
4371	input,
4372	inst,
4373	continue: !def.abort
4374	});
4375	};
4376	});
4377	var $ZodCheckLengthEquals = /@__PURE__/ $constructor("$ZodCheckLengthEquals", (inst, def) => {
4378	var _a;
4379	$ZodCheck.init(inst, def);
4380	(_a = inst._zod.def).when ?? (_a.when = (payload) => {
4381	const val = payload.value;
4382	return !nullish(val) && val.length !== void 0;
4383	});
4384	inst._zod.onattach.push((inst) => {
4385	const bag = inst._zod.bag;
4386	bag.minimum = def.length;
4387	bag.maximum = def.length;
4388	bag.length = def.length;
4389	});
4390	inst._zod.check = (payload) => {
4391	const input = payload.value;
4392	const length = input.length;
4393	if (length === def.length) return;
4394	const origin = getLengthableOrigin(input);
4395	const tooBig = length > def.length;
4396	payload.issues.push({
4397	origin,
4398	...tooBig ? {
4399	code: "too_big",
4400	maximum: def.length
4401	} : {
4402	code: "too_small",
4403	minimum: def.length
4404	},
4405	inclusive: true,
4406	exact: true,
4407	input: payload.value,
4408	inst,
4409	continue: !def.abort
4410	});
4411	};
4412	});
4413	var $ZodCheckStringFormat = /@__PURE__/ $constructor("$ZodCheckStringFormat", (inst, def) => {
4414	var _a;
4415	var _b;
4416	$ZodCheck.init(inst, def);
4417	inst._zod.onattach.push((inst) => {
4418	const bag = inst._zod.bag;
4419	bag.format = def.format;
4420	if (def.pattern) {
4421	bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
4422	bag.patterns.add(def.pattern);
4423	}
4424	});
4425	if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload) => {
4426	def.pattern.lastIndex = 0;
4427	if (def.pattern.test(payload.value)) return;
4428	payload.issues.push({
4429	origin: "string",
4430	code: "invalid_format",
4431	format: def.format,
4432	input: payload.value,
4433	...def.pattern ? { pattern: def.pattern.toString() } : {},
4434	inst,
4435	continue: !def.abort
4436	});
4437	});
4438	else (_b = inst._zod).check ?? (_b.check = () => {});
4439	});
4440	var $ZodCheckRegex = /@__PURE__/ $constructor("$ZodCheckRegex", (inst, def) => {
4441	$ZodCheckStringFormat.init(inst, def);
4442	inst._zod.check = (payload) => {
4443	def.pattern.lastIndex = 0;
4444	if (def.pattern.test(payload.value)) return;
4445	payload.issues.push({
4446	origin: "string",
4447	code: "invalid_format",
4448	format: "regex",
4449	input: payload.value,
4450	pattern: def.pattern.toString(),
4451	inst,
4452	continue: !def.abort
4453	});
4454	};
4455	});
4456	var $ZodCheckLowerCase = /@__PURE__/ $constructor("$ZodCheckLowerCase", (inst, def) => {
4457	def.pattern ?? (def.pattern = lowercase);
4458	$ZodCheckStringFormat.init(inst, def);
4459	});
4460	var $ZodCheckUpperCase = /@__PURE__/ $constructor("$ZodCheckUpperCase", (inst, def) => {
4461	def.pattern ?? (def.pattern = uppercase);
4462	$ZodCheckStringFormat.init(inst, def);
4463	});
4464	var $ZodCheckIncludes = /@__PURE__/ $constructor("$ZodCheckIncludes", (inst, def) => {
4465	$ZodCheck.init(inst, def);
4466	const escapedRegex = escapeRegex(def.includes);
4467	const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
4468	def.pattern = pattern;
4469	inst._zod.onattach.push((inst) => {
4470	const bag = inst._zod.bag;
4471	bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
4472	bag.patterns.add(pattern);
4473	});
4474	inst._zod.check = (payload) => {
4475	if (payload.value.includes(def.includes, def.position)) return;
4476	payload.issues.push({
4477	origin: "string",
4478	code: "invalid_format",
4479	format: "includes",
4480	includes: def.includes,
4481	input: payload.value,
4482	inst,
4483	continue: !def.abort
4484	});
4485	};
4486	});
4487	var $ZodCheckStartsWith = /@__PURE__/ $constructor("$ZodCheckStartsWith", (inst, def) => {
4488	$ZodCheck.init(inst, def);
4489	const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
4490	def.pattern ?? (def.pattern = pattern);
4491	inst._zod.onattach.push((inst) => {
4492	const bag = inst._zod.bag;
4493	bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
4494	bag.patterns.add(pattern);
4495	});
4496	inst._zod.check = (payload) => {
4497	if (payload.value.startsWith(def.prefix)) return;
4498	payload.issues.push({
4499	origin: "string",
4500	code: "invalid_format",
4501	format: "starts_with",
4502	prefix: def.prefix,
4503	input: payload.value,
4504	inst,
4505	continue: !def.abort
4506	});
4507	};
4508	});
4509	var $ZodCheckEndsWith = /@__PURE__/ $constructor("$ZodCheckEndsWith", (inst, def) => {
4510	$ZodCheck.init(inst, def);
4511	const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
4512	def.pattern ?? (def.pattern = pattern);
4513	inst._zod.onattach.push((inst) => {
4514	const bag = inst._zod.bag;
4515	bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
4516	bag.patterns.add(pattern);
4517	});
4518	inst._zod.check = (payload) => {
4519	if (payload.value.endsWith(def.suffix)) return;
4520	payload.issues.push({
4521	origin: "string",
4522	code: "invalid_format",
4523	format: "ends_with",
4524	suffix: def.suffix,
4525	input: payload.value,
4526	inst,
4527	continue: !def.abort
4528	});
4529	};
4530	});
4531	var $ZodCheckOverwrite = /@__PURE__/ $constructor("$ZodCheckOverwrite", (inst, def) => {
4532	$ZodCheck.init(inst, def);
4533	inst._zod.check = (payload) => {
4534	payload.value = def.tx(payload.value);
4535	};
4536	});
4537
4538	//#endregion
4539	//#region node_modules/zod/v4/core/doc.js
4540	var Doc = class {
4541	constructor(args = []) {
4542	this.content = [];
4543	this.indent = 0;
4544	if (this) this.args = args;
4545	}
4546	indented(fn) {
4547	this.indent += 1;
4548	fn(this);
4549	this.indent -= 1;
4550	}
4551	write(arg) {
4552	if (typeof arg === "function") {
4553	arg(this, { execution: "sync" });
4554	arg(this, { execution: "async" });
4555	return;
4556	}
4557	const lines = arg.split("\n").filter((x) => x);
4558	const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
4559	const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
4560	for (const line of dedented) this.content.push(line);
4561	}
4562	compile() {
4563	const F = Function;
4564	const args = this?.args;
4565	const lines = [...(this?.content ?? [``]).map((x) => ` ${x}`)];
4566	return new F(...args, lines.join("\n"));
4567	}
4568	};
4569
4570	//#endregion
4571	//#region node_modules/zod/v4/core/versions.js
4572	var version = {
4573	major: 4,
4574	minor: 0,
4575	patch: 0
4576	};
4577
4578	//#endregion
4579	//#region node_modules/zod/v4/core/schemas.js
4580	var $ZodType = /@__PURE__/ $constructor("$ZodType", (inst, def) => {
4581	var _a;
4582	inst ?? (inst = {});
4583	inst._zod.def = def;
4584	inst._zod.bag = inst._zod.bag \|\| {};
4585	inst._zod.version = version;
4586	const checks = [...inst._zod.def.checks ?? []];
4587	if (inst._zod.traits.has("$ZodCheck")) checks.unshift(inst);
4588	for (const ch of checks) for (const fn of ch._zod.onattach) fn(inst);
4589	if (checks.length === 0) {
4590	(_a = inst._zod).deferred ?? (_a.deferred = []);
4591	inst._zod.deferred?.push(() => {
4592	inst._zod.run = inst._zod.parse;
4593	});
4594	} else {
4595	const runChecks = (payload, checks, ctx) => {
4596	let isAborted = aborted(payload);
4597	let asyncResult;
4598	for (const ch of checks) {
4599	if (ch._zod.def.when) {
4600	if (!ch._zod.def.when(payload)) continue;
4601	} else if (isAborted) continue;
4602	const currLen = payload.issues.length;
4603	const _ = ch._zod.check(payload);
4604	if (_ instanceof Promise && ctx?.async === false) throw new $ZodAsyncError();
4605	if (asyncResult \|\| _ instanceof Promise) asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
4606	await _;
4607	if (payload.issues.length === currLen) return;
4608	if (!isAborted) isAborted = aborted(payload, currLen);
4609	});
4610	else {
4611	if (payload.issues.length === currLen) continue;
4612	if (!isAborted) isAborted = aborted(payload, currLen);
4613	}
4614	}
4615	if (asyncResult) return asyncResult.then(() => {
4616	return payload;
4617	});
4618	return payload;
4619	};
4620	inst._zod.run = (payload, ctx) => {
4621	const result = inst._zod.parse(payload, ctx);
4622	if (result instanceof Promise) {
4623	if (ctx.async === false) throw new $ZodAsyncError();
4624	return result.then((result) => runChecks(result, checks, ctx));
4625	}
4626	return runChecks(result, checks, ctx);
4627	};
4628	}
4629	inst["~standard"] = {
4630	validate: (value) => {
4631	try {
4632	const r = safeParse$2(inst, value);
4633	return r.success ? { value: r.data } : { issues: r.error?.issues };
4634	} catch (_) {
4635	return safeParseAsync$2(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
4636	}
4637	},
4638	vendor: "zod",
4639	version: 1
4640	};
4641	});
4642	var $ZodString = /@__PURE__/ $constructor("$ZodString", (inst, def) => {
4643	$ZodType.init(inst, def);
4644	inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string$1(inst._zod.bag);
4645	inst._zod.parse = (payload, _) => {
4646	if (def.coerce) try {
4647	payload.value = String(payload.value);
4648	} catch (_) {}
4649	if (typeof payload.value === "string") return payload;
4650	payload.issues.push({
4651	expected: "string",
4652	code: "invalid_type",
4653	input: payload.value,
4654	inst
4655	});
4656	return payload;
4657	};
4658	});
4659	var $ZodStringFormat = /@__PURE__/ $constructor("$ZodStringFormat", (inst, def) => {
4660	$ZodCheckStringFormat.init(inst, def);
4661	$ZodString.init(inst, def);
4662	});
4663	var $ZodGUID = /@__PURE__/ $constructor("$ZodGUID", (inst, def) => {
4664	def.pattern ?? (def.pattern = guid);
4665	$ZodStringFormat.init(inst, def);
4666	});
4667	var $ZodUUID = /@__PURE__/ $constructor("$ZodUUID", (inst, def) => {
4668	if (def.version) {
4669	const v = {
4670	v1: 1,
4671	v2: 2,
4672	v3: 3,
4673	v4: 4,
4674	v5: 5,
4675	v6: 6,
4676	v7: 7,
4677	v8: 8
4678	}[def.version];
4679	if (v === void 0) throw new Error(`Invalid UUID version: "${def.version}"`);
4680	def.pattern ?? (def.pattern = uuid(v));
4681	} else def.pattern ?? (def.pattern = uuid());
4682	$ZodStringFormat.init(inst, def);
4683	});
4684	var $ZodEmail = /@__PURE__/ $constructor("$ZodEmail", (inst, def) => {
4685	def.pattern ?? (def.pattern = email);
4686	$ZodStringFormat.init(inst, def);
4687	});
4688	var $ZodURL = /@__PURE__/ $constructor("$ZodURL", (inst, def) => {
4689	$ZodStringFormat.init(inst, def);
4690	inst._zod.check = (payload) => {
4691	try {
4692	const orig = payload.value;
4693	const url = new URL(orig);
4694	const href = url.href;
4695	if (def.hostname) {
4696	def.hostname.lastIndex = 0;
4697	if (!def.hostname.test(url.hostname)) payload.issues.push({
4698	code: "invalid_format",
4699	format: "url",
4700	note: "Invalid hostname",
4701	pattern: hostname.source,
4702	input: payload.value,
4703	inst,
4704	continue: !def.abort
4705	});
4706	}
4707	if (def.protocol) {
4708	def.protocol.lastIndex = 0;
4709	if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) payload.issues.push({
4710	code: "invalid_format",
4711	format: "url",
4712	note: "Invalid protocol",
4713	pattern: def.protocol.source,
4714	input: payload.value,
4715	inst,
4716	continue: !def.abort
4717	});
4718	}
4719	if (!orig.endsWith("/") && href.endsWith("/")) payload.value = href.slice(0, -1);
4720	else payload.value = href;
4721	return;
4722	} catch (_) {
4723	payload.issues.push({
4724	code: "invalid_format",
4725	format: "url",
4726	input: payload.value,
4727	inst,
4728	continue: !def.abort
4729	});
4730	}
4731	};
4732	});
4733	var $ZodEmoji = /@__PURE__/ $constructor("$ZodEmoji", (inst, def) => {
4734	def.pattern ?? (def.pattern = emoji());
4735	$ZodStringFormat.init(inst, def);
4736	});
4737	var $ZodNanoID = /@__PURE__/ $constructor("$ZodNanoID", (inst, def) => {
4738	def.pattern ?? (def.pattern = nanoid);
4739	$ZodStringFormat.init(inst, def);
4740	});
4741	var $ZodCUID = /@__PURE__/ $constructor("$ZodCUID", (inst, def) => {
4742	def.pattern ?? (def.pattern = cuid);
4743	$ZodStringFormat.init(inst, def);
4744	});
4745	var $ZodCUID2 = /@__PURE__/ $constructor("$ZodCUID2", (inst, def) => {
4746	def.pattern ?? (def.pattern = cuid2);
4747	$ZodStringFormat.init(inst, def);
4748	});
4749	var $ZodULID = /@__PURE__/ $constructor("$ZodULID", (inst, def) => {
4750	def.pattern ?? (def.pattern = ulid);
4751	$ZodStringFormat.init(inst, def);
4752	});
4753	var $ZodXID = /@__PURE__/ $constructor("$ZodXID", (inst, def) => {
4754	def.pattern ?? (def.pattern = xid);
4755	$ZodStringFormat.init(inst, def);
4756	});
4757	var $ZodKSUID = /@__PURE__/ $constructor("$ZodKSUID", (inst, def) => {
4758	def.pattern ?? (def.pattern = ksuid);
4759	$ZodStringFormat.init(inst, def);
4760	});
4761	var $ZodISODateTime = /@__PURE__/ $constructor("$ZodISODateTime", (inst, def) => {
4762	def.pattern ?? (def.pattern = datetime$1(def));
4763	$ZodStringFormat.init(inst, def);
4764	});
4765	var $ZodISODate = /@__PURE__/ $constructor("$ZodISODate", (inst, def) => {
4766	def.pattern ?? (def.pattern = date$1);
4767	$ZodStringFormat.init(inst, def);
4768	});
4769	var $ZodISOTime = /@__PURE__/ $constructor("$ZodISOTime", (inst, def) => {
4770	def.pattern ?? (def.pattern = time$1(def));
4771	$ZodStringFormat.init(inst, def);
4772	});
4773	var $ZodISODuration = /@__PURE__/ $constructor("$ZodISODuration", (inst, def) => {
4774	def.pattern ?? (def.pattern = duration$1);
4775	$ZodStringFormat.init(inst, def);
4776	});
4777	var $ZodIPv4 = /@__PURE__/ $constructor("$ZodIPv4", (inst, def) => {
4778	def.pattern ?? (def.pattern = ipv4);
4779	$ZodStringFormat.init(inst, def);
4780	inst._zod.onattach.push((inst) => {
4781	const bag = inst._zod.bag;
4782	bag.format = `ipv4`;
4783	});
4784	});
4785	var $ZodIPv6 = /@__PURE__/ $constructor("$ZodIPv6", (inst, def) => {
4786	def.pattern ?? (def.pattern = ipv6);
4787	$ZodStringFormat.init(inst, def);
4788	inst._zod.onattach.push((inst) => {
4789	const bag = inst._zod.bag;
4790	bag.format = `ipv6`;
4791	});
4792	inst._zod.check = (payload) => {
4793	try {
4794	new URL(`http://[${payload.value}]`);
4795	} catch {
4796	payload.issues.push({
4797	code: "invalid_format",
4798	format: "ipv6",
4799	input: payload.value,
4800	inst,
4801	continue: !def.abort
4802	});
4803	}
4804	};
4805	});
4806	var $ZodCIDRv4 = /@__PURE__/ $constructor("$ZodCIDRv4", (inst, def) => {
4807	def.pattern ?? (def.pattern = cidrv4);
4808	$ZodStringFormat.init(inst, def);
4809	});
4810	var $ZodCIDRv6 = /@__PURE__/ $constructor("$ZodCIDRv6", (inst, def) => {
4811	def.pattern ?? (def.pattern = cidrv6);
4812	$ZodStringFormat.init(inst, def);
4813	inst._zod.check = (payload) => {
4814	const [address, prefix] = payload.value.split("/");
4815	try {
4816	if (!prefix) throw new Error();
4817	const prefixNum = Number(prefix);
4818	if (`${prefixNum}` !== prefix) throw new Error();
4819	if (prefixNum < 0 \|\| prefixNum > 128) throw new Error();
4820	new URL(`http://[${address}]`);
4821	} catch {
4822	payload.issues.push({
4823	code: "invalid_format",
4824	format: "cidrv6",
4825	input: payload.value,
4826	inst,
4827	continue: !def.abort
4828	});
4829	}
4830	};
4831	});
4832	function isValidBase64(data) {
4833	if (data === "") return true;
4834	if (data.length % 4 !== 0) return false;
4835	try {
4836	atob(data);
4837	return true;
4838	} catch {
4839	return false;
4840	}
4841	}
4842	var $ZodBase64 = /@__PURE__/ $constructor("$ZodBase64", (inst, def) => {
4843	def.pattern ?? (def.pattern = base64);
4844	$ZodStringFormat.init(inst, def);
4845	inst._zod.onattach.push((inst) => {
4846	inst._zod.bag.contentEncoding = "base64";
4847	});
4848	inst._zod.check = (payload) => {
4849	if (isValidBase64(payload.value)) return;
4850	payload.issues.push({
4851	code: "invalid_format",
4852	format: "base64",
4853	input: payload.value,
4854	inst,
4855	continue: !def.abort
4856	});
4857	};
4858	});
4859	function isValidBase64URL(data) {
4860	if (!base64url.test(data)) return false;
4861	const base64 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
4862	return isValidBase64(base64.padEnd(Math.ceil(base64.length / 4) * 4, "="));
4863	}
4864	var $ZodBase64URL = /@__PURE__/ $constructor("$ZodBase64URL", (inst, def) => {
4865	def.pattern ?? (def.pattern = base64url);
4866	$ZodStringFormat.init(inst, def);
4867	inst._zod.onattach.push((inst) => {
4868	inst._zod.bag.contentEncoding = "base64url";
4869	});
4870	inst._zod.check = (payload) => {
4871	if (isValidBase64URL(payload.value)) return;
4872	payload.issues.push({
4873	code: "invalid_format",
4874	format: "base64url",
4875	input: payload.value,
4876	inst,
4877	continue: !def.abort
4878	});
4879	};
4880	});
4881	var $ZodE164 = /@__PURE__/ $constructor("$ZodE164", (inst, def) => {
4882	def.pattern ?? (def.pattern = e164);
4883	$ZodStringFormat.init(inst, def);
4884	});
4885	function isValidJWT(token, algorithm = null) {
4886	try {
4887	const tokensParts = token.split(".");
4888	if (tokensParts.length !== 3) return false;
4889	const [header] = tokensParts;
4890	if (!header) return false;
4891	const parsedHeader = JSON.parse(atob(header));
4892	if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
4893	if (!parsedHeader.alg) return false;
4894	if (algorithm && (!("alg" in parsedHeader) \|\| parsedHeader.alg !== algorithm)) return false;
4895	return true;
4896	} catch {
4897	return false;
4898	}
4899	}
4900	var $ZodJWT = /@__PURE__/ $constructor("$ZodJWT", (inst, def) => {
4901	$ZodStringFormat.init(inst, def);
4902	inst._zod.check = (payload) => {
4903	if (isValidJWT(payload.value, def.alg)) return;
4904	payload.issues.push({
4905	code: "invalid_format",
4906	format: "jwt",
4907	input: payload.value,
4908	inst,
4909	continue: !def.abort
4910	});
4911	};
4912	});
4913	var $ZodNumber = /@__PURE__/ $constructor("$ZodNumber", (inst, def) => {
4914	$ZodType.init(inst, def);
4915	inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
4916	inst._zod.parse = (payload, _ctx) => {
4917	if (def.coerce) try {
4918	payload.value = Number(payload.value);
4919	} catch (_) {}
4920	const input = payload.value;
4921	if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) return payload;
4922	const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
4923	payload.issues.push({
4924	expected: "number",
4925	code: "invalid_type",
4926	input,
4927	inst,
4928	...received ? { received } : {}
4929	});
4930	return payload;
4931	};
4932	});
4933	var $ZodNumberFormat = /@__PURE__/ $constructor("$ZodNumber", (inst, def) => {
4934	$ZodCheckNumberFormat.init(inst, def);
4935	$ZodNumber.init(inst, def);
4936	});
4937	var $ZodBoolean = /@__PURE__/ $constructor("$ZodBoolean", (inst, def) => {
4938	$ZodType.init(inst, def);
4939	inst._zod.pattern = boolean$1;
4940	inst._zod.parse = (payload, _ctx) => {
4941	if (def.coerce) try {
4942	payload.value = Boolean(payload.value);
4943	} catch (_) {}
4944	const input = payload.value;
4945	if (typeof input === "boolean") return payload;
4946	payload.issues.push({
4947	expected: "boolean",
4948	code: "invalid_type",
4949	input,
4950	inst
4951	});
4952	return payload;
4953	};
4954	});
4955	var $ZodNull = /@__PURE__/ $constructor("$ZodNull", (inst, def) => {
4956	$ZodType.init(inst, def);
4957	inst._zod.pattern = _null$2;
4958	inst._zod.values = /* @__PURE__ */ new Set([null]);
4959	inst._zod.parse = (payload, _ctx) => {
4960	const input = payload.value;
4961	if (input === null) return payload;
4962	payload.issues.push({
4963	expected: "null",
4964	code: "invalid_type",
4965	input,
4966	inst
4967	});
4968	return payload;
4969	};
4970	});
4971	var $ZodUnknown = /@__PURE__/ $constructor("$ZodUnknown", (inst, def) => {
4972	$ZodType.init(inst, def);
4973	inst._zod.parse = (payload) => payload;
4974	});
4975	var $ZodNever = /@__PURE__/ $constructor("$ZodNever", (inst, def) => {
4976	$ZodType.init(inst, def);
4977	inst._zod.parse = (payload, _ctx) => {
4978	payload.issues.push({
4979	expected: "never",
4980	code: "invalid_type",
4981	input: payload.value,
4982	inst
4983	});
4984	return payload;
4985	};
4986	});
4987	function handleArrayResult(result, final, index) {
4988	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
4989	final.value[index] = result.value;
4990	}
4991	var $ZodArray = /@__PURE__/ $constructor("$ZodArray", (inst, def) => {
4992	$ZodType.init(inst, def);
4993	inst._zod.parse = (payload, ctx) => {
4994	const input = payload.value;
4995	if (!Array.isArray(input)) {
4996	payload.issues.push({
4997	expected: "array",
4998	code: "invalid_type",
4999	input,
5000	inst
5001	});
5002	return payload;
5003	}
5004	payload.value = Array(input.length);
5005	const proms = [];
5006	for (let i = 0; i < input.length; i++) {
5007	const item = input[i];
5008	const result = def.element._zod.run({
5009	value: item,
5010	issues: []
5011	}, ctx);
5012	if (result instanceof Promise) proms.push(result.then((result) => handleArrayResult(result, payload, i)));
5013	else handleArrayResult(result, payload, i);
5014	}
5015	if (proms.length) return Promise.all(proms).then(() => payload);
5016	return payload;
5017	};
5018	});
5019	function handleObjectResult(result, final, key) {
5020	if (result.issues.length) final.issues.push(...prefixIssues(key, result.issues));
5021	final.value[key] = result.value;
5022	}
5023	function handleOptionalObjectResult(result, final, key, input) {
5024	if (result.issues.length) if (input[key] === void 0) if (key in input) final.value[key] = void 0;
5025	else final.value[key] = result.value;
5026	else final.issues.push(...prefixIssues(key, result.issues));
5027	else if (result.value === void 0) {
5028	if (key in input) final.value[key] = void 0;
5029	} else final.value[key] = result.value;
5030	}
5031	var $ZodObject = /@__PURE__/ $constructor("$ZodObject", (inst, def) => {
5032	$ZodType.init(inst, def);
5033	const _normalized = cached(() => {
5034	const keys = Object.keys(def.shape);
5035	for (const k of keys) if (!(def.shape[k] instanceof $ZodType)) throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
5036	const okeys = optionalKeys(def.shape);
5037	return {
5038	shape: def.shape,
5039	keys,
5040	keySet: new Set(keys),
5041	numKeys: keys.length,
5042	optionalKeys: new Set(okeys)
5043	};
5044	});
5045	defineLazy(inst._zod, "propValues", () => {
5046	const shape = def.shape;
5047	const propValues = {};
5048	for (const key in shape) {
5049	const field = shape[key]._zod;
5050	if (field.values) {
5051	propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
5052	for (const v of field.values) propValues[key].add(v);
5053	}
5054	}
5055	return propValues;
5056	});
5057	const generateFastpass = (shape) => {
5058	const doc = new Doc([
5059	"shape",
5060	"payload",
5061	"ctx"
5062	]);
5063	const normalized = _normalized.value;
5064	const parseStr = (key) => {
5065	const k = esc(key);
5066	return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
5067	};
5068	doc.write(`const input = payload.value;`);
5069	const ids = Object.create(null);
5070	let counter = 0;
5071	for (const key of normalized.keys) ids[key] = `key_${counter++}`;
5072	doc.write(`const newResult = {}`);
5073	for (const key of normalized.keys) if (normalized.optionalKeys.has(key)) {
5074	const id = ids[key];
5075	doc.write(`const ${id} = ${parseStr(key)};`);
5076	const k = esc(key);
5077	doc.write(`
5078	if (${id}.issues.length) {
5079	if (input[${k}] === undefined) {
5080	if (${k} in input) {
5081	newResult[${k}] = undefined;
5082	}
5083	} else {
5084	payload.issues = payload.issues.concat(
5085	${id}.issues.map((iss) => ({
5086	...iss,
5087	path: iss.path ? [${k}, ...iss.path] : [${k}],
5088	}))
5089	);
5090	}
5091	} else if (${id}.value === undefined) {
5092	if (${k} in input) newResult[${k}] = undefined;
5093	} else {
5094	newResult[${k}] = ${id}.value;
5095	}
5096	`);
5097	} else {
5098	const id = ids[key];
5099	doc.write(`const ${id} = ${parseStr(key)};`);
5100	doc.write(`
5101	if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
5102	...iss,
5103	path: iss.path ? [${esc(key)}, ...iss.path] : [${esc(key)}]
5104	})));`);
5105	doc.write(`newResult[${esc(key)}] = ${id}.value`);
5106	}
5107	doc.write(`payload.value = newResult;`);
5108	doc.write(`return payload;`);
5109	const fn = doc.compile();
5110	return (payload, ctx) => fn(shape, payload, ctx);
5111	};
5112	let fastpass;
5113	const isObject$1 = isObject;
5114	const jit = !globalConfig.jitless;
5115	const allowsEval$1 = allowsEval;
5116	const fastEnabled = jit && allowsEval$1.value;
5117	const catchall = def.catchall;
5118	let value;
5119	inst._zod.parse = (payload, ctx) => {
5120	value ?? (value = _normalized.value);
5121	const input = payload.value;
5122	if (!isObject$1(input)) {
5123	payload.issues.push({
5124	expected: "object",
5125	code: "invalid_type",
5126	input,
5127	inst
5128	});
5129	return payload;
5130	}
5131	const proms = [];
5132	if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
5133	if (!fastpass) fastpass = generateFastpass(def.shape);
5134	payload = fastpass(payload, ctx);
5135	} else {
5136	payload.value = {};
5137	const shape = value.shape;
5138	for (const key of value.keys) {
5139	const el = shape[key];
5140	const r = el._zod.run({
5141	value: input[key],
5142	issues: []
5143	}, ctx);
5144	const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
5145	if (r instanceof Promise) proms.push(r.then((r) => isOptional ? handleOptionalObjectResult(r, payload, key, input) : handleObjectResult(r, payload, key)));
5146	else if (isOptional) handleOptionalObjectResult(r, payload, key, input);
5147	else handleObjectResult(r, payload, key);
5148	}
5149	}
5150	if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;
5151	const unrecognized = [];
5152	const keySet = value.keySet;
5153	const _catchall = catchall._zod;
5154	const t = _catchall.def.type;
5155	for (const key of Object.keys(input)) {
5156	if (keySet.has(key)) continue;
5157	if (t === "never") {
5158	unrecognized.push(key);
5159	continue;
5160	}
5161	const r = _catchall.run({
5162	value: input[key],
5163	issues: []
5164	}, ctx);
5165	if (r instanceof Promise) proms.push(r.then((r) => handleObjectResult(r, payload, key)));
5166	else handleObjectResult(r, payload, key);
5167	}
5168	if (unrecognized.length) payload.issues.push({
5169	code: "unrecognized_keys",
5170	keys: unrecognized,
5171	input,
5172	inst
5173	});
5174	if (!proms.length) return payload;
5175	return Promise.all(proms).then(() => {
5176	return payload;
5177	});
5178	};
5179	});
5180	function handleUnionResults(results, final, inst, ctx) {
5181	for (const result of results) if (result.issues.length === 0) {
5182	final.value = result.value;
5183	return final;
5184	}
5185	final.issues.push({
5186	code: "invalid_union",
5187	input: final.value,
5188	inst,
5189	errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
5190	});
5191	return final;
5192	}
5193	var $ZodUnion = /@__PURE__/ $constructor("$ZodUnion", (inst, def) => {
5194	$ZodType.init(inst, def);
5195	defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
5196	defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
5197	defineLazy(inst._zod, "values", () => {
5198	if (def.options.every((o) => o._zod.values)) return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
5199	});
5200	defineLazy(inst._zod, "pattern", () => {
5201	if (def.options.every((o) => o._zod.pattern)) {
5202	const patterns = def.options.map((o) => o._zod.pattern);
5203	return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("\|")})$`);
5204	}
5205	});
5206	inst._zod.parse = (payload, ctx) => {
5207	let async = false;
5208	const results = [];
5209	for (const option of def.options) {
5210	const result = option._zod.run({
5211	value: payload.value,
5212	issues: []
5213	}, ctx);
5214	if (result instanceof Promise) {
5215	results.push(result);
5216	async = true;
5217	} else {
5218	if (result.issues.length === 0) return result;
5219	results.push(result);
5220	}
5221	}
5222	if (!async) return handleUnionResults(results, payload, inst, ctx);
5223	return Promise.all(results).then((results) => {
5224	return handleUnionResults(results, payload, inst, ctx);
5225	});
5226	};
5227	});
5228	var $ZodDiscriminatedUnion = /@__PURE__/ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
5229	$ZodUnion.init(inst, def);
5230	const _super = inst._zod.parse;
5231	defineLazy(inst._zod, "propValues", () => {
5232	const propValues = {};
5233	for (const option of def.options) {
5234	const pv = option._zod.propValues;
5235	if (!pv \|\| Object.keys(pv).length === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
5236	for (const [k, v] of Object.entries(pv)) {
5237	if (!propValues[k]) propValues[k] = /* @__PURE__ */ new Set();
5238	for (const val of v) propValues[k].add(val);
5239	}
5240	}
5241	return propValues;
5242	});
5243	const disc = cached(() => {
5244	const opts = def.options;
5245	const map = /* @__PURE__ */ new Map();
5246	for (const o of opts) {
5247	const values = o._zod.propValues[def.discriminator];
5248	if (!values \|\| values.size === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
5249	for (const v of values) {
5250	if (map.has(v)) throw new Error(`Duplicate discriminator value "${String(v)}"`);
5251	map.set(v, o);
5252	}
5253	}
5254	return map;
5255	});
5256	inst._zod.parse = (payload, ctx) => {
5257	const input = payload.value;
5258	if (!isObject(input)) {
5259	payload.issues.push({
5260	code: "invalid_type",
5261	expected: "object",
5262	input,
5263	inst
5264	});
5265	return payload;
5266	}
5267	const opt = disc.value.get(input?.[def.discriminator]);
5268	if (opt) return opt._zod.run(payload, ctx);
5269	if (def.unionFallback) return _super(payload, ctx);
5270	payload.issues.push({
5271	code: "invalid_union",
5272	errors: [],
5273	note: "No matching discriminator",
5274	input,
5275	path: [def.discriminator],
5276	inst
5277	});
5278	return payload;
5279	};
5280	});
5281	var $ZodIntersection = /@__PURE__/ $constructor("$ZodIntersection", (inst, def) => {
5282	$ZodType.init(inst, def);
5283	inst._zod.parse = (payload, ctx) => {
5284	const input = payload.value;
5285	const left = def.left._zod.run({
5286	value: input,
5287	issues: []
5288	}, ctx);
5289	const right = def.right._zod.run({
5290	value: input,
5291	issues: []
5292	}, ctx);
5293	if (left instanceof Promise \|\| right instanceof Promise) return Promise.all([left, right]).then(([left, right]) => {
5294	return handleIntersectionResults(payload, left, right);
5295	});
5296	return handleIntersectionResults(payload, left, right);
5297	};
5298	});
5299	function mergeValues(a, b) {
5300	if (a === b) return {
5301	valid: true,
5302	data: a
5303	};
5304	if (a instanceof Date && b instanceof Date && +a === +b) return {
5305	valid: true,
5306	data: a
5307	};
5308	if (isPlainObject$1(a) && isPlainObject$1(b)) {
5309	const bKeys = Object.keys(b);
5310	const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
5311	const newObj = {
5312	...a,
5313	...b
5314	};
5315	for (const key of sharedKeys) {
5316	const sharedValue = mergeValues(a[key], b[key]);
5317	if (!sharedValue.valid) return {
5318	valid: false,
5319	mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
5320	};
5321	newObj[key] = sharedValue.data;
5322	}
5323	return {
5324	valid: true,
5325	data: newObj
5326	};
5327	}
5328	if (Array.isArray(a) && Array.isArray(b)) {
5329	if (a.length !== b.length) return {
5330	valid: false,
5331	mergeErrorPath: []
5332	};
5333	const newArray = [];
5334	for (let index = 0; index < a.length; index++) {
5335	const itemA = a[index];
5336	const itemB = b[index];
5337	const sharedValue = mergeValues(itemA, itemB);
5338	if (!sharedValue.valid) return {
5339	valid: false,
5340	mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
5341	};
5342	newArray.push(sharedValue.data);
5343	}
5344	return {
5345	valid: true,
5346	data: newArray
5347	};
5348	}
5349	return {
5350	valid: false,
5351	mergeErrorPath: []
5352	};
5353	}
5354	function handleIntersectionResults(result, left, right) {
5355	if (left.issues.length) result.issues.push(...left.issues);
5356	if (right.issues.length) result.issues.push(...right.issues);
5357	if (aborted(result)) return result;
5358	const merged = mergeValues(left.value, right.value);
5359	if (!merged.valid) throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
5360	result.value = merged.data;
5361	return result;
5362	}
5363	var $ZodRecord = /@__PURE__/ $constructor("$ZodRecord", (inst, def) => {
5364	$ZodType.init(inst, def);
5365	inst._zod.parse = (payload, ctx) => {
5366	const input = payload.value;
5367	if (!isPlainObject$1(input)) {
5368	payload.issues.push({
5369	expected: "record",
5370	code: "invalid_type",
5371	input,
5372	inst
5373	});
5374	return payload;
5375	}
5376	const proms = [];
5377	if (def.keyType._zod.values) {
5378	const values = def.keyType._zod.values;
5379	payload.value = {};
5380	for (const key of values) if (typeof key === "string" \|\| typeof key === "number" \|\| typeof key === "symbol") {
5381	const result = def.valueType._zod.run({
5382	value: input[key],
5383	issues: []
5384	}, ctx);
5385	if (result instanceof Promise) proms.push(result.then((result) => {
5386	if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
5387	payload.value[key] = result.value;
5388	}));
5389	else {
5390	if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
5391	payload.value[key] = result.value;
5392	}
5393	}
5394	let unrecognized;
5395	for (const key in input) if (!values.has(key)) {
5396	unrecognized = unrecognized ?? [];
5397	unrecognized.push(key);
5398	}
5399	if (unrecognized && unrecognized.length > 0) payload.issues.push({
5400	code: "unrecognized_keys",
5401	input,
5402	inst,
5403	keys: unrecognized
5404	});
5405	} else {
5406	payload.value = {};
5407	for (const key of Reflect.ownKeys(input)) {
5408	if (key === "__proto__") continue;
5409	const keyResult = def.keyType._zod.run({
5410	value: key,
5411	issues: []
5412	}, ctx);
5413	if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
5414	if (keyResult.issues.length) {
5415	payload.issues.push({
5416	origin: "record",
5417	code: "invalid_key",
5418	issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
5419	input: key,
5420	path: [key],
5421	inst
5422	});
5423	payload.value[keyResult.value] = keyResult.value;
5424	continue;
5425	}
5426	const result = def.valueType._zod.run({
5427	value: input[key],
5428	issues: []
5429	}, ctx);
5430	if (result instanceof Promise) proms.push(result.then((result) => {
5431	if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
5432	payload.value[keyResult.value] = result.value;
5433	}));
5434	else {
5435	if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
5436	payload.value[keyResult.value] = result.value;
5437	}
5438	}
5439	}
5440	if (proms.length) return Promise.all(proms).then(() => payload);
5441	return payload;
5442	};
5443	});
5444	var $ZodEnum = /@__PURE__/ $constructor("$ZodEnum", (inst, def) => {
5445	$ZodType.init(inst, def);
5446	const values = getEnumValues(def.entries);
5447	inst._zod.values = new Set(values);
5448	inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("\|")})$`);
5449	inst._zod.parse = (payload, _ctx) => {
5450	const input = payload.value;
5451	if (inst._zod.values.has(input)) return payload;
5452	payload.issues.push({
5453	code: "invalid_value",
5454	values,
5455	input,
5456	inst
5457	});
5458	return payload;
5459	};
5460	});
5461	var $ZodLiteral = /@__PURE__/ $constructor("$ZodLiteral", (inst, def) => {
5462	$ZodType.init(inst, def);
5463	inst._zod.values = new Set(def.values);
5464	inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? o.toString() : String(o)).join("\|")})$`);
5465	inst._zod.parse = (payload, _ctx) => {
5466	const input = payload.value;
5467	if (inst._zod.values.has(input)) return payload;
5468	payload.issues.push({
5469	code: "invalid_value",
5470	values: def.values,
5471	input,
5472	inst
5473	});
5474	return payload;
5475	};
5476	});
5477	var $ZodTransform = /@__PURE__/ $constructor("$ZodTransform", (inst, def) => {
5478	$ZodType.init(inst, def);
5479	inst._zod.parse = (payload, _ctx) => {
5480	const _out = def.transform(payload.value, payload);
5481	if (_ctx.async) return (_out instanceof Promise ? _out : Promise.resolve(_out)).then((output) => {
5482	payload.value = output;
5483	return payload;
5484	});
5485	if (_out instanceof Promise) throw new $ZodAsyncError();
5486	payload.value = _out;
5487	return payload;
5488	};
5489	});
5490	var $ZodOptional = /@__PURE__/ $constructor("$ZodOptional", (inst, def) => {
5491	$ZodType.init(inst, def);
5492	inst._zod.optin = "optional";
5493	inst._zod.optout = "optional";
5494	defineLazy(inst._zod, "values", () => {
5495	return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
5496	});
5497	defineLazy(inst._zod, "pattern", () => {
5498	const pattern = def.innerType._zod.pattern;
5499	return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
5500	});
5501	inst._zod.parse = (payload, ctx) => {
5502	if (def.innerType._zod.optin === "optional") return def.innerType._zod.run(payload, ctx);
5503	if (payload.value === void 0) return payload;
5504	return def.innerType._zod.run(payload, ctx);
5505	};
5506	});
5507	var $ZodNullable = /@__PURE__/ $constructor("$ZodNullable", (inst, def) => {
5508	$ZodType.init(inst, def);
5509	defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
5510	defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
5511	defineLazy(inst._zod, "pattern", () => {
5512	const pattern = def.innerType._zod.pattern;
5513	return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}\|null)$`) : void 0;
5514	});
5515	defineLazy(inst._zod, "values", () => {
5516	return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
5517	});
5518	inst._zod.parse = (payload, ctx) => {
5519	if (payload.value === null) return payload;
5520	return def.innerType._zod.run(payload, ctx);
5521	};
5522	});
5523	var $ZodDefault = /@__PURE__/ $constructor("$ZodDefault", (inst, def) => {
5524	$ZodType.init(inst, def);
5525	inst._zod.optin = "optional";
5526	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
5527	inst._zod.parse = (payload, ctx) => {
5528	if (payload.value === void 0) {
5529	payload.value = def.defaultValue;
5530	/**
5531	* $ZodDefault always returns the default value immediately.
5532	* It doesn't pass the default value into the validator ("prefault"). There's no reason to pass the default value through validation. The validity of the default is enforced by TypeScript statically. Otherwise, it's the responsibility of the user to ensure the default is valid. In the case of pipes with divergent in/out types, you can specify the default on the `in` schema of your ZodPipe to set a "prefault" for the pipe. */
5533	return payload;
5534	}
5535	const result = def.innerType._zod.run(payload, ctx);
5536	if (result instanceof Promise) return result.then((result) => handleDefaultResult(result, def));
5537	return handleDefaultResult(result, def);
5538	};
5539	});
5540	function handleDefaultResult(payload, def) {
5541	if (payload.value === void 0) payload.value = def.defaultValue;
5542	return payload;
5543	}
5544	var $ZodPrefault = /@__PURE__/ $constructor("$ZodPrefault", (inst, def) => {
5545	$ZodType.init(inst, def);
5546	inst._zod.optin = "optional";
5547	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
5548	inst._zod.parse = (payload, ctx) => {
5549	if (payload.value === void 0) payload.value = def.defaultValue;
5550	return def.innerType._zod.run(payload, ctx);
5551	};
5552	});
5553	var $ZodNonOptional = /@__PURE__/ $constructor("$ZodNonOptional", (inst, def) => {
5554	$ZodType.init(inst, def);
5555	defineLazy(inst._zod, "values", () => {
5556	const v = def.innerType._zod.values;
5557	return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
5558	});
5559	inst._zod.parse = (payload, ctx) => {
5560	const result = def.innerType._zod.run(payload, ctx);
5561	if (result instanceof Promise) return result.then((result) => handleNonOptionalResult(result, inst));
5562	return handleNonOptionalResult(result, inst);
5563	};
5564	});
5565	function handleNonOptionalResult(payload, inst) {
5566	if (!payload.issues.length && payload.value === void 0) payload.issues.push({
5567	code: "invalid_type",
5568	expected: "nonoptional",
5569	input: payload.value,
5570	inst
5571	});
5572	return payload;
5573	}
5574	var $ZodCatch = /@__PURE__/ $constructor("$ZodCatch", (inst, def) => {
5575	$ZodType.init(inst, def);
5576	inst._zod.optin = "optional";
5577	defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
5578	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
5579	inst._zod.parse = (payload, ctx) => {
5580	const result = def.innerType._zod.run(payload, ctx);
5581	if (result instanceof Promise) return result.then((result) => {
5582	payload.value = result.value;
5583	if (result.issues.length) {
5584	payload.value = def.catchValue({
5585	...payload,
5586	error: { issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) },
5587	input: payload.value
5588	});
5589	payload.issues = [];
5590	}
5591	return payload;
5592	});
5593	payload.value = result.value;
5594	if (result.issues.length) {
5595	payload.value = def.catchValue({
5596	...payload,
5597	error: { issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) },
5598	input: payload.value
5599	});
5600	payload.issues = [];
5601	}
5602	return payload;
5603	};
5604	});
5605	var $ZodPipe = /@__PURE__/ $constructor("$ZodPipe", (inst, def) => {
5606	$ZodType.init(inst, def);
5607	defineLazy(inst._zod, "values", () => def.in._zod.values);
5608	defineLazy(inst._zod, "optin", () => def.in._zod.optin);
5609	defineLazy(inst._zod, "optout", () => def.out._zod.optout);
5610	inst._zod.parse = (payload, ctx) => {
5611	const left = def.in._zod.run(payload, ctx);
5612	if (left instanceof Promise) return left.then((left) => handlePipeResult(left, def, ctx));
5613	return handlePipeResult(left, def, ctx);
5614	};
5615	});
5616	function handlePipeResult(left, def, ctx) {
5617	if (aborted(left)) return left;
5618	return def.out._zod.run({
5619	value: left.value,
5620	issues: left.issues
5621	}, ctx);
5622	}
5623	var $ZodReadonly = /@__PURE__/ $constructor("$ZodReadonly", (inst, def) => {
5624	$ZodType.init(inst, def);
5625	defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
5626	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
5627	defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
5628	defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
5629	inst._zod.parse = (payload, ctx) => {
5630	const result = def.innerType._zod.run(payload, ctx);
5631	if (result instanceof Promise) return result.then(handleReadonlyResult);
5632	return handleReadonlyResult(result);
5633	};
5634	});
5635	function handleReadonlyResult(payload) {
5636	payload.value = Object.freeze(payload.value);
5637	return payload;
5638	}
5639	var $ZodCustom = /@__PURE__/ $constructor("$ZodCustom", (inst, def) => {
5640	$ZodCheck.init(inst, def);
5641	$ZodType.init(inst, def);
5642	inst._zod.parse = (payload, _) => {
5643	return payload;
5644	};
5645	inst._zod.check = (payload) => {
5646	const input = payload.value;
5647	const r = def.fn(input);
5648	if (r instanceof Promise) return r.then((r) => handleRefineResult(r, payload, input, inst));
5649	handleRefineResult(r, payload, input, inst);
5650	};
5651	});
5652	function handleRefineResult(result, payload, input, inst) {
5653	if (!result) {
5654	const _iss = {
5655	code: "custom",
5656	input,
5657	inst,
5658	path: [...inst._zod.def.path ?? []],
5659	continue: !inst._zod.def.abort
5660	};
5661	if (inst._zod.def.params) _iss.params = inst._zod.def.params;
5662	payload.issues.push(issue(_iss));
5663	}
5664	}
5665
5666	//#endregion
5667	//#region node_modules/zod/v4/core/registries.js
5668	var $ZodRegistry = class {
5669	constructor() {
5670	this._map = /* @__PURE__ */ new Map();
5671	this._idmap = /* @__PURE__ */ new Map();
5672	}
5673	add(schema, ..._meta) {
5674	const meta = _meta[0];
5675	this._map.set(schema, meta);
5676	if (meta && typeof meta === "object" && "id" in meta) {
5677	if (this._idmap.has(meta.id)) throw new Error(`ID ${meta.id} already exists in the registry`);
5678	this._idmap.set(meta.id, schema);
5679	}
5680	return this;
5681	}
5682	clear() {
5683	this._map = /* @__PURE__ */ new Map();
5684	this._idmap = /* @__PURE__ */ new Map();
5685	return this;
5686	}
5687	remove(schema) {
5688	const meta = this._map.get(schema);
5689	if (meta && typeof meta === "object" && "id" in meta) this._idmap.delete(meta.id);
5690	this._map.delete(schema);
5691	return this;
5692	}
5693	get(schema) {
5694	const p = schema._zod.parent;
5695	if (p) {
5696	const pm = { ...this.get(p) ?? {} };
5697	delete pm.id;
5698	return {
5699	...pm,
5700	...this._map.get(schema)
5701	};
5702	}
5703	return this._map.get(schema);
5704	}
5705	has(schema) {
5706	return this._map.has(schema);
5707	}
5708	};
5709	function registry() {
5710	return new $ZodRegistry();
5711	}
5712	var globalRegistry = /@__PURE__/ registry();
5713
5714	//#endregion
5715	//#region node_modules/zod/v4/core/api.js
5716	function _string(Class, params) {
5717	return new Class({
5718	type: "string",
5719	...normalizeParams(params)
5720	});
5721	}
5722	function _email(Class, params) {
5723	return new Class({
5724	type: "string",
5725	format: "email",
5726	check: "string_format",
5727	abort: false,
5728	...normalizeParams(params)
5729	});
5730	}
5731	function _guid(Class, params) {
5732	return new Class({
5733	type: "string",
5734	format: "guid",
5735	check: "string_format",
5736	abort: false,
5737	...normalizeParams(params)
5738	});
5739	}
5740	function _uuid(Class, params) {
5741	return new Class({
5742	type: "string",
5743	format: "uuid",
5744	check: "string_format",
5745	abort: false,
5746	...normalizeParams(params)
5747	});
5748	}
5749	function _uuidv4(Class, params) {
5750	return new Class({
5751	type: "string",
5752	format: "uuid",
5753	check: "string_format",
5754	abort: false,
5755	version: "v4",
5756	...normalizeParams(params)
5757	});
5758	}
5759	function _uuidv6(Class, params) {
5760	return new Class({
5761	type: "string",
5762	format: "uuid",
5763	check: "string_format",
5764	abort: false,
5765	version: "v6",
5766	...normalizeParams(params)
5767	});
5768	}
5769	function _uuidv7(Class, params) {
5770	return new Class({
5771	type: "string",
5772	format: "uuid",
5773	check: "string_format",
5774	abort: false,
5775	version: "v7",
5776	...normalizeParams(params)
5777	});
5778	}
5779	function _url(Class, params) {
5780	return new Class({
5781	type: "string",
5782	format: "url",
5783	check: "string_format",
5784	abort: false,
5785	...normalizeParams(params)
5786	});
5787	}
5788	function _emoji(Class, params) {
5789	return new Class({
5790	type: "string",
5791	format: "emoji",
5792	check: "string_format",
5793	abort: false,
5794	...normalizeParams(params)
5795	});
5796	}
5797	function _nanoid(Class, params) {
5798	return new Class({
5799	type: "string",
5800	format: "nanoid",
5801	check: "string_format",
5802	abort: false,
5803	...normalizeParams(params)
5804	});
5805	}
5806	function _cuid(Class, params) {
5807	return new Class({
5808	type: "string",
5809	format: "cuid",
5810	check: "string_format",
5811	abort: false,
5812	...normalizeParams(params)
5813	});
5814	}
5815	function _cuid2(Class, params) {
5816	return new Class({
5817	type: "string",
5818	format: "cuid2",
5819	check: "string_format",
5820	abort: false,
5821	...normalizeParams(params)
5822	});
5823	}
5824	function _ulid(Class, params) {
5825	return new Class({
5826	type: "string",
5827	format: "ulid",
5828	check: "string_format",
5829	abort: false,
5830	...normalizeParams(params)
5831	});
5832	}
5833	function _xid(Class, params) {
5834	return new Class({
5835	type: "string",
5836	format: "xid",
5837	check: "string_format",
5838	abort: false,
5839	...normalizeParams(params)
5840	});
5841	}
5842	function _ksuid(Class, params) {
5843	return new Class({
5844	type: "string",
5845	format: "ksuid",
5846	check: "string_format",
5847	abort: false,
5848	...normalizeParams(params)
5849	});
5850	}
5851	function _ipv4(Class, params) {
5852	return new Class({
5853	type: "string",
5854	format: "ipv4",
5855	check: "string_format",
5856	abort: false,
5857	...normalizeParams(params)
5858	});
5859	}
5860	function _ipv6(Class, params) {
5861	return new Class({
5862	type: "string",
5863	format: "ipv6",
5864	check: "string_format",
5865	abort: false,
5866	...normalizeParams(params)
5867	});
5868	}
5869	function _cidrv4(Class, params) {
5870	return new Class({
5871	type: "string",
5872	format: "cidrv4",
5873	check: "string_format",
5874	abort: false,
5875	...normalizeParams(params)
5876	});
5877	}
5878	function _cidrv6(Class, params) {
5879	return new Class({
5880	type: "string",
5881	format: "cidrv6",
5882	check: "string_format",
5883	abort: false,
5884	...normalizeParams(params)
5885	});
5886	}
5887	function _base64(Class, params) {
5888	return new Class({
5889	type: "string",
5890	format: "base64",
5891	check: "string_format",
5892	abort: false,
5893	...normalizeParams(params)
5894	});
5895	}
5896	function _base64url(Class, params) {
5897	return new Class({
5898	type: "string",
5899	format: "base64url",
5900	check: "string_format",
5901	abort: false,
5902	...normalizeParams(params)
5903	});
5904	}
5905	function _e164(Class, params) {
5906	return new Class({
5907	type: "string",
5908	format: "e164",
5909	check: "string_format",
5910	abort: false,
5911	...normalizeParams(params)
5912	});
5913	}
5914	function _jwt(Class, params) {
5915	return new Class({
5916	type: "string",
5917	format: "jwt",
5918	check: "string_format",
5919	abort: false,
5920	...normalizeParams(params)
5921	});
5922	}
5923	function _isoDateTime(Class, params) {
5924	return new Class({
5925	type: "string",
5926	format: "datetime",
5927	check: "string_format",
5928	offset: false,
5929	local: false,
5930	precision: null,
5931	...normalizeParams(params)
5932	});
5933	}
5934	function _isoDate(Class, params) {
5935	return new Class({
5936	type: "string",
5937	format: "date",
5938	check: "string_format",
5939	...normalizeParams(params)
5940	});
5941	}
5942	function _isoTime(Class, params) {
5943	return new Class({
5944	type: "string",
5945	format: "time",
5946	check: "string_format",
5947	precision: null,
5948	...normalizeParams(params)
5949	});
5950	}
5951	function _isoDuration(Class, params) {
5952	return new Class({
5953	type: "string",
5954	format: "duration",
5955	check: "string_format",
5956	...normalizeParams(params)
5957	});
5958	}
5959	function _number(Class, params) {
5960	return new Class({
5961	type: "number",
5962	checks: [],
5963	...normalizeParams(params)
5964	});
5965	}
5966	function _int(Class, params) {
5967	return new Class({
5968	type: "number",
5969	check: "number_format",
5970	abort: false,
5971	format: "safeint",
5972	...normalizeParams(params)
5973	});
5974	}
5975	function _boolean(Class, params) {
5976	return new Class({
5977	type: "boolean",
5978	...normalizeParams(params)
5979	});
5980	}
5981	function _null$1(Class, params) {
5982	return new Class({
5983	type: "null",
5984	...normalizeParams(params)
5985	});
5986	}
5987	__name(_null$1, "_null");
5988	function _unknown(Class) {
5989	return new Class({ type: "unknown" });
5990	}
5991	function _never(Class, params) {
5992	return new Class({
5993	type: "never",
5994	...normalizeParams(params)
5995	});
5996	}
5997	function _lt(value, params) {
5998	return new $ZodCheckLessThan({
5999	check: "less_than",
6000	...normalizeParams(params),
6001	value,
6002	inclusive: false
6003	});
6004	}
6005	function _lte(value, params) {
6006	return new $ZodCheckLessThan({
6007	check: "less_than",
6008	...normalizeParams(params),
6009	value,
6010	inclusive: true
6011	});
6012	}
6013	function _gt(value, params) {
6014	return new $ZodCheckGreaterThan({
6015	check: "greater_than",
6016	...normalizeParams(params),
6017	value,
6018	inclusive: false
6019	});
6020	}
6021	function _gte(value, params) {
6022	return new $ZodCheckGreaterThan({
6023	check: "greater_than",
6024	...normalizeParams(params),
6025	value,
6026	inclusive: true
6027	});
6028	}
6029	function _multipleOf(value, params) {
6030	return new $ZodCheckMultipleOf({
6031	check: "multiple_of",
6032	...normalizeParams(params),
6033	value
6034	});
6035	}
6036	function _maxLength(maximum, params) {
6037	return new $ZodCheckMaxLength({
6038	check: "max_length",
6039	...normalizeParams(params),
6040	maximum
6041	});
6042	}
6043	function _minLength(minimum, params) {
6044	return new $ZodCheckMinLength({
6045	check: "min_length",
6046	...normalizeParams(params),
6047	minimum
6048	});
6049	}
6050	function _length(length, params) {
6051	return new $ZodCheckLengthEquals({
6052	check: "length_equals",
6053	...normalizeParams(params),
6054	length
6055	});
6056	}
6057	function _regex(pattern, params) {
6058	return new $ZodCheckRegex({
6059	check: "string_format",
6060	format: "regex",
6061	...normalizeParams(params),
6062	pattern
6063	});
6064	}
6065	function _lowercase(params) {
6066	return new $ZodCheckLowerCase({
6067	check: "string_format",
6068	format: "lowercase",
6069	...normalizeParams(params)
6070	});
6071	}
6072	function _uppercase(params) {
6073	return new $ZodCheckUpperCase({
6074	check: "string_format",
6075	format: "uppercase",
6076	...normalizeParams(params)
6077	});
6078	}
6079	function _includes(includes, params) {
6080	return new $ZodCheckIncludes({
6081	check: "string_format",
6082	format: "includes",
6083	...normalizeParams(params),
6084	includes
6085	});
6086	}
6087	function _startsWith(prefix, params) {
6088	return new $ZodCheckStartsWith({
6089	check: "string_format",
6090	format: "starts_with",
6091	...normalizeParams(params),
6092	prefix
6093	});
6094	}
6095	function _endsWith(suffix, params) {
6096	return new $ZodCheckEndsWith({
6097	check: "string_format",
6098	format: "ends_with",
6099	...normalizeParams(params),
6100	suffix
6101	});
6102	}
6103	function _overwrite(tx) {
6104	return new $ZodCheckOverwrite({
6105	check: "overwrite",
6106	tx
6107	});
6108	}
6109	function _normalize(form) {
6110	return _overwrite((input) => input.normalize(form));
6111	}
6112	function _trim() {
6113	return _overwrite((input) => input.trim());
6114	}
6115	function _toLowerCase() {
6116	return _overwrite((input) => input.toLowerCase());
6117	}
6118	function _toUpperCase() {
6119	return _overwrite((input) => input.toUpperCase());
6120	}
6121	function _array(Class, element, params) {
6122	return new Class({
6123	type: "array",
6124	element,
6125	...normalizeParams(params)
6126	});
6127	}
6128	function _custom(Class, fn, _params) {
6129	const norm = normalizeParams(_params);
6130	norm.abort ?? (norm.abort = true);
6131	return new Class({
6132	type: "custom",
6133	check: "custom",
6134	fn,
6135	...norm
6136	});
6137	}
6138	function _refine(Class, fn, _params) {
6139	return new Class({
6140	type: "custom",
6141	check: "custom",
6142	fn,
6143	...normalizeParams(_params)
6144	});
6145	}
6146
6147	//#endregion
6148	//#region node_modules/zod/v4/core/to-json-schema.js
6149	var JSONSchemaGenerator = class {
6150	constructor(params) {
6151	this.counter = 0;
6152	this.metadataRegistry = params?.metadata ?? globalRegistry;
6153	this.target = params?.target ?? "draft-2020-12";
6154	this.unrepresentable = params?.unrepresentable ?? "throw";
6155	this.override = params?.override ?? (() => {});
6156	this.io = params?.io ?? "output";
6157	this.seen = /* @__PURE__ */ new Map();
6158	}
6159	process(schema, _params = {
6160	path: [],
6161	schemaPath: []
6162	}) {
6163	var _a;
6164	const def = schema._zod.def;
6165	const formatMap = {
6166	guid: "uuid",
6167	url: "uri",
6168	datetime: "date-time",
6169	json_string: "json-string",
6170	regex: ""
6171	};
6172	const seen = this.seen.get(schema);
6173	if (seen) {
6174	seen.count++;
6175	if (_params.schemaPath.includes(schema)) seen.cycle = _params.path;
6176	return seen.schema;
6177	}
6178	const result = {
6179	schema: {},
6180	count: 1,
6181	cycle: void 0,
6182	path: _params.path
6183	};
6184	this.seen.set(schema, result);
6185	const overrideSchema = schema._zod.toJSONSchema?.();
6186	if (overrideSchema) result.schema = overrideSchema;
6187	else {
6188	const params = {
6189	..._params,
6190	schemaPath: [..._params.schemaPath, schema],
6191	path: _params.path
6192	};
6193	const parent = schema._zod.parent;
6194	if (parent) {
6195	result.ref = parent;
6196	this.process(parent, params);
6197	this.seen.get(parent).isParent = true;
6198	} else {
6199	const _json = result.schema;
6200	switch (def.type) {
6201	case "string": {
6202	const json = _json;
6203	json.type = "string";
6204	const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
6205	if (typeof minimum === "number") json.minLength = minimum;
6206	if (typeof maximum === "number") json.maxLength = maximum;
6207	if (format) {
6208	json.format = formatMap[format] ?? format;
6209	if (json.format === "") delete json.format;
6210	}
6211	if (contentEncoding) json.contentEncoding = contentEncoding;
6212	if (patterns && patterns.size > 0) {
6213	const regexes = [...patterns];
6214	if (regexes.length === 1) json.pattern = regexes[0].source;
6215	else if (regexes.length > 1) result.schema.allOf = [...regexes.map((regex) => ({
6216	...this.target === "draft-7" ? { type: "string" } : {},
6217	pattern: regex.source
6218	}))];
6219	}
6220	break;
6221	}
6222	case "number": {
6223	const json = _json;
6224	const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
6225	if (typeof format === "string" && format.includes("int")) json.type = "integer";
6226	else json.type = "number";
6227	if (typeof exclusiveMinimum === "number") json.exclusiveMinimum = exclusiveMinimum;
6228	if (typeof minimum === "number") {
6229	json.minimum = minimum;
6230	if (typeof exclusiveMinimum === "number") if (exclusiveMinimum >= minimum) delete json.minimum;
6231	else delete json.exclusiveMinimum;
6232	}
6233	if (typeof exclusiveMaximum === "number") json.exclusiveMaximum = exclusiveMaximum;
6234	if (typeof maximum === "number") {
6235	json.maximum = maximum;
6236	if (typeof exclusiveMaximum === "number") if (exclusiveMaximum <= maximum) delete json.maximum;
6237	else delete json.exclusiveMaximum;
6238	}
6239	if (typeof multipleOf === "number") json.multipleOf = multipleOf;
6240	break;
6241	}
6242	case "boolean": {
6243	const json = _json;
6244	json.type = "boolean";
6245	break;
6246	}
6247	case "bigint":
6248	if (this.unrepresentable === "throw") throw new Error("BigInt cannot be represented in JSON Schema");
6249	break;
6250	case "symbol":
6251	if (this.unrepresentable === "throw") throw new Error("Symbols cannot be represented in JSON Schema");
6252	break;
6253	case "null":
6254	_json.type = "null";
6255	break;
6256	case "any": break;
6257	case "unknown": break;
6258	case "undefined":
6259	if (this.unrepresentable === "throw") throw new Error("Undefined cannot be represented in JSON Schema");
6260	break;
6261	case "void":
6262	if (this.unrepresentable === "throw") throw new Error("Void cannot be represented in JSON Schema");
6263	break;
6264	case "never":
6265	_json.not = {};
6266	break;
6267	case "date":
6268	if (this.unrepresentable === "throw") throw new Error("Date cannot be represented in JSON Schema");
6269	break;
6270	case "array": {
6271	const json = _json;
6272	const { minimum, maximum } = schema._zod.bag;
6273	if (typeof minimum === "number") json.minItems = minimum;
6274	if (typeof maximum === "number") json.maxItems = maximum;
6275	json.type = "array";
6276	json.items = this.process(def.element, {
6277	...params,
6278	path: [...params.path, "items"]
6279	});
6280	break;
6281	}
6282	case "object": {
6283	const json = _json;
6284	json.type = "object";
6285	json.properties = {};
6286	const shape = def.shape;
6287	for (const key in shape) json.properties[key] = this.process(shape[key], {
6288	...params,
6289	path: [
6290	...params.path,
6291	"properties",
6292	key
6293	]
6294	});
6295	const allKeys = new Set(Object.keys(shape));
6296	const requiredKeys = new Set([...allKeys].filter((key) => {
6297	const v = def.shape[key]._zod;
6298	if (this.io === "input") return v.optin === void 0;
6299	else return v.optout === void 0;
6300	}));
6301	if (requiredKeys.size > 0) json.required = Array.from(requiredKeys);
6302	if (def.catchall?._zod.def.type === "never") json.additionalProperties = false;
6303	else if (!def.catchall) {
6304	if (this.io === "output") json.additionalProperties = false;
6305	} else if (def.catchall) json.additionalProperties = this.process(def.catchall, {
6306	...params,
6307	path: [...params.path, "additionalProperties"]
6308	});
6309	break;
6310	}
6311	case "union": {
6312	const json = _json;
6313	json.anyOf = def.options.map((x, i) => this.process(x, {
6314	...params,
6315	path: [
6316	...params.path,
6317	"anyOf",
6318	i
6319	]
6320	}));
6321	break;
6322	}
6323	case "intersection": {
6324	const json = _json;
6325	const a = this.process(def.left, {
6326	...params,
6327	path: [
6328	...params.path,
6329	"allOf",
6330	0
6331	]
6332	});
6333	const b = this.process(def.right, {
6334	...params,
6335	path: [
6336	...params.path,
6337	"allOf",
6338	1
6339	]
6340	});
6341	const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
6342	json.allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
6343	break;
6344	}
6345	case "tuple": {
6346	const json = _json;
6347	json.type = "array";
6348	const prefixItems = def.items.map((x, i) => this.process(x, {
6349	...params,
6350	path: [
6351	...params.path,
6352	"prefixItems",
6353	i
6354	]
6355	}));
6356	if (this.target === "draft-2020-12") json.prefixItems = prefixItems;
6357	else json.items = prefixItems;
6358	if (def.rest) {
6359	const rest = this.process(def.rest, {
6360	...params,
6361	path: [...params.path, "items"]
6362	});
6363	if (this.target === "draft-2020-12") json.items = rest;
6364	else json.additionalItems = rest;
6365	}
6366	if (def.rest) json.items = this.process(def.rest, {
6367	...params,
6368	path: [...params.path, "items"]
6369	});
6370	const { minimum, maximum } = schema._zod.bag;
6371	if (typeof minimum === "number") json.minItems = minimum;
6372	if (typeof maximum === "number") json.maxItems = maximum;
6373	break;
6374	}
6375	case "record": {
6376	const json = _json;
6377	json.type = "object";
6378	json.propertyNames = this.process(def.keyType, {
6379	...params,
6380	path: [...params.path, "propertyNames"]
6381	});
6382	json.additionalProperties = this.process(def.valueType, {
6383	...params,
6384	path: [...params.path, "additionalProperties"]
6385	});
6386	break;
6387	}
6388	case "map":
6389	if (this.unrepresentable === "throw") throw new Error("Map cannot be represented in JSON Schema");
6390	break;
6391	case "set":
6392	if (this.unrepresentable === "throw") throw new Error("Set cannot be represented in JSON Schema");
6393	break;
6394	case "enum": {
6395	const json = _json;
6396	const values = getEnumValues(def.entries);
6397	if (values.every((v) => typeof v === "number")) json.type = "number";
6398	if (values.every((v) => typeof v === "string")) json.type = "string";
6399	json.enum = values;
6400	break;
6401	}
6402	case "literal": {
6403	const json = _json;
6404	const vals = [];
6405	for (const val of def.values) if (val === void 0) {
6406	if (this.unrepresentable === "throw") throw new Error("Literal `undefined` cannot be represented in JSON Schema");
6407	} else if (typeof val === "bigint") if (this.unrepresentable === "throw") throw new Error("BigInt literals cannot be represented in JSON Schema");
6408	else vals.push(Number(val));
6409	else vals.push(val);
6410	if (vals.length === 0) {} else if (vals.length === 1) {
6411	const val = vals[0];
6412	json.type = val === null ? "null" : typeof val;
6413	json.const = val;
6414	} else {
6415	if (vals.every((v) => typeof v === "number")) json.type = "number";
6416	if (vals.every((v) => typeof v === "string")) json.type = "string";
6417	if (vals.every((v) => typeof v === "boolean")) json.type = "string";
6418	if (vals.every((v) => v === null)) json.type = "null";
6419	json.enum = vals;
6420	}
6421	break;
6422	}
6423	case "file": {
6424	const json = _json;
6425	const file = {
6426	type: "string",
6427	format: "binary",
6428	contentEncoding: "binary"
6429	};
6430	const { minimum, maximum, mime } = schema._zod.bag;
6431	if (minimum !== void 0) file.minLength = minimum;
6432	if (maximum !== void 0) file.maxLength = maximum;
6433	if (mime) if (mime.length === 1) {
6434	file.contentMediaType = mime[0];
6435	Object.assign(json, file);
6436	} else json.anyOf = mime.map((m) => {
6437	return {
6438	...file,
6439	contentMediaType: m
6440	};
6441	});
6442	else Object.assign(json, file);
6443	break;
6444	}
6445	case "transform":
6446	if (this.unrepresentable === "throw") throw new Error("Transforms cannot be represented in JSON Schema");
6447	break;
6448	case "nullable":
6449	_json.anyOf = [this.process(def.innerType, params), { type: "null" }];
6450	break;
6451	case "nonoptional":
6452	this.process(def.innerType, params);
6453	result.ref = def.innerType;
6454	break;
6455	case "success": {
6456	const json = _json;
6457	json.type = "boolean";
6458	break;
6459	}
6460	case "default":
6461	this.process(def.innerType, params);
6462	result.ref = def.innerType;
6463	_json.default = JSON.parse(JSON.stringify(def.defaultValue));
6464	break;
6465	case "prefault":
6466	this.process(def.innerType, params);
6467	result.ref = def.innerType;
6468	if (this.io === "input") _json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
6469	break;
6470	case "catch": {
6471	this.process(def.innerType, params);
6472	result.ref = def.innerType;
6473	let catchValue;
6474	try {
6475	catchValue = def.catchValue(void 0);
6476	} catch {
6477	throw new Error("Dynamic catch values are not supported in JSON Schema");
6478	}
6479	_json.default = catchValue;
6480	break;
6481	}
6482	case "nan":
6483	if (this.unrepresentable === "throw") throw new Error("NaN cannot be represented in JSON Schema");
6484	break;
6485	case "template_literal": {
6486	const json = _json;
6487	const pattern = schema._zod.pattern;
6488	if (!pattern) throw new Error("Pattern not found in template literal");
6489	json.type = "string";
6490	json.pattern = pattern.source;
6491	break;
6492	}
6493	case "pipe": {
6494	const innerType = this.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
6495	this.process(innerType, params);
6496	result.ref = innerType;
6497	break;
6498	}
6499	case "readonly":
6500	this.process(def.innerType, params);
6501	result.ref = def.innerType;
6502	_json.readOnly = true;
6503	break;
6504	case "promise":
6505	this.process(def.innerType, params);
6506	result.ref = def.innerType;
6507	break;
6508	case "optional":
6509	this.process(def.innerType, params);
6510	result.ref = def.innerType;
6511	break;
6512	case "lazy": {
6513	const innerType = schema._zod.innerType;
6514	this.process(innerType, params);
6515	result.ref = innerType;
6516	break;
6517	}
6518	case "custom":
6519	if (this.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
6520	break;
6521	default:
6522	}
6523	}
6524	}
6525	const meta = this.metadataRegistry.get(schema);
6526	if (meta) Object.assign(result.schema, meta);
6527	if (this.io === "input" && isTransforming(schema)) {
6528	delete result.schema.examples;
6529	delete result.schema.default;
6530	}
6531	if (this.io === "input" && result.schema._prefault) (_a = result.schema).default ?? (_a.default = result.schema._prefault);
6532	delete result.schema._prefault;
6533	return this.seen.get(schema).schema;
6534	}
6535	emit(schema, _params) {
6536	const params = {
6537	cycles: _params?.cycles ?? "ref",
6538	reused: _params?.reused ?? "inline",
6539	external: _params?.external ?? void 0
6540	};
6541	const root = this.seen.get(schema);
6542	if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
6543	const makeURI = (entry) => {
6544	const defsSegment = this.target === "draft-2020-12" ? "$defs" : "definitions";
6545	if (params.external) {
6546	const externalId = params.external.registry.get(entry[0])?.id;
6547	const uriGenerator = params.external.uri ?? ((id) => id);
6548	if (externalId) return { ref: uriGenerator(externalId) };
6549	const id = entry[1].defId ?? entry[1].schema.id ?? `schema${this.counter++}`;
6550	entry[1].defId = id;
6551	return {
6552	defId: id,
6553	ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}`
6554	};
6555	}
6556	if (entry[1] === root) return { ref: "#" };
6557	const defUriPrefix = `#/${defsSegment}/`;
6558	const defId = entry[1].schema.id ?? `__schema${this.counter++}`;
6559	return {
6560	defId,
6561	ref: defUriPrefix + defId
6562	};
6563	};
6564	const extractToDef = (entry) => {
6565	if (entry[1].schema.$ref) return;
6566	const seen = entry[1];
6567	const { ref, defId } = makeURI(entry);
6568	seen.def = { ...seen.schema };
6569	if (defId) seen.defId = defId;
6570	const schema = seen.schema;
6571	for (const key in schema) delete schema[key];
6572	schema.$ref = ref;
6573	};
6574	if (params.cycles === "throw") for (const entry of this.seen.entries()) {
6575	const seen = entry[1];
6576	if (seen.cycle) throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
6577
6578	Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
6579	}
6580	for (const entry of this.seen.entries()) {
6581	const seen = entry[1];
6582	if (schema === entry[0]) {
6583	extractToDef(entry);
6584	continue;
6585	}
6586	if (params.external) {
6587	const ext = params.external.registry.get(entry[0])?.id;
6588	if (schema !== entry[0] && ext) {
6589	extractToDef(entry);
6590	continue;
6591	}
6592	}
6593	if (this.metadataRegistry.get(entry[0])?.id) {
6594	extractToDef(entry);
6595	continue;
6596	}
6597	if (seen.cycle) {
6598	extractToDef(entry);
6599	continue;
6600	}
6601	if (seen.count > 1) {
6602	if (params.reused === "ref") {
6603	extractToDef(entry);
6604	continue;
6605	}
6606	}
6607	}
6608	const flattenRef = (zodSchema, params) => {
6609	const seen = this.seen.get(zodSchema);
6610	const schema = seen.def ?? seen.schema;
6611	const _cached = { ...schema };
6612	if (seen.ref === null) return;
6613	const ref = seen.ref;
6614	seen.ref = null;
6615	if (ref) {
6616	flattenRef(ref, params);
6617	const refSchema = this.seen.get(ref).schema;
6618	if (refSchema.$ref && params.target === "draft-7") {
6619	schema.allOf = schema.allOf ?? [];
6620	schema.allOf.push(refSchema);
6621	} else {
6622	Object.assign(schema, refSchema);
6623	Object.assign(schema, _cached);
6624	}
6625	}
6626	if (!seen.isParent) this.override({
6627	zodSchema,
6628	jsonSchema: schema,
6629	path: seen.path ?? []
6630	});
6631	};
6632	for (const entry of [...this.seen.entries()].reverse()) flattenRef(entry[0], { target: this.target });
6633	const result = {};
6634	if (this.target === "draft-2020-12") result.$schema = "https://json-schema.org/draft/2020-12/schema";
6635	else if (this.target === "draft-7") result.$schema = "http://json-schema.org/draft-07/schema#";
6636	else console.warn(`Invalid target: ${this.target}`);
6637	if (params.external?.uri) {
6638	const id = params.external.registry.get(schema)?.id;
6639	if (!id) throw new Error("Schema is missing an `id` property");
6640	result.$id = params.external.uri(id);
6641	}
6642	Object.assign(result, root.def);
6643	const defs = params.external?.defs ?? {};
6644	for (const entry of this.seen.entries()) {
6645	const seen = entry[1];
6646	if (seen.def && seen.defId) defs[seen.defId] = seen.def;
6647	}
6648	if (params.external) {} else if (Object.keys(defs).length > 0) if (this.target === "draft-2020-12") result.$defs = defs;
6649	else result.definitions = defs;
6650	try {
6651	return JSON.parse(JSON.stringify(result));
6652	} catch (_err) {
6653	throw new Error("Error converting schema to JSON.");
6654	}
6655	}
6656	};
6657	function toJSONSchema(input, _params) {
6658	if (input instanceof $ZodRegistry) {
6659	const gen = new JSONSchemaGenerator(_params);
6660	const defs = {};
6661	for (const entry of input._idmap.entries()) {
6662	const [_, schema] = entry;
6663	gen.process(schema);
6664	}
6665	const schemas = {};
6666	const external = {
6667	registry: input,
6668	uri: _params?.uri,
6669	defs
6670	};
6671	for (const entry of input._idmap.entries()) {
6672	const [key, schema] = entry;
6673	schemas[key] = gen.emit(schema, {
6674	..._params,
6675	external
6676	});
6677	}
6678	if (Object.keys(defs).length > 0) schemas.__shared = { [gen.target === "draft-2020-12" ? "$defs" : "definitions"]: defs };
6679	return { schemas };
6680	}
6681	const gen = new JSONSchemaGenerator(_params);
6682	gen.process(input);
6683	return gen.emit(input, _params);
6684	}
6685	function isTransforming(_schema, _ctx) {
6686	const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
6687	if (ctx.seen.has(_schema)) return false;
6688	ctx.seen.add(_schema);
6689	const def = _schema._zod.def;
6690	switch (def.type) {
6691	case "string":
6692	case "number":
6693	case "bigint":
6694	case "boolean":
6695	case "date":
6696	case "symbol":
6697	case "undefined":
6698	case "null":
6699	case "any":
6700	case "unknown":
6701	case "never":
6702	case "void":
6703	case "literal":
6704	case "enum":
6705	case "nan":
6706	case "file":
6707	case "template_literal": return false;
6708	case "array": return isTransforming(def.element, ctx);
6709	case "object":
6710	for (const key in def.shape) if (isTransforming(def.shape[key], ctx)) return true;
6711	return false;
6712	case "union":
6713	for (const option of def.options) if (isTransforming(option, ctx)) return true;
6714	return false;
6715	case "intersection": return isTransforming(def.left, ctx) \|\| isTransforming(def.right, ctx);
6716	case "tuple":
6717	for (const item of def.items) if (isTransforming(item, ctx)) return true;
6718	if (def.rest && isTransforming(def.rest, ctx)) return true;
6719	return false;
6720	case "record": return isTransforming(def.keyType, ctx) \|\| isTransforming(def.valueType, ctx);
6721	case "map": return isTransforming(def.keyType, ctx) \|\| isTransforming(def.valueType, ctx);
6722	case "set": return isTransforming(def.valueType, ctx);
6723	case "promise":
6724	case "optional":
6725	case "nonoptional":
6726	case "nullable":
6727	case "readonly": return isTransforming(def.innerType, ctx);
6728	case "lazy": return isTransforming(def.getter(), ctx);
6729	case "default": return isTransforming(def.innerType, ctx);
6730	case "prefault": return isTransforming(def.innerType, ctx);
6731	case "custom": return false;
6732	case "transform": return true;
6733	case "pipe": return isTransforming(def.in, ctx) \|\| isTransforming(def.out, ctx);
6734	case "success": return false;
6735	case "catch": return false;
6736	default:
6737	}
6738	throw new Error(`Unknown schema type: ${def.type}`);
6739	}
6740
6741	//#endregion
6742	//#region node_modules/zod/v4/mini/schemas.js
6743	var ZodMiniType = /@__PURE__/ $constructor("ZodMiniType", (inst, def) => {
6744	if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");
6745	$ZodType.init(inst, def);
6746	inst.def = def;
6747	inst.parse = (data, params) => parse$1(inst, data, params, { callee: inst.parse });
6748	inst.safeParse = (data, params) => safeParse$2(inst, data, params);
6749	inst.parseAsync = async (data, params) => parseAsync$1(inst, data, params, { callee: inst.parseAsync });
6750	inst.safeParseAsync = async (data, params) => safeParseAsync$2(inst, data, params);
6751	inst.check = (...checks) => {
6752	return inst.clone({
6753	...def,
6754	checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
6755	check: ch,
6756	def: { check: "custom" },
6757	onattach: []
6758	} } : ch)]
6759	});
6760	};
6761	inst.clone = (_def, params) => clone(inst, _def, params);
6762	inst.brand = () => inst;
6763	inst.register = ((reg, meta) => {
6764	reg.add(inst, meta);
6765	return inst;
6766	});
6767	});
6768	var ZodMiniObject = /@__PURE__/ $constructor("ZodMiniObject", (inst, def) => {
6769	$ZodObject.init(inst, def);
6770	ZodMiniType.init(inst, def);
6771	defineLazy(inst, "shape", () => def.shape);
6772	});
6773	function object$1(shape, params) {
6774	const def = {
6775	type: "object",
6776	get shape() {
6777	assignProp(this, "shape", { ...shape });
6778	return this.shape;
6779	},
6780	...normalizeParams(params)
6781	};
6782	return new ZodMiniObject(def);
6783	}
6784	__name(object$1, "object");
6785
6786	//#endregion
6787	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
6788	function isZ4Schema(s) {
6789	return !!s._zod;
6790	}
6791	function objectFromShape(shape) {
6792	const values = Object.values(shape);
6793	if (values.length === 0) return object$1({});
6794	const allV4 = values.every(isZ4Schema);
6795	const allV3 = values.every((s) => !isZ4Schema(s));
6796	if (allV4) return object$1(shape);
6797	if (allV3) return objectType(shape);
6798	throw new Error("Mixed Zod versions detected in object shape.");
6799	}
6800	function safeParse$1(schema, data) {
6801	if (isZ4Schema(schema)) return safeParse$2(schema, data);
6802	return schema.safeParse(data);
6803	}
6804	__name(safeParse$1, "safeParse");
6805	async function safeParseAsync$1(schema, data) {
6806	if (isZ4Schema(schema)) return await safeParseAsync$2(schema, data);
6807	return await schema.safeParseAsync(data);
6808	}
6809	__name(safeParseAsync$1, "safeParseAsync");
6810	function getObjectShape(schema) {
6811	if (!schema) return void 0;
6812	let rawShape;
6813	if (isZ4Schema(schema)) rawShape = schema._zod?.def?.shape;
6814	else rawShape = schema.shape;
6815	if (!rawShape) return void 0;
6816	if (typeof rawShape === "function") try {
6817	return rawShape();
6818	} catch {
6819	return;
6820	}
6821	return rawShape;
6822	}
6823	/**
6824	* Normalizes a schema to an object schema. Handles both:
6825	* - Already-constructed object schemas (v3 or v4)
6826	* - Raw shapes that need to be wrapped into object schemas
6827	*/
6828	function normalizeObjectSchema(schema) {
6829	if (!schema) return void 0;
6830	if (typeof schema === "object") {
6831	const asV3 = schema;
6832	const asV4 = schema;
6833	if (!asV3._def && !asV4._zod) {
6834	const values = Object.values(schema);
6835	if (values.length > 0 && values.every((v) => typeof v === "object" && v !== null && (v._def !== void 0 \|\| v._zod !== void 0 \|\| typeof v.parse === "function"))) return objectFromShape(schema);
6836	}
6837	}
6838	if (isZ4Schema(schema)) {
6839	const def = schema._zod?.def;
6840	if (def && (def.type === "object" \|\| def.shape !== void 0)) return schema;
6841	} else if (schema.shape !== void 0) return schema;
6842	}
6843	/**
6844	* Safely extracts an error message from a parse result error.
6845	* Zod errors can have different structures, so we handle various cases.
6846	*/
6847	function getParseErrorMessage(error) {
6848	if (error && typeof error === "object") {
6849	if ("message" in error && typeof error.message === "string") return error.message;
6850	if ("issues" in error && Array.isArray(error.issues) && error.issues.length > 0) {
6851	const firstIssue = error.issues[0];
6852	if (firstIssue && typeof firstIssue === "object" && "message" in firstIssue) return String(firstIssue.message);
6853	}
6854	try {
6855	return JSON.stringify(error);
6856	} catch {
6857	return String(error);
6858	}
6859	}
6860	return String(error);
6861	}
6862	/**
6863	* Gets the description from a schema, if available.
6864	* Works with both Zod v3 and v4.
6865	*
6866	* Both versions expose a `.description` getter that returns the description
6867	* from their respective internal storage (v3: _def, v4: globalRegistry).
6868	*/
6869	function getSchemaDescription(schema) {
6870	return schema.description;
6871	}
6872	/**
6873	* Checks if a schema is optional.
6874	* Works with both Zod v3 and v4.
6875	*/
6876	function isSchemaOptional(schema) {
6877	if (isZ4Schema(schema)) return schema._zod?.def?.type === "optional";
6878	const v3Schema = schema;
6879	if (typeof schema.isOptional === "function") return schema.isOptional();
6880	return v3Schema._def?.typeName === "ZodOptional";
6881	}
6882	/**
6883	* Gets the literal value from a schema, if it's a literal schema.
6884	* Works with both Zod v3 and v4.
6885	* Returns undefined if the schema is not a literal or the value cannot be determined.
6886	*/
6887	function getLiteralValue(schema) {
6888	if (isZ4Schema(schema)) {
6889	const def = schema._zod?.def;
6890	if (def) {
6891	if (def.value !== void 0) return def.value;
6892	if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
6893	}
6894	}
6895	const def = schema._def;
6896	if (def) {
6897	if (def.value !== void 0) return def.value;
6898	if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
6899	}
6900	const directValue = schema.value;
6901	if (directValue !== void 0) return directValue;
6902	}
6903
6904	//#endregion
6905	//#region node_modules/zod/v4/classic/iso.js
6906	var ZodISODateTime = /@__PURE__/ $constructor("ZodISODateTime", (inst, def) => {
6907	$ZodISODateTime.init(inst, def);
6908	ZodStringFormat.init(inst, def);
6909	});
6910	function datetime(params) {
6911	return _isoDateTime(ZodISODateTime, params);
6912	}
6913	var ZodISODate = /@__PURE__/ $constructor("ZodISODate", (inst, def) => {
6914	$ZodISODate.init(inst, def);
6915	ZodStringFormat.init(inst, def);
6916	});
6917	function date(params) {
6918	return _isoDate(ZodISODate, params);
6919	}
6920	var ZodISOTime = /@__PURE__/ $constructor("ZodISOTime", (inst, def) => {
6921	$ZodISOTime.init(inst, def);
6922	ZodStringFormat.init(inst, def);
6923	});
6924	function time(params) {
6925	return _isoTime(ZodISOTime, params);
6926	}
6927	var ZodISODuration = /@__PURE__/ $constructor("ZodISODuration", (inst, def) => {
6928	$ZodISODuration.init(inst, def);
6929	ZodStringFormat.init(inst, def);
6930	});
6931	function duration(params) {
6932	return _isoDuration(ZodISODuration, params);
6933	}
6934
6935	//#endregion
6936	//#region node_modules/zod/v4/classic/errors.js
6937	var initializer = (inst, issues) => {
6938	$ZodError.init(inst, issues);
6939	inst.name = "ZodError";
6940	Object.defineProperties(inst, {
6941	format: { value: (mapper) => formatError(inst, mapper) },
6942	flatten: { value: (mapper) => flattenError(inst, mapper) },
6943	addIssue: { value: (issue) => inst.issues.push(issue) },
6944	addIssues: { value: (issues) => inst.issues.push(...issues) },
6945	isEmpty: { get() {
6946	return inst.issues.length === 0;
6947	} }
6948	});
6949	};
6950	var ZodError = $constructor("ZodError", initializer);
6951	var ZodRealError = $constructor("ZodError", initializer, { Parent: Error });
6952
6953	//#endregion
6954	//#region node_modules/zod/v4/classic/parse.js
6955	var parse = /* @__PURE__ */ _parse(ZodRealError);
6956	var parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
6957	var safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
6958	var safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
6959
6960	//#endregion
6961	//#region node_modules/zod/v4/classic/schemas.js
6962	var ZodType = /@__PURE__/ $constructor("ZodType", (inst, def) => {
6963	$ZodType.init(inst, def);
6964	inst.def = def;
6965	Object.defineProperty(inst, "_def", { value: def });
6966	inst.check = (...checks) => {
6967	return inst.clone({
6968	...def,
6969	checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
6970	check: ch,
6971	def: { check: "custom" },
6972	onattach: []
6973	} } : ch)]
6974	});
6975	};
6976	inst.clone = (def, params) => clone(inst, def, params);
6977	inst.brand = () => inst;
6978	inst.register = ((reg, meta) => {
6979	reg.add(inst, meta);
6980	return inst;
6981	});
6982	inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
6983	inst.safeParse = (data, params) => safeParse(inst, data, params);
6984	inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
6985	inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
6986	inst.spa = inst.safeParseAsync;
6987	inst.refine = (check, params) => inst.check(refine(check, params));
6988	inst.superRefine = (refinement) => inst.check(superRefine(refinement));
6989	inst.overwrite = (fn) => inst.check(_overwrite(fn));
6990	inst.optional = () => optional(inst);
6991	inst.nullable = () => nullable(inst);
6992	inst.nullish = () => optional(nullable(inst));
6993	inst.nonoptional = (params) => nonoptional(inst, params);
6994	inst.array = () => array(inst);
6995	inst.or = (arg) => union([inst, arg]);
6996	inst.and = (arg) => intersection(inst, arg);
6997	inst.transform = (tx) => pipe(inst, transform(tx));
6998	inst.default = (def) => _default(inst, def);
6999	inst.prefault = (def) => prefault(inst, def);
7000	inst.catch = (params) => _catch(inst, params);
7001	inst.pipe = (target) => pipe(inst, target);
7002	inst.readonly = () => readonly(inst);
7003	inst.describe = (description) => {
7004	const cl = inst.clone();
7005	globalRegistry.add(cl, { description });
7006	return cl;
7007	};
7008	Object.defineProperty(inst, "description", {
7009	get() {
7010	return globalRegistry.get(inst)?.description;
7011	},
7012	configurable: true
7013	});
7014	inst.meta = (...args) => {
7015	if (args.length === 0) return globalRegistry.get(inst);
7016	const cl = inst.clone();
7017	globalRegistry.add(cl, args[0]);
7018	return cl;
7019	};
7020	inst.isOptional = () => inst.safeParse(void 0).success;
7021	inst.isNullable = () => inst.safeParse(null).success;
7022	return inst;
7023	});
7024	/** @internal */
7025	var _ZodString = /@__PURE__/ $constructor("_ZodString", (inst, def) => {
7026	$ZodString.init(inst, def);
7027	ZodType.init(inst, def);
7028	const bag = inst._zod.bag;
7029	inst.format = bag.format ?? null;
7030	inst.minLength = bag.minimum ?? null;
7031	inst.maxLength = bag.maximum ?? null;
7032	inst.regex = (...args) => inst.check(_regex(...args));
7033	inst.includes = (...args) => inst.check(_includes(...args));
7034	inst.startsWith = (...args) => inst.check(_startsWith(...args));
7035	inst.endsWith = (...args) => inst.check(_endsWith(...args));
7036	inst.min = (...args) => inst.check(_minLength(...args));
7037	inst.max = (...args) => inst.check(_maxLength(...args));
7038	inst.length = (...args) => inst.check(_length(...args));
7039	inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
7040	inst.lowercase = (params) => inst.check(_lowercase(params));
7041	inst.uppercase = (params) => inst.check(_uppercase(params));
7042	inst.trim = () => inst.check(_trim());
7043	inst.normalize = (...args) => inst.check(_normalize(...args));
7044	inst.toLowerCase = () => inst.check(_toLowerCase());
7045	inst.toUpperCase = () => inst.check(_toUpperCase());
7046	});
7047	var ZodString = /@__PURE__/ $constructor("ZodString", (inst, def) => {
7048	$ZodString.init(inst, def);
7049	_ZodString.init(inst, def);
7050	inst.email = (params) => inst.check(_email(ZodEmail, params));
7051	inst.url = (params) => inst.check(_url(ZodURL, params));
7052	inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
7053	inst.emoji = (params) => inst.check(_emoji(ZodEmoji, params));
7054	inst.guid = (params) => inst.check(_guid(ZodGUID, params));
7055	inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
7056	inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
7057	inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
7058	inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
7059	inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
7060	inst.guid = (params) => inst.check(_guid(ZodGUID, params));
7061	inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
7062	inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
7063	inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
7064	inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
7065	inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
7066	inst.xid = (params) => inst.check(_xid(ZodXID, params));
7067	inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
7068	inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
7069	inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
7070	inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
7071	inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
7072	inst.e164 = (params) => inst.check(_e164(ZodE164, params));
7073	inst.datetime = (params) => inst.check(datetime(params));
7074	inst.date = (params) => inst.check(date(params));
7075	inst.time = (params) => inst.check(time(params));
7076	inst.duration = (params) => inst.check(duration(params));
7077	});
7078	function string(params) {
7079	return _string(ZodString, params);
7080	}
7081	var ZodStringFormat = /@__PURE__/ $constructor("ZodStringFormat", (inst, def) => {
7082	$ZodStringFormat.init(inst, def);
7083	_ZodString.init(inst, def);
7084	});
7085	var ZodEmail = /@__PURE__/ $constructor("ZodEmail", (inst, def) => {
7086	$ZodEmail.init(inst, def);
7087	ZodStringFormat.init(inst, def);
7088	});
7089	var ZodGUID = /@__PURE__/ $constructor("ZodGUID", (inst, def) => {
7090	$ZodGUID.init(inst, def);
7091	ZodStringFormat.init(inst, def);
7092	});
7093	var ZodUUID = /@__PURE__/ $constructor("ZodUUID", (inst, def) => {
7094	$ZodUUID.init(inst, def);
7095	ZodStringFormat.init(inst, def);
7096	});
7097	var ZodURL = /@__PURE__/ $constructor("ZodURL", (inst, def) => {
7098	$ZodURL.init(inst, def);
7099	ZodStringFormat.init(inst, def);
7100	});
7101	var ZodEmoji = /@__PURE__/ $constructor("ZodEmoji", (inst, def) => {
7102	$ZodEmoji.init(inst, def);
7103	ZodStringFormat.init(inst, def);
7104	});
7105	var ZodNanoID = /@__PURE__/ $constructor("ZodNanoID", (inst, def) => {
7106	$ZodNanoID.init(inst, def);
7107	ZodStringFormat.init(inst, def);
7108	});
7109	var ZodCUID = /@__PURE__/ $constructor("ZodCUID", (inst, def) => {
7110	$ZodCUID.init(inst, def);
7111	ZodStringFormat.init(inst, def);
7112	});
7113	var ZodCUID2 = /@__PURE__/ $constructor("ZodCUID2", (inst, def) => {
7114	$ZodCUID2.init(inst, def);
7115	ZodStringFormat.init(inst, def);
7116	});
7117	var ZodULID = /@__PURE__/ $constructor("ZodULID", (inst, def) => {
7118	$ZodULID.init(inst, def);
7119	ZodStringFormat.init(inst, def);
7120	});
7121	var ZodXID = /@__PURE__/ $constructor("ZodXID", (inst, def) => {
7122	$ZodXID.init(inst, def);
7123	ZodStringFormat.init(inst, def);
7124	});
7125	var ZodKSUID = /@__PURE__/ $constructor("ZodKSUID", (inst, def) => {
7126	$ZodKSUID.init(inst, def);
7127	ZodStringFormat.init(inst, def);
7128	});
7129	var ZodIPv4 = /@__PURE__/ $constructor("ZodIPv4", (inst, def) => {
7130	$ZodIPv4.init(inst, def);
7131	ZodStringFormat.init(inst, def);
7132	});
7133	var ZodIPv6 = /@__PURE__/ $constructor("ZodIPv6", (inst, def) => {
7134	$ZodIPv6.init(inst, def);
7135	ZodStringFormat.init(inst, def);
7136	});
7137	var ZodCIDRv4 = /@__PURE__/ $constructor("ZodCIDRv4", (inst, def) => {
7138	$ZodCIDRv4.init(inst, def);
7139	ZodStringFormat.init(inst, def);
7140	});
7141	var ZodCIDRv6 = /@__PURE__/ $constructor("ZodCIDRv6", (inst, def) => {
7142	$ZodCIDRv6.init(inst, def);
7143	ZodStringFormat.init(inst, def);
7144	});
7145	var ZodBase64 = /@__PURE__/ $constructor("ZodBase64", (inst, def) => {
7146	$ZodBase64.init(inst, def);
7147	ZodStringFormat.init(inst, def);
7148	});
7149	var ZodBase64URL = /@__PURE__/ $constructor("ZodBase64URL", (inst, def) => {
7150	$ZodBase64URL.init(inst, def);
7151	ZodStringFormat.init(inst, def);
7152	});
7153	var ZodE164 = /@__PURE__/ $constructor("ZodE164", (inst, def) => {
7154	$ZodE164.init(inst, def);
7155	ZodStringFormat.init(inst, def);
7156	});
7157	var ZodJWT = /@__PURE__/ $constructor("ZodJWT", (inst, def) => {
7158	$ZodJWT.init(inst, def);
7159	ZodStringFormat.init(inst, def);
7160	});
7161	var ZodNumber = /@__PURE__/ $constructor("ZodNumber", (inst, def) => {
7162	$ZodNumber.init(inst, def);
7163	ZodType.init(inst, def);
7164	inst.gt = (value, params) => inst.check(_gt(value, params));
7165	inst.gte = (value, params) => inst.check(_gte(value, params));
7166	inst.min = (value, params) => inst.check(_gte(value, params));
7167	inst.lt = (value, params) => inst.check(_lt(value, params));
7168	inst.lte = (value, params) => inst.check(_lte(value, params));
7169	inst.max = (value, params) => inst.check(_lte(value, params));
7170	inst.int = (params) => inst.check(int(params));
7171	inst.safe = (params) => inst.check(int(params));
7172	inst.positive = (params) => inst.check(_gt(0, params));
7173	inst.nonnegative = (params) => inst.check(_gte(0, params));
7174	inst.negative = (params) => inst.check(_lt(0, params));
7175	inst.nonpositive = (params) => inst.check(_lte(0, params));
7176	inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
7177	inst.step = (value, params) => inst.check(_multipleOf(value, params));
7178	inst.finite = () => inst;
7179	const bag = inst._zod.bag;
7180	inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
7181	inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
7182	inst.isInt = (bag.format ?? "").includes("int") \|\| Number.isSafeInteger(bag.multipleOf ?? .5);
7183	inst.isFinite = true;
7184	inst.format = bag.format ?? null;
7185	});
7186	function number(params) {
7187	return _number(ZodNumber, params);
7188	}
7189	var ZodNumberFormat = /@__PURE__/ $constructor("ZodNumberFormat", (inst, def) => {
7190	$ZodNumberFormat.init(inst, def);
7191	ZodNumber.init(inst, def);
7192	});
7193	function int(params) {
7194	return _int(ZodNumberFormat, params);
7195	}
7196	var ZodBoolean = /@__PURE__/ $constructor("ZodBoolean", (inst, def) => {
7197	$ZodBoolean.init(inst, def);
7198	ZodType.init(inst, def);
7199	});
7200	function boolean(params) {
7201	return _boolean(ZodBoolean, params);
7202	}
7203	var ZodNull = /@__PURE__/ $constructor("ZodNull", (inst, def) => {
7204	$ZodNull.init(inst, def);
7205	ZodType.init(inst, def);
7206	});
7207	function _null(params) {
7208	return _null$1(ZodNull, params);
7209	}
7210	var ZodUnknown = /@__PURE__/ $constructor("ZodUnknown", (inst, def) => {
7211	$ZodUnknown.init(inst, def);
7212	ZodType.init(inst, def);
7213	});
7214	function unknown() {
7215	return _unknown(ZodUnknown);
7216	}
7217	var ZodNever = /@__PURE__/ $constructor("ZodNever", (inst, def) => {
7218	$ZodNever.init(inst, def);
7219	ZodType.init(inst, def);
7220	});
7221	function never(params) {
7222	return _never(ZodNever, params);
7223	}
7224	var ZodArray = /@__PURE__/ $constructor("ZodArray", (inst, def) => {
7225	$ZodArray.init(inst, def);
7226	ZodType.init(inst, def);
7227	inst.element = def.element;
7228	inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
7229	inst.nonempty = (params) => inst.check(_minLength(1, params));
7230	inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
7231	inst.length = (len, params) => inst.check(_length(len, params));
7232	inst.unwrap = () => inst.element;
7233	});
7234	function array(element, params) {
7235	return _array(ZodArray, element, params);
7236	}
7237	var ZodObject = /@__PURE__/ $constructor("ZodObject", (inst, def) => {
7238	$ZodObject.init(inst, def);
7239	ZodType.init(inst, def);
7240	defineLazy(inst, "shape", () => def.shape);
7241	inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
7242	inst.catchall = (catchall) => inst.clone({
7243	...inst._zod.def,
7244	catchall
7245	});
7246	inst.passthrough = () => inst.clone({
7247	...inst._zod.def,
7248	catchall: unknown()
7249	});
7250	inst.loose = () => inst.clone({
7251	...inst._zod.def,
7252	catchall: unknown()
7253	});
7254	inst.strict = () => inst.clone({
7255	...inst._zod.def,
7256	catchall: never()
7257	});
7258	inst.strip = () => inst.clone({
7259	...inst._zod.def,
7260	catchall: void 0
7261	});
7262	inst.extend = (incoming) => {
7263	return extend(inst, incoming);
7264	};
7265	inst.merge = (other) => merge(inst, other);
7266	inst.pick = (mask) => pick(inst, mask);
7267	inst.omit = (mask) => omit(inst, mask);
7268	inst.partial = (...args) => partial(ZodOptional, inst, args[0]);
7269	inst.required = (...args) => required$1(ZodNonOptional, inst, args[0]);
7270	});
7271	function object(shape, params) {
7272	const def = {
7273	type: "object",
7274	get shape() {
7275	assignProp(this, "shape", { ...shape });
7276	return this.shape;
7277	},
7278	...normalizeParams(params)
7279	};
7280	return new ZodObject(def);
7281	}
7282	function looseObject(shape, params) {
7283	return new ZodObject({
7284	type: "object",
7285	get shape() {
7286	assignProp(this, "shape", { ...shape });
7287	return this.shape;
7288	},
7289	catchall: unknown(),
7290	...normalizeParams(params)
7291	});
7292	}
7293	var ZodUnion = /@__PURE__/ $constructor("ZodUnion", (inst, def) => {
7294	$ZodUnion.init(inst, def);
7295	ZodType.init(inst, def);
7296	inst.options = def.options;
7297	});
7298	function union(options, params) {
7299	return new ZodUnion({
7300	type: "union",
7301	options,
7302	...normalizeParams(params)
7303	});
7304	}
7305	var ZodDiscriminatedUnion = /@__PURE__/ $constructor("ZodDiscriminatedUnion", (inst, def) => {
7306	ZodUnion.init(inst, def);
7307	$ZodDiscriminatedUnion.init(inst, def);
7308	});
7309	function discriminatedUnion(discriminator, options, params) {
7310	return new ZodDiscriminatedUnion({
7311	type: "union",
7312	options,
7313	discriminator,
7314	...normalizeParams(params)
7315	});
7316	}
7317	var ZodIntersection = /@__PURE__/ $constructor("ZodIntersection", (inst, def) => {
7318	$ZodIntersection.init(inst, def);
7319	ZodType.init(inst, def);
7320	});
7321	function intersection(left, right) {
7322	return new ZodIntersection({
7323	type: "intersection",
7324	left,
7325	right
7326	});
7327	}
7328	var ZodRecord = /@__PURE__/ $constructor("ZodRecord", (inst, def) => {
7329	$ZodRecord.init(inst, def);
7330	ZodType.init(inst, def);
7331	inst.keyType = def.keyType;
7332	inst.valueType = def.valueType;
7333	});
7334	function record(keyType, valueType, params) {
7335	return new ZodRecord({
7336	type: "record",
7337	keyType,
7338	valueType,
7339	...normalizeParams(params)
7340	});
7341	}
7342	var ZodEnum = /@__PURE__/ $constructor("ZodEnum", (inst, def) => {
7343	$ZodEnum.init(inst, def);
7344	ZodType.init(inst, def);
7345	inst.enum = def.entries;
7346	inst.options = Object.values(def.entries);
7347	const keys = new Set(Object.keys(def.entries));
7348	inst.extract = (values, params) => {
7349	const newEntries = {};
7350	for (const value of values) if (keys.has(value)) newEntries[value] = def.entries[value];
7351	else throw new Error(`Key ${value} not found in enum`);
7352	return new ZodEnum({
7353	...def,
7354	checks: [],
7355	...normalizeParams(params),
7356	entries: newEntries
7357	});
7358	};
7359	inst.exclude = (values, params) => {
7360	const newEntries = { ...def.entries };
7361	for (const value of values) if (keys.has(value)) delete newEntries[value];
7362	else throw new Error(`Key ${value} not found in enum`);
7363	return new ZodEnum({
7364	...def,
7365	checks: [],
7366	...normalizeParams(params),
7367	entries: newEntries
7368	});
7369	};
7370	});
7371	function _enum(values, params) {
7372	const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
7373	return new ZodEnum({
7374	type: "enum",
7375	entries,
7376	...normalizeParams(params)
7377	});
7378	}
7379	var ZodLiteral = /@__PURE__/ $constructor("ZodLiteral", (inst, def) => {
7380	$ZodLiteral.init(inst, def);
7381	ZodType.init(inst, def);
7382	inst.values = new Set(def.values);
7383	Object.defineProperty(inst, "value", { get() {
7384	if (def.values.length > 1) throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
7385	return def.values[0];
7386	} });
7387	});
7388	function literal(value, params) {
7389	return new ZodLiteral({
7390	type: "literal",
7391	values: Array.isArray(value) ? value : [value],
7392	...normalizeParams(params)
7393	});
7394	}
7395	var ZodTransform = /@__PURE__/ $constructor("ZodTransform", (inst, def) => {
7396	$ZodTransform.init(inst, def);
7397	ZodType.init(inst, def);
7398	inst._zod.parse = (payload, _ctx) => {
7399	payload.addIssue = (issue$2) => {
7400	if (typeof issue$2 === "string") payload.issues.push(issue(issue$2, payload.value, def));
7401	else {
7402	const _issue = issue$2;
7403	if (_issue.fatal) _issue.continue = false;
7404	_issue.code ?? (_issue.code = "custom");
7405	_issue.input ?? (_issue.input = payload.value);
7406	_issue.inst ?? (_issue.inst = inst);
7407	_issue.continue ?? (_issue.continue = true);
7408	payload.issues.push(issue(_issue));
7409	}
7410	};
7411	const output = def.transform(payload.value, payload);
7412	if (output instanceof Promise) return output.then((output) => {
7413	payload.value = output;
7414	return payload;
7415	});
7416	payload.value = output;
7417	return payload;
7418	};
7419	});
7420	function transform(fn) {
7421	return new ZodTransform({
7422	type: "transform",
7423	transform: fn
7424	});
7425	}
7426	var ZodOptional = /@__PURE__/ $constructor("ZodOptional", (inst, def) => {
7427	$ZodOptional.init(inst, def);
7428	ZodType.init(inst, def);
7429	inst.unwrap = () => inst._zod.def.innerType;
7430	});
7431	function optional(innerType) {
7432	return new ZodOptional({
7433	type: "optional",
7434	innerType
7435	});
7436	}
7437	var ZodNullable = /@__PURE__/ $constructor("ZodNullable", (inst, def) => {
7438	$ZodNullable.init(inst, def);
7439	ZodType.init(inst, def);
7440	inst.unwrap = () => inst._zod.def.innerType;
7441	});
7442	function nullable(innerType) {
7443	return new ZodNullable({
7444	type: "nullable",
7445	innerType
7446	});
7447	}
7448	var ZodDefault = /@__PURE__/ $constructor("ZodDefault", (inst, def) => {
7449	$ZodDefault.init(inst, def);
7450	ZodType.init(inst, def);
7451	inst.unwrap = () => inst._zod.def.innerType;
7452	inst.removeDefault = inst.unwrap;
7453	});
7454	function _default(innerType, defaultValue) {
7455	return new ZodDefault({
7456	type: "default",
7457	innerType,
7458	get defaultValue() {
7459	return typeof defaultValue === "function" ? defaultValue() : defaultValue;
7460	}
7461	});
7462	}
7463	var ZodPrefault = /@__PURE__/ $constructor("ZodPrefault", (inst, def) => {
7464	$ZodPrefault.init(inst, def);
7465	ZodType.init(inst, def);
7466	inst.unwrap = () => inst._zod.def.innerType;
7467	});
7468	function prefault(innerType, defaultValue) {
7469	return new ZodPrefault({
7470	type: "prefault",
7471	innerType,
7472	get defaultValue() {
7473	return typeof defaultValue === "function" ? defaultValue() : defaultValue;
7474	}
7475	});
7476	}
7477	var ZodNonOptional = /@__PURE__/ $constructor("ZodNonOptional", (inst, def) => {
7478	$ZodNonOptional.init(inst, def);
7479	ZodType.init(inst, def);
7480	inst.unwrap = () => inst._zod.def.innerType;
7481	});
7482	function nonoptional(innerType, params) {
7483	return new ZodNonOptional({
7484	type: "nonoptional",
7485	innerType,
7486	...normalizeParams(params)
7487	});
7488	}
7489	var ZodCatch = /@__PURE__/ $constructor("ZodCatch", (inst, def) => {
7490	$ZodCatch.init(inst, def);
7491	ZodType.init(inst, def);
7492	inst.unwrap = () => inst._zod.def.innerType;
7493	inst.removeCatch = inst.unwrap;
7494	});
7495	function _catch(innerType, catchValue) {
7496	return new ZodCatch({
7497	type: "catch",
7498	innerType,
7499	catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
7500	});
7501	}
7502	var ZodPipe = /@__PURE__/ $constructor("ZodPipe", (inst, def) => {
7503	$ZodPipe.init(inst, def);
7504	ZodType.init(inst, def);
7505	inst.in = def.in;
7506	inst.out = def.out;
7507	});
7508	function pipe(in_, out) {
7509	return new ZodPipe({
7510	type: "pipe",
7511	in: in_,
7512	out
7513	});
7514	}
7515	var ZodReadonly = /@__PURE__/ $constructor("ZodReadonly", (inst, def) => {
7516	$ZodReadonly.init(inst, def);
7517	ZodType.init(inst, def);
7518	});
7519	function readonly(innerType) {
7520	return new ZodReadonly({
7521	type: "readonly",
7522	innerType
7523	});
7524	}
7525	var ZodCustom = /@__PURE__/ $constructor("ZodCustom", (inst, def) => {
7526	$ZodCustom.init(inst, def);
7527	ZodType.init(inst, def);
7528	});
7529	function check(fn) {
7530	const ch = new $ZodCheck({ check: "custom" });
7531	ch._zod.check = fn;
7532	return ch;
7533	}
7534	function custom(fn, _params) {
7535	return _custom(ZodCustom, fn ?? (() => true), _params);
7536	}
7537	function refine(fn, _params = {}) {
7538	return _refine(ZodCustom, fn, _params);
7539	}
7540	function superRefine(fn) {
7541	const ch = check((payload) => {
7542	payload.addIssue = (issue$1) => {
7543	if (typeof issue$1 === "string") payload.issues.push(issue(issue$1, payload.value, ch._zod.def));
7544	else {
7545	const _issue = issue$1;
7546	if (_issue.fatal) _issue.continue = false;
7547	_issue.code ?? (_issue.code = "custom");
7548	_issue.input ?? (_issue.input = payload.value);
7549	_issue.inst ?? (_issue.inst = ch);
7550	_issue.continue ?? (_issue.continue = !ch._zod.def.abort);
7551	payload.issues.push(issue(_issue));
7552	}
7553	};
7554	return fn(payload.value, payload);
7555	});
7556	return ch;
7557	}
7558	function preprocess(fn, schema) {
7559	return pipe(transform(fn), schema);
7560	}
7561
7562	//#endregion
7563	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
7564	var LATEST_PROTOCOL_VERSION = "2025-11-25";
7565	var SUPPORTED_PROTOCOL_VERSIONS = [
7566	LATEST_PROTOCOL_VERSION,
7567	"2025-06-18",
7568	"2025-03-26",
7569	"2024-11-05",
7570	"2024-10-07"
7571	];
7572	var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
7573	var JSONRPC_VERSION = "2.0";
7574	/**
7575	* Assert 'object' type schema.
7576	*
7577	* @internal
7578	*/
7579	var AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" \|\| typeof v === "function"));
7580	/**
7581	* A progress token, used to associate progress notifications with the original request.
7582	*/
7583	var ProgressTokenSchema = union([string(), number().int()]);
7584	/**
7585	* An opaque token used to represent a cursor for pagination.
7586	*/
7587	var CursorSchema = string();
7588	/**
7589	* Task creation parameters, used to ask that the server create a task to represent a request.
7590	*/
7591	var TaskCreationParamsSchema = looseObject({
7592	/**
7593	* Time in milliseconds to keep task results available after completion.
7594	* If null, the task has unlimited lifetime until manually cleaned up.
7595	*/
7596	ttl: union([number(), _null()]).optional(),
7597	/**
7598	* Time in milliseconds to wait between task status requests.
7599	*/
7600	pollInterval: number().optional()
7601	});
7602	var TaskMetadataSchema = object({ ttl: number().optional() });
7603	/**
7604	* Metadata for associating messages with a task.
7605	* Include this in the `_meta` field under the key `io.modelcontextprotocol/related-task`.
7606	*/
7607	var RelatedTaskMetadataSchema = object({ taskId: string() });
7608	var RequestMetaSchema = looseObject({
7609	/**
7610	* If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
7611	*/
7612	progressToken: ProgressTokenSchema.optional(),
7613	/**
7614	* If specified, this request is related to the provided task.
7615	*/
7616	[RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
7617	});
7618	/**
7619	* Common params for any request.
7620	*/
7621	var BaseRequestParamsSchema = object({
7622	/**
7623	* See [General fields: `_meta`](/specification/draft/basic/index#meta) for notes on `_meta` usage.
7624	*/
7625	_meta: RequestMetaSchema.optional() });
7626	/**
7627	* Common params for any task-augmented request.
7628	*/
7629	var TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({
7630	/**
7631	* If specified, the caller is requesting task-augmented execution for this request.
7632	* The request will return a CreateTaskResult immediately, and the actual result can be
7633	* retrieved later via tasks/result.
7634	*
7635	* Task augmentation is subject to capability negotiation - receivers MUST declare support
7636	* for task augmentation of specific request types in their capabilities.
7637	*/
7638	task: TaskMetadataSchema.optional() });
7639	/**
7640	* Checks if a value is a valid TaskAugmentedRequestParams.
7641	* @param value - The value to check.
7642	*
7643	* @returns True if the value is a valid TaskAugmentedRequestParams, false otherwise.
7644	*/
7645	var isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success;
7646	var RequestSchema = object({
7647	method: string(),
7648	params: BaseRequestParamsSchema.loose().optional()
7649	});
7650	var NotificationsParamsSchema = object({
7651	/**
7652	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
7653	* for notes on _meta usage.
7654	*/
7655	_meta: RequestMetaSchema.optional() });
7656	var NotificationSchema = object({
7657	method: string(),
7658	params: NotificationsParamsSchema.loose().optional()
7659	});
7660	var ResultSchema = looseObject({
7661	/**
7662	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
7663	* for notes on _meta usage.
7664	*/
7665	_meta: RequestMetaSchema.optional() });
7666	/**
7667	* A uniquely identifying ID for a request in JSON-RPC.
7668	*/
7669	var RequestIdSchema = union([string(), number().int()]);
7670	/**
7671	* A request that expects a response.
7672	*/
7673	var JSONRPCRequestSchema = object({
7674	jsonrpc: literal("2.0"),
7675	id: RequestIdSchema,
7676	...RequestSchema.shape
7677	}).strict();
7678	var isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;
7679	/**
7680	* A notification which does not expect a response.
7681	*/
7682	var JSONRPCNotificationSchema = object({
7683	jsonrpc: literal("2.0"),
7684	...NotificationSchema.shape
7685	}).strict();
7686	var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
7687	/**
7688	* A successful (non-error) response to a request.
7689	*/
7690	var JSONRPCResultResponseSchema = object({
7691	jsonrpc: literal("2.0"),
7692	id: RequestIdSchema,
7693	result: ResultSchema
7694	}).strict();
7695	/**
7696	* Checks if a value is a valid JSONRPCResultResponse.
7697	* @param value - The value to check.
7698	*
7699	* @returns True if the value is a valid JSONRPCResultResponse, false otherwise.
7700	*/
7701	var isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
7702	/**
7703	* Error codes defined by the JSON-RPC specification.
7704	*/
7705	var ErrorCode;
7706	(function(ErrorCode) {
7707	ErrorCode[ErrorCode["ConnectionClosed"] = -32e3] = "ConnectionClosed";
7708	ErrorCode[ErrorCode["RequestTimeout"] = -32001] = "RequestTimeout";
7709	ErrorCode[ErrorCode["ParseError"] = -32700] = "ParseError";
7710	ErrorCode[ErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
7711	ErrorCode[ErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
7712	ErrorCode[ErrorCode["InvalidParams"] = -32602] = "InvalidParams";
7713	ErrorCode[ErrorCode["InternalError"] = -32603] = "InternalError";
7714	ErrorCode[ErrorCode["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
7715	})(ErrorCode \|\| (ErrorCode = {}));
7716	/**
7717	* A response to a request that indicates an error occurred.
7718	*/
7719	var JSONRPCErrorResponseSchema = object({
7720	jsonrpc: literal("2.0"),
7721	id: RequestIdSchema.optional(),
7722	error: object({
7723	/**
7724	* The error type that occurred.
7725	*/
7726	code: number().int(),
7727	/**
7728	* A short description of the error. The message SHOULD be limited to a concise single sentence.
7729	*/
7730	message: string(),
7731	/**
7732	* Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
7733	*/
7734	data: unknown().optional()
7735	})
7736	}).strict();
7737	/**
7738	* Checks if a value is a valid JSONRPCErrorResponse.
7739	* @param value - The value to check.
7740	*
7741	* @returns True if the value is a valid JSONRPCErrorResponse, false otherwise.
7742	*/
7743	var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
7744	var JSONRPCMessageSchema = union([
7745	JSONRPCRequestSchema,
7746	JSONRPCNotificationSchema,
7747	JSONRPCResultResponseSchema,
7748	JSONRPCErrorResponseSchema
7749	]);
7750	var JSONRPCResponseSchema = union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
7751	/**
7752	* A response that indicates success but carries no data.
7753	*/
7754	var EmptyResultSchema = ResultSchema.strict();
7755	var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
7756	/**
7757	* The ID of the request to cancel.
7758	*
7759	* This MUST correspond to the ID of a request previously issued in the same direction.
7760	*/
7761	requestId: RequestIdSchema.optional(),
7762	/**
7763	* An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.
7764	*/
7765	reason: string().optional()
7766	});
7767	/**
7768	* This notification can be sent by either side to indicate that it is cancelling a previously-issued request.
7769	*
7770	* The request SHOULD still be in-flight, but due to communication latency, it is always possible that this notification MAY arrive after the request has already finished.
7771	*
7772	* This notification indicates that the result will be unused, so any associated processing SHOULD cease.
7773	*
7774	* A client MUST NOT attempt to cancel its `initialize` request.
7775	*/
7776	var CancelledNotificationSchema = NotificationSchema.extend({
7777	method: literal("notifications/cancelled"),
7778	params: CancelledNotificationParamsSchema
7779	});
7780	/**
7781	* Icon schema for use in tools, prompts, resources, and implementations.
7782	*/
7783	var IconSchema = object({
7784	/**
7785	* URL or data URI for the icon.
7786	*/
7787	src: string(),
7788	/**
7789	* Optional MIME type for the icon.
7790	*/
7791	mimeType: string().optional(),
7792	/**
7793	* Optional array of strings that specify sizes at which the icon can be used.
7794	* Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
7795	*
7796	* If not provided, the client should assume that the icon can be used at any size.
7797	*/
7798	sizes: array(string()).optional(),
7799	/**
7800	* Optional specifier for the theme this icon is designed for. `light` indicates
7801	* the icon is designed to be used with a light background, and `dark` indicates
7802	* the icon is designed to be used with a dark background.
7803	*
7804	* If not provided, the client should assume the icon can be used with any theme.
7805	*/
7806	theme: _enum(["light", "dark"]).optional()
7807	});
7808	/**
7809	* Base schema to add `icons` property.
7810	*
7811	*/
7812	var IconsSchema = object({
7813	/**
7814	* Optional set of sized icons that the client can display in a user interface.
7815	*
7816	* Clients that support rendering icons MUST support at least the following MIME types:
7817	* - `image/png` - PNG images (safe, universal compatibility)
7818	* - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
7819	*
7820	* Clients that support rendering icons SHOULD also support:
7821	* - `image/svg+xml` - SVG images (scalable but requires security precautions)
7822	* - `image/webp` - WebP images (modern, efficient format)
7823	*/
7824	icons: array(IconSchema).optional() });
7825	/**
7826	* Base metadata interface for common properties across resources, tools, prompts, and implementations.
7827	*/
7828	var BaseMetadataSchema = object({
7829	/** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
7830	name: string(),
7831	/**
7832	* Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
7833	* even by those unfamiliar with domain-specific terminology.
7834	*
7835	* If not provided, the name should be used for display (except for Tool,
7836	* where `annotations.title` should be given precedence over using `name`,
7837	* if present).
7838	*/
7839	title: string().optional()
7840	});
7841	/**
7842	* Describes the name and version of an MCP implementation.
7843	*/
7844	var ImplementationSchema = BaseMetadataSchema.extend({
7845	...BaseMetadataSchema.shape,
7846	...IconsSchema.shape,
7847	version: string(),
7848	/**
7849	* An optional URL of the website for this implementation.
7850	*/
7851	websiteUrl: string().optional(),
7852	/**
7853	* An optional human-readable description of what this implementation does.
7854	*
7855	* This can be used by clients or servers to provide context about their purpose
7856	* and capabilities. For example, a server might describe the types of resources
7857	* or tools it provides, while a client might describe its intended use case.
7858	*/
7859	description: string().optional()
7860	});
7861	var FormElicitationCapabilitySchema = intersection(object({ applyDefaults: boolean().optional() }), record(string(), unknown()));
7862	var ElicitationCapabilitySchema = preprocess((value) => {
7863	if (value && typeof value === "object" && !Array.isArray(value)) {
7864	if (Object.keys(value).length === 0) return { form: {} };
7865	}
7866	return value;
7867	}, intersection(object({
7868	form: FormElicitationCapabilitySchema.optional(),
7869	url: AssertObjectSchema.optional()
7870	}), record(string(), unknown()).optional()));
7871	/**
7872	* Task capabilities for clients, indicating which request types support task creation.
7873	*/
7874	var ClientTasksCapabilitySchema = looseObject({
7875	/**
7876	* Present if the client supports listing tasks.
7877	*/
7878	list: AssertObjectSchema.optional(),
7879	/**
7880	* Present if the client supports cancelling tasks.
7881	*/
7882	cancel: AssertObjectSchema.optional(),
7883	/**
7884	* Capabilities for task creation on specific request types.
7885	*/
7886	requests: looseObject({
7887	/**
7888	* Task support for sampling requests.
7889	*/
7890	sampling: looseObject({ createMessage: AssertObjectSchema.optional() }).optional(),
7891	/**
7892	* Task support for elicitation requests.
7893	*/
7894	elicitation: looseObject({ create: AssertObjectSchema.optional() }).optional()
7895	}).optional()
7896	});
7897	/**
7898	* Task capabilities for servers, indicating which request types support task creation.
7899	*/
7900	var ServerTasksCapabilitySchema = looseObject({
7901	/**
7902	* Present if the server supports listing tasks.
7903	*/
7904	list: AssertObjectSchema.optional(),
7905	/**
7906	* Present if the server supports cancelling tasks.
7907	*/
7908	cancel: AssertObjectSchema.optional(),
7909	/**
7910	* Capabilities for task creation on specific request types.
7911	*/
7912	requests: looseObject({
7913	/**
7914	* Task support for tool requests.
7915	*/
7916	tools: looseObject({ call: AssertObjectSchema.optional() }).optional() }).optional()
7917	});
7918	/**
7919	* Capabilities a client may support. Known capabilities are defined here, in this schema, but this is not a closed set: any client can define its own, additional capabilities.
7920	*/
7921	var ClientCapabilitiesSchema = object({
7922	/**
7923	* Experimental, non-standard capabilities that the client supports.
7924	*/
7925	experimental: record(string(), AssertObjectSchema).optional(),
7926	/**
7927	* Present if the client supports sampling from an LLM.
7928	*/
7929	sampling: object({
7930	/**
7931	* Present if the client supports context inclusion via includeContext parameter.
7932	* If not declared, servers SHOULD only use `includeContext: "none"` (or omit it).
7933	*/
7934	context: AssertObjectSchema.optional(),
7935	/**
7936	* Present if the client supports tool use via tools and toolChoice parameters.
7937	*/
7938	tools: AssertObjectSchema.optional()
7939	}).optional(),
7940	/**
7941	* Present if the client supports eliciting user input.
7942	*/
7943	elicitation: ElicitationCapabilitySchema.optional(),
7944	/**
7945	* Present if the client supports listing roots.
7946	*/
7947	roots: object({
7948	/**
7949	* Whether the client supports issuing notifications for changes to the roots list.
7950	*/
7951	listChanged: boolean().optional() }).optional(),
7952	/**
7953	* Present if the client supports task creation.
7954	*/
7955	tasks: ClientTasksCapabilitySchema.optional()
7956	});
7957	var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
7958	/**
7959	* The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well.
7960	*/
7961	protocolVersion: string(),
7962	capabilities: ClientCapabilitiesSchema,
7963	clientInfo: ImplementationSchema
7964	});
7965	/**
7966	* This request is sent from the client to the server when it first connects, asking it to begin initialization.
7967	*/
7968	var InitializeRequestSchema = RequestSchema.extend({
7969	method: literal("initialize"),
7970	params: InitializeRequestParamsSchema
7971	});
7972	/**
7973	* Capabilities that a server may support. Known capabilities are defined here, in this schema, but this is not a closed set: any server can define its own, additional capabilities.
7974	*/
7975	var ServerCapabilitiesSchema = object({
7976	/**
7977	* Experimental, non-standard capabilities that the server supports.
7978	*/
7979	experimental: record(string(), AssertObjectSchema).optional(),
7980	/**
7981	* Present if the server supports sending log messages to the client.
7982	*/
7983	logging: AssertObjectSchema.optional(),
7984	/**
7985	* Present if the server supports sending completions to the client.
7986	*/
7987	completions: AssertObjectSchema.optional(),
7988	/**
7989	* Present if the server offers any prompt templates.
7990	*/
7991	prompts: object({
7992	/**
7993	* Whether this server supports issuing notifications for changes to the prompt list.
7994	*/
7995	listChanged: boolean().optional() }).optional(),
7996	/**
7997	* Present if the server offers any resources to read.
7998	*/
7999	resources: object({
8000	/**
8001	* Whether this server supports clients subscribing to resource updates.
8002	*/
8003	subscribe: boolean().optional(),
8004	/**
8005	* Whether this server supports issuing notifications for changes to the resource list.
8006	*/
8007	listChanged: boolean().optional()
8008	}).optional(),
8009	/**
8010	* Present if the server offers any tools to call.
8011	*/
8012	tools: object({
8013	/**
8014	* Whether this server supports issuing notifications for changes to the tool list.
8015	*/
8016	listChanged: boolean().optional() }).optional(),
8017	/**
8018	* Present if the server supports task creation.
8019	*/
8020	tasks: ServerTasksCapabilitySchema.optional()
8021	});
8022	/**
8023	* After receiving an initialize request from the client, the server sends this response.
8024	*/
8025	var InitializeResultSchema = ResultSchema.extend({
8026	/**
8027	* The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect.
8028	*/
8029	protocolVersion: string(),
8030	capabilities: ServerCapabilitiesSchema,
8031	serverInfo: ImplementationSchema,
8032	/**
8033	* Instructions describing how to use the server and its features.
8034	*
8035	* This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt.
8036	*/
8037	instructions: string().optional()
8038	});
8039	/**
8040	* This notification is sent from the client to the server after initialization has finished.
8041	*/
8042	var InitializedNotificationSchema = NotificationSchema.extend({
8043	method: literal("notifications/initialized"),
8044	params: NotificationsParamsSchema.optional()
8045	});
8046	/**
8047	* A ping, issued by either the server or the client, to check that the other party is still alive. The receiver must promptly respond, or else may be disconnected.
8048	*/
8049	var PingRequestSchema = RequestSchema.extend({
8050	method: literal("ping"),
8051	params: BaseRequestParamsSchema.optional()
8052	});
8053	var ProgressSchema = object({
8054	/**
8055	* The progress thus far. This should increase every time progress is made, even if the total is unknown.
8056	*/
8057	progress: number(),
8058	/**
8059	* Total number of items to process (or total progress required), if known.
8060	*/
8061	total: optional(number()),
8062	/**
8063	* An optional message describing the current progress.
8064	*/
8065	message: optional(string())
8066	});
8067	var ProgressNotificationParamsSchema = object({
8068	...NotificationsParamsSchema.shape,
8069	...ProgressSchema.shape,
8070	/**
8071	* The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
8072	*/
8073	progressToken: ProgressTokenSchema
8074	});
8075	/**
8076	* An out-of-band notification used to inform the receiver of a progress update for a long-running request.
8077	*
8078	* @category notifications/progress
8079	*/
8080	var ProgressNotificationSchema = NotificationSchema.extend({
8081	method: literal("notifications/progress"),
8082	params: ProgressNotificationParamsSchema
8083	});
8084	var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({
8085	/**
8086	* An opaque token representing the current pagination position.
8087	* If provided, the server should return results starting after this cursor.
8088	*/
8089	cursor: CursorSchema.optional() });
8090	var PaginatedRequestSchema = RequestSchema.extend({ params: PaginatedRequestParamsSchema.optional() });
8091	var PaginatedResultSchema = ResultSchema.extend({
8092	/**
8093	* An opaque token representing the pagination position after the last returned result.
8094	* If present, there may be more results available.
8095	*/
8096	nextCursor: CursorSchema.optional() });
8097	/**
8098	* The status of a task.
8099	* */
8100	var TaskStatusSchema = _enum([
8101	"working",
8102	"input_required",
8103	"completed",
8104	"failed",
8105	"cancelled"
8106	]);
8107	/**
8108	* A pollable state object associated with a request.
8109	*/
8110	var TaskSchema = object({
8111	taskId: string(),
8112	status: TaskStatusSchema,
8113	/**
8114	* Time in milliseconds to keep task results available after completion.
8115	* If null, the task has unlimited lifetime until manually cleaned up.
8116	*/
8117	ttl: union([number(), _null()]),
8118	/**
8119	* ISO 8601 timestamp when the task was created.
8120	*/
8121	createdAt: string(),
8122	/**
8123	* ISO 8601 timestamp when the task was last updated.
8124	*/
8125	lastUpdatedAt: string(),
8126	pollInterval: optional(number()),
8127	/**
8128	* Optional diagnostic message for failed tasks or other status information.
8129	*/
8130	statusMessage: optional(string())
8131	});
8132	/**
8133	* Result returned when a task is created, containing the task data wrapped in a task field.
8134	*/
8135	var CreateTaskResultSchema = ResultSchema.extend({ task: TaskSchema });
8136	/**
8137	* Parameters for task status notification.
8138	*/
8139	var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
8140	/**
8141	* A notification sent when a task's status changes.
8142	*/
8143	var TaskStatusNotificationSchema = NotificationSchema.extend({
8144	method: literal("notifications/tasks/status"),
8145	params: TaskStatusNotificationParamsSchema
8146	});
8147	/**
8148	* A request to get the state of a specific task.
8149	*/
8150	var GetTaskRequestSchema = RequestSchema.extend({
8151	method: literal("tasks/get"),
8152	params: BaseRequestParamsSchema.extend({ taskId: string() })
8153	});
8154	/**
8155	* The response to a tasks/get request.
8156	*/
8157	var GetTaskResultSchema = ResultSchema.merge(TaskSchema);
8158	/**
8159	* A request to get the result of a specific task.
8160	*/
8161	var GetTaskPayloadRequestSchema = RequestSchema.extend({
8162	method: literal("tasks/result"),
8163	params: BaseRequestParamsSchema.extend({ taskId: string() })
8164	});
8165	/**
8166	* The response to a tasks/result request.
8167	* The structure matches the result type of the original request.
8168	* For example, a tools/call task would return the CallToolResult structure.
8169	*
8170	*/
8171	var GetTaskPayloadResultSchema = ResultSchema.loose();
8172	/**
8173	* A request to list tasks.
8174	*/
8175	var ListTasksRequestSchema = PaginatedRequestSchema.extend({ method: literal("tasks/list") });
8176	/**
8177	* The response to a tasks/list request.
8178	*/
8179	var ListTasksResultSchema = PaginatedResultSchema.extend({ tasks: array(TaskSchema) });
8180	/**
8181	* A request to cancel a specific task.
8182	*/
8183	var CancelTaskRequestSchema = RequestSchema.extend({
8184	method: literal("tasks/cancel"),
8185	params: BaseRequestParamsSchema.extend({ taskId: string() })
8186	});
8187	/**
8188	* The response to a tasks/cancel request.
8189	*/
8190	var CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
8191	/**
8192	* The contents of a specific resource or sub-resource.
8193	*/
8194	var ResourceContentsSchema = object({
8195	/**
8196	* The URI of this resource.
8197	*/
8198	uri: string(),
8199	/**
8200	* The MIME type of this resource, if known.
8201	*/
8202	mimeType: optional(string()),
8203	/**
8204	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8205	* for notes on _meta usage.
8206	*/
8207	_meta: record(string(), unknown()).optional()
8208	});
8209	var TextResourceContentsSchema = ResourceContentsSchema.extend({
8210	/**
8211	* The text of the item. This must only be set if the item can actually be represented as text (not binary data).
8212	*/
8213	text: string() });
8214	/**
8215	* A Zod schema for validating Base64 strings that is more performant and
8216	* robust for very large inputs than the default regex-based check. It avoids
8217	* stack overflows by using the native `atob` function for validation.
8218	*/
8219	var Base64Schema = string().refine((val) => {
8220	try {
8221	atob(val);
8222	return true;
8223	} catch {
8224	return false;
8225	}
8226	}, { message: "Invalid Base64 string" });
8227	var BlobResourceContentsSchema = ResourceContentsSchema.extend({
8228	/**
8229	* A base64-encoded string representing the binary data of the item.
8230	*/
8231	blob: Base64Schema });
8232	/**
8233	* The sender or recipient of messages and data in a conversation.
8234	*/
8235	var RoleSchema = _enum(["user", "assistant"]);
8236	/**
8237	* Optional annotations providing clients additional context about a resource.
8238	*/
8239	var AnnotationsSchema = object({
8240	/**
8241	* Intended audience(s) for the resource.
8242	*/
8243	audience: array(RoleSchema).optional(),
8244	/**
8245	* Importance hint for the resource, from 0 (least) to 1 (most).
8246	*/
8247	priority: number().min(0).max(1).optional(),
8248	/**
8249	* ISO 8601 timestamp for the most recent modification.
8250	*/
8251	lastModified: datetime({ offset: true }).optional()
8252	});
8253	/**
8254	* A known resource that the server is capable of reading.
8255	*/
8256	var ResourceSchema = object({
8257	...BaseMetadataSchema.shape,
8258	...IconsSchema.shape,
8259	/**
8260	* The URI of this resource.
8261	*/
8262	uri: string(),
8263	/**
8264	* A description of what this resource represents.
8265	*
8266	* This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
8267	*/
8268	description: optional(string()),
8269	/**
8270	* The MIME type of this resource, if known.
8271	*/
8272	mimeType: optional(string()),
8273	/**
8274	* Optional annotations for the client.
8275	*/
8276	annotations: AnnotationsSchema.optional(),
8277	/**
8278	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8279	* for notes on _meta usage.
8280	*/
8281	_meta: optional(looseObject({}))
8282	});
8283	/**
8284	* A template description for resources available on the server.
8285	*/
8286	var ResourceTemplateSchema = object({
8287	...BaseMetadataSchema.shape,
8288	...IconsSchema.shape,
8289	/**
8290	* A URI template (according to RFC 6570) that can be used to construct resource URIs.
8291	*/
8292	uriTemplate: string(),
8293	/**
8294	* A description of what this template is for.
8295	*
8296	* This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
8297	*/
8298	description: optional(string()),
8299	/**
8300	* The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type.
8301	*/
8302	mimeType: optional(string()),
8303	/**
8304	* Optional annotations for the client.
8305	*/
8306	annotations: AnnotationsSchema.optional(),
8307	/**
8308	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8309	* for notes on _meta usage.
8310	*/
8311	_meta: optional(looseObject({}))
8312	});
8313	/**
8314	* Sent from the client to request a list of resources the server has.
8315	*/
8316	var ListResourcesRequestSchema = PaginatedRequestSchema.extend({ method: literal("resources/list") });
8317	/**
8318	* The server's response to a resources/list request from the client.
8319	*/
8320	var ListResourcesResultSchema = PaginatedResultSchema.extend({ resources: array(ResourceSchema) });
8321	/**
8322	* Sent from the client to request a list of resource templates the server has.
8323	*/
8324	var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({ method: literal("resources/templates/list") });
8325	/**
8326	* The server's response to a resources/templates/list request from the client.
8327	*/
8328	var ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({ resourceTemplates: array(ResourceTemplateSchema) });
8329	var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({
8330	/**
8331	* The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it.
8332	*
8333	* @format uri
8334	*/
8335	uri: string() });
8336	/**
8337	* Parameters for a `resources/read` request.
8338	*/
8339	var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema;
8340	/**
8341	* Sent from the client to the server, to read a specific resource URI.
8342	*/
8343	var ReadResourceRequestSchema = RequestSchema.extend({
8344	method: literal("resources/read"),
8345	params: ReadResourceRequestParamsSchema
8346	});
8347	/**
8348	* The server's response to a resources/read request from the client.
8349	*/
8350	var ReadResourceResultSchema = ResultSchema.extend({ contents: array(union([TextResourceContentsSchema, BlobResourceContentsSchema])) });
8351	/**
8352	* An optional notification from the server to the client, informing it that the list of resources it can read from has changed. This may be issued by servers without any previous subscription from the client.
8353	*/
8354	var ResourceListChangedNotificationSchema = NotificationSchema.extend({
8355	method: literal("notifications/resources/list_changed"),
8356	params: NotificationsParamsSchema.optional()
8357	});
8358	var SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
8359	/**
8360	* Sent from the client to request resources/updated notifications from the server whenever a particular resource changes.
8361	*/
8362	var SubscribeRequestSchema = RequestSchema.extend({
8363	method: literal("resources/subscribe"),
8364	params: SubscribeRequestParamsSchema
8365	});
8366	var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema;
8367	/**
8368	* Sent from the client to request cancellation of resources/updated notifications from the server. This should follow a previous resources/subscribe request.
8369	*/
8370	var UnsubscribeRequestSchema = RequestSchema.extend({
8371	method: literal("resources/unsubscribe"),
8372	params: UnsubscribeRequestParamsSchema
8373	});
8374	/**
8375	* Parameters for a `notifications/resources/updated` notification.
8376	*/
8377	var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({
8378	/**
8379	* The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.
8380	*/
8381	uri: string() });
8382	/**
8383	* A notification from the server to the client, informing it that a resource has changed and may need to be read again. This should only be sent if the client previously sent a resources/subscribe request.
8384	*/
8385	var ResourceUpdatedNotificationSchema = NotificationSchema.extend({
8386	method: literal("notifications/resources/updated"),
8387	params: ResourceUpdatedNotificationParamsSchema
8388	});
8389	/**
8390	* Describes an argument that a prompt can accept.
8391	*/
8392	var PromptArgumentSchema = object({
8393	/**
8394	* The name of the argument.
8395	*/
8396	name: string(),
8397	/**
8398	* A human-readable description of the argument.
8399	*/
8400	description: optional(string()),
8401	/**
8402	* Whether this argument must be provided.
8403	*/
8404	required: optional(boolean())
8405	});
8406	/**
8407	* A prompt or prompt template that the server offers.
8408	*/
8409	var PromptSchema = object({
8410	...BaseMetadataSchema.shape,
8411	...IconsSchema.shape,
8412	/**
8413	* An optional description of what this prompt provides
8414	*/
8415	description: optional(string()),
8416	/**
8417	* A list of arguments to use for templating the prompt.
8418	*/
8419	arguments: optional(array(PromptArgumentSchema)),
8420	/**
8421	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8422	* for notes on _meta usage.
8423	*/
8424	_meta: optional(looseObject({}))
8425	});
8426	/**
8427	* Sent from the client to request a list of prompts and prompt templates the server has.
8428	*/
8429	var ListPromptsRequestSchema = PaginatedRequestSchema.extend({ method: literal("prompts/list") });
8430	/**
8431	* The server's response to a prompts/list request from the client.
8432	*/
8433	var ListPromptsResultSchema = PaginatedResultSchema.extend({ prompts: array(PromptSchema) });
8434	/**
8435	* Parameters for a `prompts/get` request.
8436	*/
8437	var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({
8438	/**
8439	* The name of the prompt or prompt template.
8440	*/
8441	name: string(),
8442	/**
8443	* Arguments to use for templating the prompt.
8444	*/
8445	arguments: record(string(), string()).optional()
8446	});
8447	/**
8448	* Used by the client to get a prompt provided by the server.
8449	*/
8450	var GetPromptRequestSchema = RequestSchema.extend({
8451	method: literal("prompts/get"),
8452	params: GetPromptRequestParamsSchema
8453	});
8454	/**
8455	* Text provided to or from an LLM.
8456	*/
8457	var TextContentSchema = object({
8458	type: literal("text"),
8459	/**
8460	* The text content of the message.
8461	*/
8462	text: string(),
8463	/**
8464	* Optional annotations for the client.
8465	*/
8466	annotations: AnnotationsSchema.optional(),
8467	/**
8468	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8469	* for notes on _meta usage.
8470	*/
8471	_meta: record(string(), unknown()).optional()
8472	});
8473	/**
8474	* An image provided to or from an LLM.
8475	*/
8476	var ImageContentSchema = object({
8477	type: literal("image"),
8478	/**
8479	* The base64-encoded image data.
8480	*/
8481	data: Base64Schema,
8482	/**
8483	* The MIME type of the image. Different providers may support different image types.
8484	*/
8485	mimeType: string(),
8486	/**
8487	* Optional annotations for the client.
8488	*/
8489	annotations: AnnotationsSchema.optional(),
8490	/**
8491	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8492	* for notes on _meta usage.
8493	*/
8494	_meta: record(string(), unknown()).optional()
8495	});
8496	/**
8497	* An Audio provided to or from an LLM.
8498	*/
8499	var AudioContentSchema = object({
8500	type: literal("audio"),
8501	/**
8502	* The base64-encoded audio data.
8503	*/
8504	data: Base64Schema,
8505	/**
8506	* The MIME type of the audio. Different providers may support different audio types.
8507	*/
8508	mimeType: string(),
8509	/**
8510	* Optional annotations for the client.
8511	*/
8512	annotations: AnnotationsSchema.optional(),
8513	/**
8514	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8515	* for notes on _meta usage.
8516	*/
8517	_meta: record(string(), unknown()).optional()
8518	});
8519	/**
8520	* A tool call request from an assistant (LLM).
8521	* Represents the assistant's request to use a tool.
8522	*/
8523	var ToolUseContentSchema = object({
8524	type: literal("tool_use"),
8525	/**
8526	* The name of the tool to invoke.
8527	* Must match a tool name from the request's tools array.
8528	*/
8529	name: string(),
8530	/**
8531	* Unique identifier for this tool call.
8532	* Used to correlate with ToolResultContent in subsequent messages.
8533	*/
8534	id: string(),
8535	/**
8536	* Arguments to pass to the tool.
8537	* Must conform to the tool's inputSchema.
8538	*/
8539	input: record(string(), unknown()),
8540	/**
8541	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8542	* for notes on _meta usage.
8543	*/
8544	_meta: record(string(), unknown()).optional()
8545	});
8546	/**
8547	* The contents of a resource, embedded into a prompt or tool call result.
8548	*/
8549	var EmbeddedResourceSchema = object({
8550	type: literal("resource"),
8551	resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]),
8552	/**
8553	* Optional annotations for the client.
8554	*/
8555	annotations: AnnotationsSchema.optional(),
8556	/**
8557	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8558	* for notes on _meta usage.
8559	*/
8560	_meta: record(string(), unknown()).optional()
8561	});
8562	/**
8563	* A resource that the server is capable of reading, included in a prompt or tool call result.
8564	*
8565	* Note: resource links returned by tools are not guaranteed to appear in the results of `resources/list` requests.
8566	*/
8567	var ResourceLinkSchema = ResourceSchema.extend({ type: literal("resource_link") });
8568	/**
8569	* A content block that can be used in prompts and tool results.
8570	*/
8571	var ContentBlockSchema = union([
8572	TextContentSchema,
8573	ImageContentSchema,
8574	AudioContentSchema,
8575	ResourceLinkSchema,
8576	EmbeddedResourceSchema
8577	]);
8578	/**
8579	* Describes a message returned as part of a prompt.
8580	*/
8581	var PromptMessageSchema = object({
8582	role: RoleSchema,
8583	content: ContentBlockSchema
8584	});
8585	/**
8586	* The server's response to a prompts/get request from the client.
8587	*/
8588	var GetPromptResultSchema = ResultSchema.extend({
8589	/**
8590	* An optional description for the prompt.
8591	*/
8592	description: string().optional(),
8593	messages: array(PromptMessageSchema)
8594	});
8595	/**
8596	* An optional notification from the server to the client, informing it that the list of prompts it offers has changed. This may be issued by servers without any previous subscription from the client.
8597	*/
8598	var PromptListChangedNotificationSchema = NotificationSchema.extend({
8599	method: literal("notifications/prompts/list_changed"),
8600	params: NotificationsParamsSchema.optional()
8601	});
8602	/**
8603	* Additional properties describing a Tool to clients.
8604	*
8605	* NOTE: all properties in ToolAnnotations are hints.
8606	* They are not guaranteed to provide a faithful description of
8607	* tool behavior (including descriptive properties like `title`).
8608	*
8609	* Clients should never make tool use decisions based on ToolAnnotations
8610	* received from untrusted servers.
8611	*/
8612	var ToolAnnotationsSchema = object({
8613	/**
8614	* A human-readable title for the tool.
8615	*/
8616	title: string().optional(),
8617	/**
8618	* If true, the tool does not modify its environment.
8619	*
8620	* Default: false
8621	*/
8622	readOnlyHint: boolean().optional(),
8623	/**
8624	* If true, the tool may perform destructive updates to its environment.
8625	* If false, the tool performs only additive updates.
8626	*
8627	* (This property is meaningful only when `readOnlyHint == false`)
8628	*
8629	* Default: true
8630	*/
8631	destructiveHint: boolean().optional(),
8632	/**
8633	* If true, calling the tool repeatedly with the same arguments
8634	* will have no additional effect on the its environment.
8635	*
8636	* (This property is meaningful only when `readOnlyHint == false`)
8637	*
8638	* Default: false
8639	*/
8640	idempotentHint: boolean().optional(),
8641	/**
8642	* If true, this tool may interact with an "open world" of external
8643	* entities. If false, the tool's domain of interaction is closed.
8644	* For example, the world of a web search tool is open, whereas that
8645	* of a memory tool is not.
8646	*
8647	* Default: true
8648	*/
8649	openWorldHint: boolean().optional()
8650	});
8651	/**
8652	* Execution-related properties for a tool.
8653	*/
8654	var ToolExecutionSchema = object({
8655	/**
8656	* Indicates the tool's preference for task-augmented execution.
8657	* - "required": Clients MUST invoke the tool as a task
8658	* - "optional": Clients MAY invoke the tool as a task or normal request
8659	* - "forbidden": Clients MUST NOT attempt to invoke the tool as a task
8660	*
8661	* If not present, defaults to "forbidden".
8662	*/
8663	taskSupport: _enum([
8664	"required",
8665	"optional",
8666	"forbidden"
8667	]).optional() });
8668	/**
8669	* Definition for a tool the client can call.
8670	*/
8671	var ToolSchema = object({
8672	...BaseMetadataSchema.shape,
8673	...IconsSchema.shape,
8674	/**
8675	* A human-readable description of the tool.
8676	*/
8677	description: string().optional(),
8678	/**
8679	* A JSON Schema 2020-12 object defining the expected parameters for the tool.
8680	* Must have type: 'object' at the root level per MCP spec.
8681	*/
8682	inputSchema: object({
8683	type: literal("object"),
8684	properties: record(string(), AssertObjectSchema).optional(),
8685	required: array(string()).optional()
8686	}).catchall(unknown()),
8687	/**
8688	* An optional JSON Schema 2020-12 object defining the structure of the tool's output
8689	* returned in the structuredContent field of a CallToolResult.
8690	* Must have type: 'object' at the root level per MCP spec.
8691	*/
8692	outputSchema: object({
8693	type: literal("object"),
8694	properties: record(string(), AssertObjectSchema).optional(),
8695	required: array(string()).optional()
8696	}).catchall(unknown()).optional(),
8697	/**
8698	* Optional additional tool information.
8699	*/
8700	annotations: ToolAnnotationsSchema.optional(),
8701	/**
8702	* Execution-related properties for this tool.
8703	*/
8704	execution: ToolExecutionSchema.optional(),
8705	/**
8706	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8707	* for notes on _meta usage.
8708	*/
8709	_meta: record(string(), unknown()).optional()
8710	});
8711	/**
8712	* Sent from the client to request a list of tools the server has.
8713	*/
8714	var ListToolsRequestSchema = PaginatedRequestSchema.extend({ method: literal("tools/list") });
8715	/**
8716	* The server's response to a tools/list request from the client.
8717	*/
8718	var ListToolsResultSchema = PaginatedResultSchema.extend({ tools: array(ToolSchema) });
8719	/**
8720	* The server's response to a tool call.
8721	*/
8722	var CallToolResultSchema = ResultSchema.extend({
8723	/**
8724	* A list of content objects that represent the result of the tool call.
8725	*
8726	* If the Tool does not define an outputSchema, this field MUST be present in the result.
8727	* For backwards compatibility, this field is always present, but it may be empty.
8728	*/
8729	content: array(ContentBlockSchema).default([]),
8730	/**
8731	* An object containing structured tool output.
8732	*
8733	* If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
8734	*/
8735	structuredContent: record(string(), unknown()).optional(),
8736	/**
8737	* Whether the tool call ended in an error.
8738	*
8739	* If not set, this is assumed to be false (the call was successful).
8740	*
8741	* Any errors that originate from the tool SHOULD be reported inside the result
8742	* object, with `isError` set to true, _not_ as an MCP protocol-level error
8743	* response. Otherwise, the LLM would not be able to see that an error occurred
8744	* and self-correct.
8745	*
8746	* However, any errors in _finding_ the tool, an error indicating that the
8747	* server does not support tool calls, or any other exceptional conditions,
8748	* should be reported as an MCP error response.
8749	*/
8750	isError: boolean().optional()
8751	});
8752	/**
8753	* CallToolResultSchema extended with backwards compatibility to protocol version 2024-10-07.
8754	*/
8755	var CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({ toolResult: unknown() }));
8756	/**
8757	* Parameters for a `tools/call` request.
8758	*/
8759	var CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
8760	/**
8761	* The name of the tool to call.
8762	*/
8763	name: string(),
8764	/**
8765	* Arguments to pass to the tool.
8766	*/
8767	arguments: record(string(), unknown()).optional()
8768	});
8769	/**
8770	* Used by the client to invoke a tool provided by the server.
8771	*/
8772	var CallToolRequestSchema = RequestSchema.extend({
8773	method: literal("tools/call"),
8774	params: CallToolRequestParamsSchema
8775	});
8776	/**
8777	* An optional notification from the server to the client, informing it that the list of tools it offers has changed. This may be issued by servers without any previous subscription from the client.
8778	*/
8779	var ToolListChangedNotificationSchema = NotificationSchema.extend({
8780	method: literal("notifications/tools/list_changed"),
8781	params: NotificationsParamsSchema.optional()
8782	});
8783	/**
8784	* Base schema for list changed subscription options (without callback).
8785	* Used internally for Zod validation of autoRefresh and debounceMs.
8786	*/
8787	var ListChangedOptionsBaseSchema = object({
8788	/**
8789	* If true, the list will be refreshed automatically when a list changed notification is received.
8790	* The callback will be called with the updated list.
8791	*
8792	* If false, the callback will be called with null items, allowing manual refresh.
8793	*
8794	* @default true
8795	*/
8796	autoRefresh: boolean().default(true),
8797	/**
8798	* Debounce time in milliseconds for list changed notification processing.
8799	*
8800	* Multiple notifications received within this timeframe will only trigger one refresh.
8801	* Set to 0 to disable debouncing.
8802	*
8803	* @default 300
8804	*/
8805	debounceMs: number().int().nonnegative().default(300)
8806	});
8807	/**
8808	* The severity of a log message.
8809	*/
8810	var LoggingLevelSchema = _enum([
8811	"debug",
8812	"info",
8813	"notice",
8814	"warning",
8815	"error",
8816	"critical",
8817	"alert",
8818	"emergency"
8819	]);
8820	/**
8821	* Parameters for a `logging/setLevel` request.
8822	*/
8823	var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({
8824	/**
8825	* The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message.
8826	*/
8827	level: LoggingLevelSchema });
8828	/**
8829	* A request from the client to the server, to enable or adjust logging.
8830	*/
8831	var SetLevelRequestSchema = RequestSchema.extend({
8832	method: literal("logging/setLevel"),
8833	params: SetLevelRequestParamsSchema
8834	});
8835	/**
8836	* Parameters for a `notifications/message` notification.
8837	*/
8838	var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
8839	/**
8840	* The severity of this log message.
8841	*/
8842	level: LoggingLevelSchema,
8843	/**
8844	* An optional name of the logger issuing this message.
8845	*/
8846	logger: string().optional(),
8847	/**
8848	* The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.
8849	*/
8850	data: unknown()
8851	});
8852	/**
8853	* Notification of a log message passed from server to client. If no logging/setLevel request has been sent from the client, the server MAY decide which messages to send automatically.
8854	*/
8855	var LoggingMessageNotificationSchema = NotificationSchema.extend({
8856	method: literal("notifications/message"),
8857	params: LoggingMessageNotificationParamsSchema
8858	});
8859	/**
8860	* Hints to use for model selection.
8861	*/
8862	var ModelHintSchema = object({
8863	/**
8864	* A hint for a model name.
8865	*/
8866	name: string().optional() });
8867	/**
8868	* The server's preferences for model selection, requested of the client during sampling.
8869	*/
8870	var ModelPreferencesSchema = object({
8871	/**
8872	* Optional hints to use for model selection.
8873	*/
8874	hints: array(ModelHintSchema).optional(),
8875	/**
8876	* How much to prioritize cost when selecting a model.
8877	*/
8878	costPriority: number().min(0).max(1).optional(),
8879	/**
8880	* How much to prioritize sampling speed (latency) when selecting a model.
8881	*/
8882	speedPriority: number().min(0).max(1).optional(),
8883	/**
8884	* How much to prioritize intelligence and capabilities when selecting a model.
8885	*/
8886	intelligencePriority: number().min(0).max(1).optional()
8887	});
8888	/**
8889	* Controls tool usage behavior in sampling requests.
8890	*/
8891	var ToolChoiceSchema = object({
8892	/**
8893	* Controls when tools are used:
8894	* - "auto": Model decides whether to use tools (default)
8895	* - "required": Model MUST use at least one tool before completing
8896	* - "none": Model MUST NOT use any tools
8897	*/
8898	mode: _enum([
8899	"auto",
8900	"required",
8901	"none"
8902	]).optional() });
8903	/**
8904	* The result of a tool execution, provided by the user (server).
8905	* Represents the outcome of invoking a tool requested via ToolUseContent.
8906	*/
8907	var ToolResultContentSchema = object({
8908	type: literal("tool_result"),
8909	toolUseId: string().describe("The unique identifier for the corresponding tool call."),
8910	content: array(ContentBlockSchema).default([]),
8911	structuredContent: object({}).loose().optional(),
8912	isError: boolean().optional(),
8913	/**
8914	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8915	* for notes on _meta usage.
8916	*/
8917	_meta: record(string(), unknown()).optional()
8918	});
8919	/**
8920	* Basic content types for sampling responses (without tool use).
8921	* Used for backwards-compatible CreateMessageResult when tools are not used.
8922	*/
8923	var SamplingContentSchema = discriminatedUnion("type", [
8924	TextContentSchema,
8925	ImageContentSchema,
8926	AudioContentSchema
8927	]);
8928	/**
8929	* Content block types allowed in sampling messages.
8930	* This includes text, image, audio, tool use requests, and tool results.
8931	*/
8932	var SamplingMessageContentBlockSchema = discriminatedUnion("type", [
8933	TextContentSchema,
8934	ImageContentSchema,
8935	AudioContentSchema,
8936	ToolUseContentSchema,
8937	ToolResultContentSchema
8938	]);
8939	/**
8940	* Describes a message issued to or received from an LLM API.
8941	*/
8942	var SamplingMessageSchema = object({
8943	role: RoleSchema,
8944	content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]),
8945	/**
8946	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
8947	* for notes on _meta usage.
8948	*/
8949	_meta: record(string(), unknown()).optional()
8950	});
8951	/**
8952	* Parameters for a `sampling/createMessage` request.
8953	*/
8954	var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
8955	messages: array(SamplingMessageSchema),
8956	/**
8957	* The server's preferences for which model to select. The client MAY modify or omit this request.
8958	*/
8959	modelPreferences: ModelPreferencesSchema.optional(),
8960	/**
8961	* An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt.
8962	*/
8963	systemPrompt: string().optional(),
8964	/**
8965	* A request to include context from one or more MCP servers (including the caller), to be attached to the prompt.
8966	* The client MAY ignore this request.
8967	*
8968	* Default is "none". Values "thisServer" and "allServers" are soft-deprecated. Servers SHOULD only use these values if the client
8969	* declares ClientCapabilities.sampling.context. These values may be removed in future spec releases.
8970	*/
8971	includeContext: _enum([
8972	"none",
8973	"thisServer",
8974	"allServers"
8975	]).optional(),
8976	temperature: number().optional(),
8977	/**
8978	* The requested maximum number of tokens to sample (to prevent runaway completions).
8979	*
8980	* The client MAY choose to sample fewer tokens than the requested maximum.
8981	*/
8982	maxTokens: number().int(),
8983	stopSequences: array(string()).optional(),
8984	/**
8985	* Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
8986	*/
8987	metadata: AssertObjectSchema.optional(),
8988	/**
8989	* Tools that the model may use during generation.
8990	* The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
8991	*/
8992	tools: array(ToolSchema).optional(),
8993	/**
8994	* Controls how the model uses tools.
8995	* The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
8996	* Default is `{ mode: "auto" }`.
8997	*/
8998	toolChoice: ToolChoiceSchema.optional()
8999	});
9000	/**
9001	* A request from the server to sample an LLM via the client. The client has full discretion over which model to select. The client should also inform the user before beginning sampling, to allow them to inspect the request (human in the loop) and decide whether to approve it.
9002	*/
9003	var CreateMessageRequestSchema = RequestSchema.extend({
9004	method: literal("sampling/createMessage"),
9005	params: CreateMessageRequestParamsSchema
9006	});
9007	/**
9008	* The client's response to a sampling/create_message request from the server.
9009	* This is the backwards-compatible version that returns single content (no arrays).
9010	* Used when the request does not include tools.
9011	*/
9012	var CreateMessageResultSchema = ResultSchema.extend({
9013	/**
9014	* The name of the model that generated the message.
9015	*/
9016	model: string(),
9017	/**
9018	* The reason why sampling stopped, if known.
9019	*
9020	* Standard values:
9021	* - "endTurn": Natural end of the assistant's turn
9022	* - "stopSequence": A stop sequence was encountered
9023	* - "maxTokens": Maximum token limit was reached
9024	*
9025	* This field is an open string to allow for provider-specific stop reasons.
9026	*/
9027	stopReason: optional(_enum([
9028	"endTurn",
9029	"stopSequence",
9030	"maxTokens"
9031	]).or(string())),
9032	role: RoleSchema,
9033	/**
9034	* Response content. Single content block (text, image, or audio).
9035	*/
9036	content: SamplingContentSchema
9037	});
9038	/**
9039	* The client's response to a sampling/create_message request when tools were provided.
9040	* This version supports array content for tool use flows.
9041	*/
9042	var CreateMessageResultWithToolsSchema = ResultSchema.extend({
9043	/**
9044	* The name of the model that generated the message.
9045	*/
9046	model: string(),
9047	/**
9048	* The reason why sampling stopped, if known.
9049	*
9050	* Standard values:
9051	* - "endTurn": Natural end of the assistant's turn
9052	* - "stopSequence": A stop sequence was encountered
9053	* - "maxTokens": Maximum token limit was reached
9054	* - "toolUse": The model wants to use one or more tools
9055	*
9056	* This field is an open string to allow for provider-specific stop reasons.
9057	*/
9058	stopReason: optional(_enum([
9059	"endTurn",
9060	"stopSequence",
9061	"maxTokens",
9062	"toolUse"
9063	]).or(string())),
9064	role: RoleSchema,
9065	/**
9066	* Response content. May be a single block or array. May include ToolUseContent if stopReason is "toolUse".
9067	*/
9068	content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)])
9069	});
9070	/**
9071	* Primitive schema definition for boolean fields.
9072	*/
9073	var BooleanSchemaSchema = object({
9074	type: literal("boolean"),
9075	title: string().optional(),
9076	description: string().optional(),
9077	default: boolean().optional()
9078	});
9079	/**
9080	* Primitive schema definition for string fields.
9081	*/
9082	var StringSchemaSchema = object({
9083	type: literal("string"),
9084	title: string().optional(),
9085	description: string().optional(),
9086	minLength: number().optional(),
9087	maxLength: number().optional(),
9088	format: _enum([
9089	"email",
9090	"uri",
9091	"date",
9092	"date-time"
9093	]).optional(),
9094	default: string().optional()
9095	});
9096	/**
9097	* Primitive schema definition for number fields.
9098	*/
9099	var NumberSchemaSchema = object({
9100	type: _enum(["number", "integer"]),
9101	title: string().optional(),
9102	description: string().optional(),
9103	minimum: number().optional(),
9104	maximum: number().optional(),
9105	default: number().optional()
9106	});
9107	/**
9108	* Schema for single-selection enumeration without display titles for options.
9109	*/
9110	var UntitledSingleSelectEnumSchemaSchema = object({
9111	type: literal("string"),
9112	title: string().optional(),
9113	description: string().optional(),
9114	enum: array(string()),
9115	default: string().optional()
9116	});
9117	/**
9118	* Schema for single-selection enumeration with display titles for each option.
9119	*/
9120	var TitledSingleSelectEnumSchemaSchema = object({
9121	type: literal("string"),
9122	title: string().optional(),
9123	description: string().optional(),
9124	oneOf: array(object({
9125	const: string(),
9126	title: string()
9127	})),
9128	default: string().optional()
9129	});
9130	/**
9131	* Use TitledSingleSelectEnumSchema instead.
9132	* This interface will be removed in a future version.
9133	*/
9134	var LegacyTitledEnumSchemaSchema = object({
9135	type: literal("string"),
9136	title: string().optional(),
9137	description: string().optional(),
9138	enum: array(string()),
9139	enumNames: array(string()).optional(),
9140	default: string().optional()
9141	});
9142	var SingleSelectEnumSchemaSchema = union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
9143	/**
9144	* Schema for multiple-selection enumeration without display titles for options.
9145	*/
9146	var UntitledMultiSelectEnumSchemaSchema = object({
9147	type: literal("array"),
9148	title: string().optional(),
9149	description: string().optional(),
9150	minItems: number().optional(),
9151	maxItems: number().optional(),
9152	items: object({
9153	type: literal("string"),
9154	enum: array(string())
9155	}),
9156	default: array(string()).optional()
9157	});
9158	/**
9159	* Schema for multiple-selection enumeration with display titles for each option.
9160	*/
9161	var TitledMultiSelectEnumSchemaSchema = object({
9162	type: literal("array"),
9163	title: string().optional(),
9164	description: string().optional(),
9165	minItems: number().optional(),
9166	maxItems: number().optional(),
9167	items: object({ anyOf: array(object({
9168	const: string(),
9169	title: string()
9170	})) }),
9171	default: array(string()).optional()
9172	});
9173	/**
9174	* Combined schema for multiple-selection enumeration
9175	*/
9176	var MultiSelectEnumSchemaSchema = union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
9177	/**
9178	* Primitive schema definition for enum fields.
9179	*/
9180	var EnumSchemaSchema = union([
9181	LegacyTitledEnumSchemaSchema,
9182	SingleSelectEnumSchemaSchema,
9183	MultiSelectEnumSchemaSchema
9184	]);
9185	/**
9186	* Union of all primitive schema definitions.
9187	*/
9188	var PrimitiveSchemaDefinitionSchema = union([
9189	EnumSchemaSchema,
9190	BooleanSchemaSchema,
9191	StringSchemaSchema,
9192	NumberSchemaSchema
9193	]);
9194	/**
9195	* Parameters for an `elicitation/create` request for form-based elicitation.
9196	*/
9197	var ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
9198	/**
9199	* The elicitation mode.
9200	*
9201	* Optional for backward compatibility. Clients MUST treat missing mode as "form".
9202	*/
9203	mode: literal("form").optional(),
9204	/**
9205	* The message to present to the user describing what information is being requested.
9206	*/
9207	message: string(),
9208	/**
9209	* A restricted subset of JSON Schema.
9210	* Only top-level properties are allowed, without nesting.
9211	*/
9212	requestedSchema: object({
9213	type: literal("object"),
9214	properties: record(string(), PrimitiveSchemaDefinitionSchema),
9215	required: array(string()).optional()
9216	})
9217	});
9218	/**
9219	* Parameters for an `elicitation/create` request for URL-based elicitation.
9220	*/
9221	var ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
9222	/**
9223	* The elicitation mode.
9224	*/
9225	mode: literal("url"),
9226	/**
9227	* The message to present to the user explaining why the interaction is needed.
9228	*/
9229	message: string(),
9230	/**
9231	* The ID of the elicitation, which must be unique within the context of the server.
9232	* The client MUST treat this ID as an opaque value.
9233	*/
9234	elicitationId: string(),
9235	/**
9236	* The URL that the user should navigate to.
9237	*/
9238	url: string().url()
9239	});
9240	/**
9241	* The parameters for a request to elicit additional information from the user via the client.
9242	*/
9243	var ElicitRequestParamsSchema = union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
9244	/**
9245	* A request from the server to elicit user input via the client.
9246	* The client should present the message and form fields to the user (form mode)
9247	* or navigate to a URL (URL mode).
9248	*/
9249	var ElicitRequestSchema = RequestSchema.extend({
9250	method: literal("elicitation/create"),
9251	params: ElicitRequestParamsSchema
9252	});
9253	/**
9254	* Parameters for a `notifications/elicitation/complete` notification.
9255	*
9256	* @category notifications/elicitation/complete
9257	*/
9258	var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({
9259	/**
9260	* The ID of the elicitation that completed.
9261	*/
9262	elicitationId: string() });
9263	/**
9264	* A notification from the server to the client, informing it of a completion of an out-of-band elicitation request.
9265	*
9266	* @category notifications/elicitation/complete
9267	*/
9268	var ElicitationCompleteNotificationSchema = NotificationSchema.extend({
9269	method: literal("notifications/elicitation/complete"),
9270	params: ElicitationCompleteNotificationParamsSchema
9271	});
9272	/**
9273	* The client's response to an elicitation/create request from the server.
9274	*/
9275	var ElicitResultSchema = ResultSchema.extend({
9276	/**
9277	* The user action in response to the elicitation.
9278	* - "accept": User submitted the form/confirmed the action
9279	* - "decline": User explicitly decline the action
9280	* - "cancel": User dismissed without making an explicit choice
9281	*/
9282	action: _enum([
9283	"accept",
9284	"decline",
9285	"cancel"
9286	]),
9287	/**
9288	* The submitted form data, only present when action is "accept".
9289	* Contains values matching the requested schema.
9290	* Per MCP spec, content is "typically omitted" for decline/cancel actions.
9291	* We normalize null to undefined for leniency while maintaining type compatibility.
9292	*/
9293	content: preprocess((val) => val === null ? void 0 : val, record(string(), union([
9294	string(),
9295	number(),
9296	boolean(),
9297	array(string())
9298	])).optional())
9299	});
9300	/**
9301	* A reference to a resource or resource template definition.
9302	*/
9303	var ResourceTemplateReferenceSchema = object({
9304	type: literal("ref/resource"),
9305	/**
9306	* The URI or URI template of the resource.
9307	*/
9308	uri: string()
9309	});
9310	/**
9311	* Identifies a prompt.
9312	*/
9313	var PromptReferenceSchema = object({
9314	type: literal("ref/prompt"),
9315	/**
9316	* The name of the prompt or prompt template
9317	*/
9318	name: string()
9319	});
9320	/**
9321	* Parameters for a `completion/complete` request.
9322	*/
9323	var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({
9324	ref: union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
9325	/**
9326	* The argument's information
9327	*/
9328	argument: object({
9329	/**
9330	* The name of the argument
9331	*/
9332	name: string(),
9333	/**
9334	* The value of the argument to use for completion matching.
9335	*/
9336	value: string()
9337	}),
9338	context: object({
9339	/**
9340	* Previously-resolved variables in a URI template or prompt.
9341	*/
9342	arguments: record(string(), string()).optional() }).optional()
9343	});
9344	/**
9345	* A request from the client to the server, to ask for completion options.
9346	*/
9347	var CompleteRequestSchema = RequestSchema.extend({
9348	method: literal("completion/complete"),
9349	params: CompleteRequestParamsSchema
9350	});
9351	function assertCompleteRequestPrompt(request) {
9352	if (request.params.ref.type !== "ref/prompt") throw new TypeError(`Expected CompleteRequestPrompt, but got ${request.params.ref.type}`);
9353	}
9354	function assertCompleteRequestResourceTemplate(request) {
9355	if (request.params.ref.type !== "ref/resource") throw new TypeError(`Expected CompleteRequestResourceTemplate, but got ${request.params.ref.type}`);
9356	}
9357	/**
9358	* The server's response to a completion/complete request
9359	*/
9360	var CompleteResultSchema = ResultSchema.extend({ completion: looseObject({
9361	/**
9362	* An array of completion values. Must not exceed 100 items.
9363	*/
9364	values: array(string()).max(100),
9365	/**
9366	* The total number of completion options available. This can exceed the number of values actually sent in the response.
9367	*/
9368	total: optional(number().int()),
9369	/**
9370	* Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
9371	*/
9372	hasMore: optional(boolean())
9373	}) });
9374	/**
9375	* Represents a root directory or file that the server can operate on.
9376	*/
9377	var RootSchema = object({
9378	/**
9379	* The URI identifying the root. This must start with file:// for now.
9380	*/
9381	uri: string().startsWith("file://"),
9382	/**
9383	* An optional name for the root.
9384	*/
9385	name: string().optional(),
9386	/**
9387	* See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
9388	* for notes on _meta usage.
9389	*/
9390	_meta: record(string(), unknown()).optional()
9391	});
9392	/**
9393	* Sent from the server to request a list of root URIs from the client.
9394	*/
9395	var ListRootsRequestSchema = RequestSchema.extend({
9396	method: literal("roots/list"),
9397	params: BaseRequestParamsSchema.optional()
9398	});
9399	/**
9400	* The client's response to a roots/list request from the server.
9401	*/
9402	var ListRootsResultSchema = ResultSchema.extend({ roots: array(RootSchema) });
9403	/**
9404	* A notification from the client to the server, informing it that the list of roots has changed.
9405	*/
9406	var RootsListChangedNotificationSchema = NotificationSchema.extend({
9407	method: literal("notifications/roots/list_changed"),
9408	params: NotificationsParamsSchema.optional()
9409	});
9410	var ClientRequestSchema = union([
9411	PingRequestSchema,
9412	InitializeRequestSchema,
9413	CompleteRequestSchema,
9414	SetLevelRequestSchema,
9415	GetPromptRequestSchema,
9416	ListPromptsRequestSchema,
9417	ListResourcesRequestSchema,
9418	ListResourceTemplatesRequestSchema,
9419	ReadResourceRequestSchema,
9420	SubscribeRequestSchema,
9421	UnsubscribeRequestSchema,
9422	CallToolRequestSchema,
9423	ListToolsRequestSchema,
9424	GetTaskRequestSchema,
9425	GetTaskPayloadRequestSchema,
9426	ListTasksRequestSchema,
9427	CancelTaskRequestSchema
9428	]);
9429	var ClientNotificationSchema = union([
9430	CancelledNotificationSchema,
9431	ProgressNotificationSchema,
9432	InitializedNotificationSchema,
9433	RootsListChangedNotificationSchema,
9434	TaskStatusNotificationSchema
9435	]);
9436	var ClientResultSchema = union([
9437	EmptyResultSchema,
9438	CreateMessageResultSchema,
9439	CreateMessageResultWithToolsSchema,
9440	ElicitResultSchema,
9441	ListRootsResultSchema,
9442	GetTaskResultSchema,
9443	ListTasksResultSchema,
9444	CreateTaskResultSchema
9445	]);
9446	var ServerRequestSchema = union([
9447	PingRequestSchema,
9448	CreateMessageRequestSchema,
9449	ElicitRequestSchema,
9450	ListRootsRequestSchema,
9451	GetTaskRequestSchema,
9452	GetTaskPayloadRequestSchema,
9453	ListTasksRequestSchema,
9454	CancelTaskRequestSchema
9455	]);
9456	var ServerNotificationSchema = union([
9457	CancelledNotificationSchema,
9458	ProgressNotificationSchema,
9459	LoggingMessageNotificationSchema,
9460	ResourceUpdatedNotificationSchema,
9461	ResourceListChangedNotificationSchema,
9462	ToolListChangedNotificationSchema,
9463	PromptListChangedNotificationSchema,
9464	TaskStatusNotificationSchema,
9465	ElicitationCompleteNotificationSchema
9466	]);
9467	var ServerResultSchema = union([
9468	EmptyResultSchema,
9469	InitializeResultSchema,
9470	CompleteResultSchema,
9471	GetPromptResultSchema,
9472	ListPromptsResultSchema,
9473	ListResourcesResultSchema,
9474	ListResourceTemplatesResultSchema,
9475	ReadResourceResultSchema,
9476	CallToolResultSchema,
9477	ListToolsResultSchema,
9478	GetTaskResultSchema,
9479	ListTasksResultSchema,
9480	CreateTaskResultSchema
9481	]);
9482	var McpError = class McpError extends Error {
9483	constructor(code, message, data) {
9484	super(`MCP error ${code}: ${message}`);
9485	this.code = code;
9486	this.data = data;
9487	this.name = "McpError";
9488	}
9489	/**
9490	* Factory method to create the appropriate error type based on the error code and data
9491	*/
9492	static fromError(code, message, data) {
9493	if (code === ErrorCode.UrlElicitationRequired && data) {
9494	const errorData = data;
9495	if (errorData.elicitations) return new UrlElicitationRequiredError(errorData.elicitations, message);
9496	}
9497	return new McpError(code, message, data);
9498	}
9499	};
9500	/**
9501	* Specialized error type when a tool requires a URL mode elicitation.
9502	* This makes it nicer for the client to handle since there is specific data to work with instead of just a code to check against.
9503	*/
9504	var UrlElicitationRequiredError = class extends McpError {
9505	constructor(elicitations, message = `URL elicitation${elicitations.length > 1 ? "s" : ""} required`) {
9506	super(ErrorCode.UrlElicitationRequired, message, { elicitations });
9507	}
9508	get elicitations() {
9509	return this.data?.elicitations ?? [];
9510	}
9511	};
9512
9513	//#endregion
9514	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
9515	/**
9516	* Experimental task interfaces for MCP SDK.
9517	* WARNING: These APIs are experimental and may change without notice.
9518	*/
9519	/**
9520	* Checks if a task status represents a terminal state.
9521	* Terminal states are those where the task has finished and will not change.
9522	*
9523	* @param status - The task status to check
9524	* @returns True if the status is terminal (completed, failed, or cancelled)
9525	* @experimental
9526	*/
9527	function isTerminal(status) {
9528	return status === "completed" \|\| status === "failed" \|\| status === "cancelled";
9529	}
9530
9531	//#endregion
9532	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/Options.js
9533	var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
9534	var defaultOptions = {
9535	name: void 0,
9536	$refStrategy: "root",
9537	basePath: ["#"],
9538	effectStrategy: "input",
9539	pipeStrategy: "all",
9540	dateStrategy: "format:date-time",
9541	mapStrategy: "entries",
9542	removeAdditionalStrategy: "passthrough",
9543	allowedAdditionalProperties: true,
9544	rejectedAdditionalProperties: false,
9545	definitionPath: "definitions",
9546	target: "jsonSchema7",
9547	strictUnions: false,
9548	definitions: {},
9549	errorMessages: false,
9550	markdownDescription: false,
9551	patternStrategy: "escape",
9552	applyRegexFlags: false,
9553	emailStrategy: "format:email",
9554	base64Strategy: "contentEncoding:base64",
9555	nameStrategy: "ref",
9556	openAiAnyTypeName: "OpenAiAnyType"
9557	};
9558	var getDefaultOptions = (options) => typeof options === "string" ? {
9559	...defaultOptions,
9560	name: options
9561	} : {
9562	...defaultOptions,
9563	...options
9564	};
9565
9566	//#endregion
9567	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/Refs.js
9568	var getRefs = (options) => {
9569	const _options = getDefaultOptions(options);
9570	const currentPath = _options.name !== void 0 ? [
9571	..._options.basePath,
9572	_options.definitionPath,
9573	_options.name
9574	] : _options.basePath;
9575	return {
9576	..._options,
9577	flags: { hasReferencedOpenAiAnyType: false },
9578	currentPath,
9579	propertyPath: void 0,
9580	seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [def._def, {
9581	def: def._def,
9582	path: [
9583	..._options.basePath,
9584	_options.definitionPath,
9585	name
9586	],
9587	jsonSchema: void 0
9588	}]))
9589	};
9590	};
9591
9592	//#endregion
9593	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
9594	function addErrorMessage(res, key, errorMessage, refs) {
9595	if (!refs?.errorMessages) return;
9596	if (errorMessage) res.errorMessage = {
9597	...res.errorMessage,
9598	[key]: errorMessage
9599	};
9600	}
9601	function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
9602	res[key] = value;
9603	addErrorMessage(res, key, errorMessage, refs);
9604	}
9605
9606	//#endregion
9607	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
9608	var getRelativePath = (pathA, pathB) => {
9609	let i = 0;
9610	for (; i < pathA.length && i < pathB.length; i++) if (pathA[i] !== pathB[i]) break;
9611	return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
9612	};
9613
9614	//#endregion
9615	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
9616	function parseAnyDef(refs) {
9617	if (refs.target !== "openAi") return {};
9618	const anyDefinitionPath = [
9619	...refs.basePath,
9620	refs.definitionPath,
9621	refs.openAiAnyTypeName
9622	];
9623	refs.flags.hasReferencedOpenAiAnyType = true;
9624	return { $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/") };
9625	}
9626
9627	//#endregion
9628	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
9629	function parseArrayDef(def, refs) {
9630	const res = { type: "array" };
9631	if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) res.items = parseDef(def.type._def, {
9632	...refs,
9633	currentPath: [...refs.currentPath, "items"]
9634	});
9635	if (def.minLength) setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
9636	if (def.maxLength) setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
9637	if (def.exactLength) {
9638	setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
9639	setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
9640	}
9641	return res;
9642	}
9643
9644	//#endregion
9645	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
9646	function parseBigintDef(def, refs) {
9647	const res = {
9648	type: "integer",
9649	format: "int64"
9650	};
9651	if (!def.checks) return res;
9652	for (const check of def.checks) switch (check.kind) {
9653	case "min":
9654	if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
9655	else setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
9656	else {
9657	if (!check.inclusive) res.exclusiveMinimum = true;
9658	setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
9659	}
9660	break;
9661	case "max":
9662	if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
9663	else setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
9664	else {
9665	if (!check.inclusive) res.exclusiveMaximum = true;
9666	setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
9667	}
9668	break;
9669	case "multipleOf":
9670	setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
9671	break;
9672	}
9673	return res;
9674	}
9675
9676	//#endregion
9677	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
9678	function parseBooleanDef() {
9679	return { type: "boolean" };
9680	}
9681
9682	//#endregion
9683	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
9684	function parseBrandedDef(_def, refs) {
9685	return parseDef(_def.type._def, refs);
9686	}
9687
9688	//#endregion
9689	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
9690	var parseCatchDef = (def, refs) => {
9691	return parseDef(def.innerType._def, refs);
9692	};
9693
9694	//#endregion
9695	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
9696	function parseDateDef(def, refs, overrideDateStrategy) {
9697	const strategy = overrideDateStrategy ?? refs.dateStrategy;
9698	if (Array.isArray(strategy)) return { anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)) };
9699	switch (strategy) {
9700	case "string":
9701	case "format:date-time": return {
9702	type: "string",
9703	format: "date-time"
9704	};
9705	case "format:date": return {
9706	type: "string",
9707	format: "date"
9708	};
9709	case "integer": return integerDateParser(def, refs);
9710	}
9711	}
9712	var integerDateParser = (def, refs) => {
9713	const res = {
9714	type: "integer",
9715	format: "unix-time"
9716	};
9717	if (refs.target === "openApi3") return res;
9718	for (const check of def.checks) switch (check.kind) {
9719	case "min":
9720	setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
9721	break;
9722	case "max":
9723	setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
9724	break;
9725	}
9726	return res;
9727	};
9728
9729	//#endregion
9730	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
9731	function parseDefaultDef(_def, refs) {
9732	return {
9733	...parseDef(_def.innerType._def, refs),
9734	default: _def.defaultValue()
9735	};
9736	}
9737
9738	//#endregion
9739	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
9740	function parseEffectsDef(_def, refs) {
9741	return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
9742	}
9743
9744	//#endregion
9745	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
9746	function parseEnumDef(def) {
9747	return {
9748	type: "string",
9749	enum: Array.from(def.values)
9750	};
9751	}
9752
9753	//#endregion
9754	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
9755	var isJsonSchema7AllOfType = (type) => {
9756	if ("type" in type && type.type === "string") return false;
9757	return "allOf" in type;
9758	};
9759	function parseIntersectionDef(def, refs) {
9760	const allOf = [parseDef(def.left._def, {
9761	...refs,
9762	currentPath: [
9763	...refs.currentPath,
9764	"allOf",
9765	"0"
9766	]
9767	}), parseDef(def.right._def, {
9768	...refs,
9769	currentPath: [
9770	...refs.currentPath,
9771	"allOf",
9772	"1"
9773	]
9774	})].filter((x) => !!x);
9775	let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
9776	const mergedAllOf = [];
9777	allOf.forEach((schema) => {
9778	if (isJsonSchema7AllOfType(schema)) {
9779	mergedAllOf.push(...schema.allOf);
9780	if (schema.unevaluatedProperties === void 0) unevaluatedProperties = void 0;
9781	} else {
9782	let nestedSchema = schema;
9783	if ("additionalProperties" in schema && schema.additionalProperties === false) {
9784	const { additionalProperties, ...rest } = schema;
9785	nestedSchema = rest;
9786	} else unevaluatedProperties = void 0;
9787	mergedAllOf.push(nestedSchema);
9788	}
9789	});
9790	return mergedAllOf.length ? {
9791	allOf: mergedAllOf,
9792	...unevaluatedProperties
9793	} : void 0;
9794	}
9795
9796	//#endregion
9797	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
9798	function parseLiteralDef(def, refs) {
9799	const parsedType = typeof def.value;
9800	if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") return { type: Array.isArray(def.value) ? "array" : "object" };
9801	if (refs.target === "openApi3") return {
9802	type: parsedType === "bigint" ? "integer" : parsedType,
9803	enum: [def.value]
9804	};
9805	return {
9806	type: parsedType === "bigint" ? "integer" : parsedType,
9807	const: def.value
9808	};
9809	}
9810
9811	//#endregion
9812	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
9813	var emojiRegex = void 0;
9814	/**
9815	* Generated from the regular expressions found here as of 2024-05-22:
9816	* https://github.com/colinhacks/zod/blob/master/src/types.ts.
9817	*
9818	* Expressions with /i flag have been changed accordingly.
9819	*/
9820	var zodPatterns = {
9821	/**
9822	* `c` was changed to `[cC]` to replicate /i flag
9823	*/
9824	cuid: /^[cC][^\s-]{8,}$/,
9825	cuid2: /^[0-9a-z]+$/,
9826	ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
9827	/**
9828	* `a-z` was added to replicate /i flag
9829	*/
9830	email: /^(?!\.)(?!.\.\.)([a-zA-Z0-9_'+\-\.])[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
9831	/**
9832	* Constructed a valid Unicode RegExp
9833	*
9834	* Lazily instantiate since this type of regex isn't supported
9835	* in all envs (e.g. React Native).
9836	*
9837	* See:
9838	* https://github.com/colinhacks/zod/issues/2433
9839	* Fix in Zod:
9840	* https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
9841	*/
9842	emoji: () => {
9843	if (emojiRegex === void 0) emojiRegex = RegExp("^(\\p{Extended_Pictographic}\|\\p{Emoji_Component})+$", "u");
9844	return emojiRegex;
9845	},
9846	/**
9847	* Unused
9848	*/
9849	uuid: /^[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}$/,
9850	/**
9851	* Unused
9852	*/
9853	ipv4: /^(?:(?: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])$/,
9854	ipv4Cidr: /^(?:(?: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])$/,
9855	/**
9856	* Unused
9857	*/
9858	ipv6: /^(([a-f0-9]{1,4}:){7}\|::([a-f0-9]{1,4}:){0,6}\|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}\|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}\|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}\|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}\|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}\|(((25[0-5])\|(2[0-4][0-9])\|(1[0-9]{2})\|([0-9]{1,2}))\.){3}((25[0-5])\|(2[0-4][0-9])\|(1[0-9]{2})\|([0-9]{1,2})))$/,
9859	ipv6Cidr: /^(([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])$/,
9860	base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)\|([0-9a-zA-Z+/]{3}=))?$/,
9861	base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)\|([0-9a-zA-Z-_]{3}(=)?))?$/,
9862	nanoid: /^[a-zA-Z0-9_-]{21}$/,
9863	jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
9864	};
9865	function parseStringDef(def, refs) {
9866	const res = { type: "string" };
9867	if (def.checks) for (const check of def.checks) switch (check.kind) {
9868	case "min":
9869	setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
9870	break;
9871	case "max":
9872	setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
9873	break;
9874	case "email":
9875	switch (refs.emailStrategy) {
9876	case "format:email":
9877	addFormat(res, "email", check.message, refs);
9878	break;
9879	case "format:idn-email":
9880	addFormat(res, "idn-email", check.message, refs);
9881	break;
9882	case "pattern:zod":
9883	addPattern(res, zodPatterns.email, check.message, refs);
9884	break;
9885	}
9886	break;
9887	case "url":
9888	addFormat(res, "uri", check.message, refs);
9889	break;
9890	case "uuid":
9891	addFormat(res, "uuid", check.message, refs);
9892	break;
9893	case "regex":
9894	addPattern(res, check.regex, check.message, refs);
9895	break;
9896	case "cuid":
9897	addPattern(res, zodPatterns.cuid, check.message, refs);
9898	break;
9899	case "cuid2":
9900	addPattern(res, zodPatterns.cuid2, check.message, refs);
9901	break;
9902	case "startsWith":
9903	addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
9904	break;
9905	case "endsWith":
9906	addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
9907	break;
9908	case "datetime":
9909	addFormat(res, "date-time", check.message, refs);
9910	break;
9911	case "date":
9912	addFormat(res, "date", check.message, refs);
9913	break;
9914	case "time":
9915	addFormat(res, "time", check.message, refs);
9916	break;
9917	case "duration":
9918	addFormat(res, "duration", check.message, refs);
9919	break;
9920	case "length":
9921	setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
9922	setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
9923	break;
9924	case "includes":
9925	addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
9926	break;
9927	case "ip":
9928	if (check.version !== "v6") addFormat(res, "ipv4", check.message, refs);
9929	if (check.version !== "v4") addFormat(res, "ipv6", check.message, refs);
9930	break;
9931	case "base64url":
9932	addPattern(res, zodPatterns.base64url, check.message, refs);
9933	break;
9934	case "jwt":
9935	addPattern(res, zodPatterns.jwt, check.message, refs);
9936	break;
9937	case "cidr":
9938	if (check.version !== "v6") addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
9939	if (check.version !== "v4") addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
9940	break;
9941	case "emoji":
9942	addPattern(res, zodPatterns.emoji(), check.message, refs);
9943	break;
9944	case "ulid":
9945	addPattern(res, zodPatterns.ulid, check.message, refs);
9946	break;
9947	case "base64":
9948	switch (refs.base64Strategy) {
9949	case "format:binary":
9950	addFormat(res, "binary", check.message, refs);
9951	break;
9952	case "contentEncoding:base64":
9953	setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
9954	break;
9955	case "pattern:zod":
9956	addPattern(res, zodPatterns.base64, check.message, refs);
9957	break;
9958	}
9959	break;
9960	case "nanoid": addPattern(res, zodPatterns.nanoid, check.message, refs);
9961	case "toLowerCase":
9962	case "toUpperCase":
9963	case "trim": break;
9964	default:
9965	}
9966	return res;
9967	}
9968	function escapeLiteralCheckValue(literal, refs) {
9969	return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
9970	}
9971	var ALPHA_NUMERIC = /* @__PURE__ */ new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
9972	function escapeNonAlphaNumeric(source) {
9973	let result = "";
9974	for (let i = 0; i < source.length; i++) {
9975	if (!ALPHA_NUMERIC.has(source[i])) result += "\\";
9976	result += source[i];
9977	}
9978	return result;
9979	}
9980	function addFormat(schema, value, message, refs) {
9981	if (schema.format \|\| schema.anyOf?.some((x) => x.format)) {
9982	if (!schema.anyOf) schema.anyOf = [];
9983	if (schema.format) {
9984	schema.anyOf.push({
9985	format: schema.format,
9986	...schema.errorMessage && refs.errorMessages && { errorMessage: { format: schema.errorMessage.format } }
9987	});
9988	delete schema.format;
9989	if (schema.errorMessage) {
9990	delete schema.errorMessage.format;
9991	if (Object.keys(schema.errorMessage).length === 0) delete schema.errorMessage;
9992	}
9993	}
9994	schema.anyOf.push({
9995	format: value,
9996	...message && refs.errorMessages && { errorMessage: { format: message } }
9997	});
9998	} else setResponseValueAndErrors(schema, "format", value, message, refs);
9999	}
10000	function addPattern(schema, regex, message, refs) {
10001	if (schema.pattern \|\| schema.allOf?.some((x) => x.pattern)) {
10002	if (!schema.allOf) schema.allOf = [];
10003	if (schema.pattern) {
10004	schema.allOf.push({
10005	pattern: schema.pattern,
10006	...schema.errorMessage && refs.errorMessages && { errorMessage: { pattern: schema.errorMessage.pattern } }
10007	});
10008	delete schema.pattern;
10009	if (schema.errorMessage) {
10010	delete schema.errorMessage.pattern;
10011	if (Object.keys(schema.errorMessage).length === 0) delete schema.errorMessage;
10012	}
10013	}
10014	schema.allOf.push({
10015	pattern: stringifyRegExpWithFlags(regex, refs),
10016	...message && refs.errorMessages && { errorMessage: { pattern: message } }
10017	});
10018	} else setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
10019	}
10020	function stringifyRegExpWithFlags(regex, refs) {
10021	if (!refs.applyRegexFlags \|\| !regex.flags) return regex.source;
10022	const flags = {
10023	i: regex.flags.includes("i"),
10024	m: regex.flags.includes("m"),
10025	s: regex.flags.includes("s")
10026	};
10027	const source = flags.i ? regex.source.toLowerCase() : regex.source;
10028	let pattern = "";
10029	let isEscaped = false;
10030	let inCharGroup = false;
10031	let inCharRange = false;
10032	for (let i = 0; i < source.length; i++) {
10033	if (isEscaped) {
10034	pattern += source[i];
10035	isEscaped = false;
10036	continue;
10037	}
10038	if (flags.i) {
10039	if (inCharGroup) {
10040	if (source[i].match(/[a-z]/)) {
10041	if (inCharRange) {
10042	pattern += source[i];
10043	pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
10044	inCharRange = false;
10045	} else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
10046	pattern += source[i];
10047	inCharRange = true;
10048	} else pattern += `${source[i]}${source[i].toUpperCase()}`;
10049	continue;
10050	}
10051	} else if (source[i].match(/[a-z]/)) {
10052	pattern += `[${source[i]}${source[i].toUpperCase()}]`;
10053	continue;
10054	}
10055	}
10056	if (flags.m) {
10057	if (source[i] === "^") {
10058	pattern += `(^\|(?<=[\r\n]))`;
10059	continue;
10060	} else if (source[i] === "$") {
10061	pattern += `($\|(?=[\r\n]))`;
10062	continue;
10063	}
10064	}
10065	if (flags.s && source[i] === ".") {
10066	pattern += inCharGroup ? `${source[i]}\r\n` : `[${source[i]}\r\n]`;
10067	continue;
10068	}
10069	pattern += source[i];
10070	if (source[i] === "\\") isEscaped = true;
10071	else if (inCharGroup && source[i] === "]") inCharGroup = false;
10072	else if (!inCharGroup && source[i] === "[") inCharGroup = true;
10073	}
10074	try {
10075	new RegExp(pattern);
10076	} catch {
10077	console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
10078	return regex.source;
10079	}
10080	return pattern;
10081	}
10082
10083	//#endregion
10084	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
10085	function parseRecordDef(def, refs) {
10086	if (refs.target === "openAi") console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
10087	if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) return {
10088	type: "object",
10089	required: def.keyType._def.values,
10090	properties: def.keyType._def.values.reduce((acc, key) => ({
10091	...acc,
10092	[key]: parseDef(def.valueType._def, {
10093	...refs,
10094	currentPath: [
10095	...refs.currentPath,
10096	"properties",
10097	key
10098	]
10099	}) ?? parseAnyDef(refs)
10100	}), {}),
10101	additionalProperties: refs.rejectedAdditionalProperties
10102	};
10103	const schema = {
10104	type: "object",
10105	additionalProperties: parseDef(def.valueType._def, {
10106	...refs,
10107	currentPath: [...refs.currentPath, "additionalProperties"]
10108	}) ?? refs.allowedAdditionalProperties
10109	};
10110	if (refs.target === "openApi3") return schema;
10111	if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
10112	const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
10113	return {
10114	...schema,
10115	propertyNames: keyType
10116	};
10117	} else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) return {
10118	...schema,
10119	propertyNames: { enum: def.keyType._def.values }
10120	};
10121	else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
10122	const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
10123	return {
10124	...schema,
10125	propertyNames: keyType
10126	};
10127	}
10128	return schema;
10129	}
10130
10131	//#endregion
10132	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
10133	function parseMapDef(def, refs) {
10134	if (refs.mapStrategy === "record") return parseRecordDef(def, refs);
10135	return {
10136	type: "array",
10137	maxItems: 125,
10138	items: {
10139	type: "array",
10140	items: [parseDef(def.keyType._def, {
10141	...refs,
10142	currentPath: [
10143	...refs.currentPath,
10144	"items",
10145	"items",
10146	"0"
10147	]
10148	}) \|\| parseAnyDef(refs), parseDef(def.valueType._def, {
10149	...refs,
10150	currentPath: [
10151	...refs.currentPath,
10152	"items",
10153	"items",
10154	"1"
10155	]
10156	}) \|\| parseAnyDef(refs)],
10157	minItems: 2,
10158	maxItems: 2
10159	}
10160	};
10161	}
10162
10163	//#endregion
10164	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
10165	function parseNativeEnumDef(def) {
10166	const object = def.values;
10167	const actualValues = Object.keys(def.values).filter((key) => {
10168	return typeof object[object[key]] !== "number";
10169	}).map((key) => object[key]);
10170	const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
10171	return {
10172	type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
10173	enum: actualValues
10174	};
10175	}
10176
10177	//#endregion
10178	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
10179	function parseNeverDef(refs) {
10180	return refs.target === "openAi" ? void 0 : { not: parseAnyDef({
10181	...refs,
10182	currentPath: [...refs.currentPath, "not"]
10183	}) };
10184	}
10185
10186	//#endregion
10187	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
10188	function parseNullDef(refs) {
10189	return refs.target === "openApi3" ? {
10190	enum: ["null"],
10191	nullable: true
10192	} : { type: "null" };
10193	}
10194
10195	//#endregion
10196	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
10197	var primitiveMappings = {
10198	ZodString: "string",
10199	ZodNumber: "number",
10200	ZodBigInt: "integer",
10201	ZodBoolean: "boolean",
10202	ZodNull: "null"
10203	};
10204	function parseUnionDef(def, refs) {
10205	if (refs.target === "openApi3") return asAnyOf(def, refs);
10206	const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
10207	if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks \|\| !x._def.checks.length))) {
10208	const types = options.reduce((types, x) => {
10209	const type = primitiveMappings[x._def.typeName];
10210	return type && !types.includes(type) ? [...types, type] : types;
10211	}, []);
10212	return { type: types.length > 1 ? types : types[0] };
10213	} else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
10214	const types = options.reduce((acc, x) => {
10215	const type = typeof x._def.value;
10216	switch (type) {
10217	case "string":
10218	case "number":
10219	case "boolean": return [...acc, type];
10220	case "bigint": return [...acc, "integer"];
10221	case "object": if (x._def.value === null) return [...acc, "null"];
10222	default: return acc;
10223	}
10224	}, []);
10225	if (types.length === options.length) {
10226	const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
10227	return {
10228	type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
10229	enum: options.reduce((acc, x) => {
10230	return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
10231	}, [])
10232	};
10233	}
10234	} else if (options.every((x) => x._def.typeName === "ZodEnum")) return {
10235	type: "string",
10236	enum: options.reduce((acc, x) => [...acc, ...x._def.values.filter((x) => !acc.includes(x))], [])
10237	};
10238	return asAnyOf(def, refs);
10239	}
10240	var asAnyOf = (def, refs) => {
10241	const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
10242	...refs,
10243	currentPath: [
10244	...refs.currentPath,
10245	"anyOf",
10246	`${i}`
10247	]
10248	})).filter((x) => !!x && (!refs.strictUnions \|\| typeof x === "object" && Object.keys(x).length > 0));
10249	return anyOf.length ? { anyOf } : void 0;
10250	};
10251
10252	//#endregion
10253	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
10254	function parseNullableDef(def, refs) {
10255	if ([
10256	"ZodString",
10257	"ZodNumber",
10258	"ZodBigInt",
10259	"ZodBoolean",
10260	"ZodNull"
10261	].includes(def.innerType._def.typeName) && (!def.innerType._def.checks \|\| !def.innerType._def.checks.length)) {
10262	if (refs.target === "openApi3") return {
10263	type: primitiveMappings[def.innerType._def.typeName],
10264	nullable: true
10265	};
10266	return { type: [primitiveMappings[def.innerType._def.typeName], "null"] };
10267	}
10268	if (refs.target === "openApi3") {
10269	const base = parseDef(def.innerType._def, {
10270	...refs,
10271	currentPath: [...refs.currentPath]
10272	});
10273	if (base && "$ref" in base) return {
10274	allOf: [base],
10275	nullable: true
10276	};
10277	return base && {
10278	...base,
10279	nullable: true
10280	};
10281	}
10282	const base = parseDef(def.innerType._def, {
10283	...refs,
10284	currentPath: [
10285	...refs.currentPath,
10286	"anyOf",
10287	"0"
10288	]
10289	});
10290	return base && { anyOf: [base, { type: "null" }] };
10291	}
10292
10293	//#endregion
10294	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
10295	function parseNumberDef(def, refs) {
10296	const res = { type: "number" };
10297	if (!def.checks) return res;
10298	for (const check of def.checks) switch (check.kind) {
10299	case "int":
10300	res.type = "integer";
10301	addErrorMessage(res, "type", check.message, refs);
10302	break;
10303	case "min":
10304	if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
10305	else setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
10306	else {
10307	if (!check.inclusive) res.exclusiveMinimum = true;
10308	setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
10309	}
10310	break;
10311	case "max":
10312	if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
10313	else setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
10314	else {
10315	if (!check.inclusive) res.exclusiveMaximum = true;
10316	setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
10317	}
10318	break;
10319	case "multipleOf":
10320	setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
10321	break;
10322	}
10323	return res;
10324	}
10325
10326	//#endregion
10327	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
10328	function parseObjectDef(def, refs) {
10329	const forceOptionalIntoNullable = refs.target === "openAi";
10330	const result = {
10331	type: "object",
10332	properties: {}
10333	};
10334	const required = [];
10335	const shape = def.shape();
10336	for (const propName in shape) {
10337	let propDef = shape[propName];
10338	if (propDef === void 0 \|\| propDef._def === void 0) continue;
10339	let propOptional = safeIsOptional(propDef);
10340	if (propOptional && forceOptionalIntoNullable) {
10341	if (propDef._def.typeName === "ZodOptional") propDef = propDef._def.innerType;
10342	if (!propDef.isNullable()) propDef = propDef.nullable();
10343	propOptional = false;
10344	}
10345	const parsedDef = parseDef(propDef._def, {
10346	...refs,
10347	currentPath: [
10348	...refs.currentPath,
10349	"properties",
10350	propName
10351	],
10352	propertyPath: [
10353	...refs.currentPath,
10354	"properties",
10355	propName
10356	]
10357	});
10358	if (parsedDef === void 0) continue;
10359	result.properties[propName] = parsedDef;
10360	if (!propOptional) required.push(propName);
10361	}
10362	if (required.length) result.required = required;
10363	const additionalProperties = decideAdditionalProperties(def, refs);
10364	if (additionalProperties !== void 0) result.additionalProperties = additionalProperties;
10365	return result;
10366	}
10367	function decideAdditionalProperties(def, refs) {
10368	if (def.catchall._def.typeName !== "ZodNever") return parseDef(def.catchall._def, {
10369	...refs,
10370	currentPath: [...refs.currentPath, "additionalProperties"]
10371	});
10372	switch (def.unknownKeys) {
10373	case "passthrough": return refs.allowedAdditionalProperties;
10374	case "strict": return refs.rejectedAdditionalProperties;
10375	case "strip": return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
10376	}
10377	}
10378	function safeIsOptional(schema) {
10379	try {
10380	return schema.isOptional();
10381	} catch {
10382	return true;
10383	}
10384	}
10385
10386	//#endregion
10387	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
10388	var parseOptionalDef = (def, refs) => {
10389	if (refs.currentPath.toString() === refs.propertyPath?.toString()) return parseDef(def.innerType._def, refs);
10390	const innerSchema = parseDef(def.innerType._def, {
10391	...refs,
10392	currentPath: [
10393	...refs.currentPath,
10394	"anyOf",
10395	"1"
10396	]
10397	});
10398	return innerSchema ? { anyOf: [{ not: parseAnyDef(refs) }, innerSchema] } : parseAnyDef(refs);
10399	};
10400
10401	//#endregion
10402	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
10403	var parsePipelineDef = (def, refs) => {
10404	if (refs.pipeStrategy === "input") return parseDef(def.in._def, refs);
10405	else if (refs.pipeStrategy === "output") return parseDef(def.out._def, refs);
10406	const a = parseDef(def.in._def, {
10407	...refs,
10408	currentPath: [
10409	...refs.currentPath,
10410	"allOf",
10411	"0"
10412	]
10413	});
10414	return { allOf: [a, parseDef(def.out._def, {
10415	...refs,
10416	currentPath: [
10417	...refs.currentPath,
10418	"allOf",
10419	a ? "1" : "0"
10420	]
10421	})].filter((x) => x !== void 0) };
10422	};
10423
10424	//#endregion
10425	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
10426	function parsePromiseDef(def, refs) {
10427	return parseDef(def.type._def, refs);
10428	}
10429
10430	//#endregion
10431	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
10432	function parseSetDef(def, refs) {
10433	const schema = {
10434	type: "array",
10435	uniqueItems: true,
10436	items: parseDef(def.valueType._def, {
10437	...refs,
10438	currentPath: [...refs.currentPath, "items"]
10439	})
10440	};
10441	if (def.minSize) setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
10442	if (def.maxSize) setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
10443	return schema;
10444	}
10445
10446	//#endregion
10447	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
10448	function parseTupleDef(def, refs) {
10449	if (def.rest) return {
10450	type: "array",
10451	minItems: def.items.length,
10452	items: def.items.map((x, i) => parseDef(x._def, {
10453	...refs,
10454	currentPath: [
10455	...refs.currentPath,
10456	"items",
10457	`${i}`
10458	]
10459	})).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
10460	additionalItems: parseDef(def.rest._def, {
10461	...refs,
10462	currentPath: [...refs.currentPath, "additionalItems"]
10463	})
10464	};
10465	else return {
10466	type: "array",
10467	minItems: def.items.length,
10468	maxItems: def.items.length,
10469	items: def.items.map((x, i) => parseDef(x._def, {
10470	...refs,
10471	currentPath: [
10472	...refs.currentPath,
10473	"items",
10474	`${i}`
10475	]
10476	})).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
10477	};
10478	}
10479
10480	//#endregion
10481	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
10482	function parseUndefinedDef(refs) {
10483	return { not: parseAnyDef(refs) };
10484	}
10485
10486	//#endregion
10487	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
10488	function parseUnknownDef(refs) {
10489	return parseAnyDef(refs);
10490	}
10491
10492	//#endregion
10493	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
10494	var parseReadonlyDef = (def, refs) => {
10495	return parseDef(def.innerType._def, refs);
10496	};
10497
10498	//#endregion
10499	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/selectParser.js
10500	var selectParser = (def, typeName, refs) => {
10501	switch (typeName) {
10502	case ZodFirstPartyTypeKind.ZodString: return parseStringDef(def, refs);
10503	case ZodFirstPartyTypeKind.ZodNumber: return parseNumberDef(def, refs);
10504	case ZodFirstPartyTypeKind.ZodObject: return parseObjectDef(def, refs);
10505	case ZodFirstPartyTypeKind.ZodBigInt: return parseBigintDef(def, refs);
10506	case ZodFirstPartyTypeKind.ZodBoolean: return parseBooleanDef();
10507	case ZodFirstPartyTypeKind.ZodDate: return parseDateDef(def, refs);
10508	case ZodFirstPartyTypeKind.ZodUndefined: return parseUndefinedDef(refs);
10509	case ZodFirstPartyTypeKind.ZodNull: return parseNullDef(refs);
10510	case ZodFirstPartyTypeKind.ZodArray: return parseArrayDef(def, refs);
10511	case ZodFirstPartyTypeKind.ZodUnion:
10512	case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: return parseUnionDef(def, refs);
10513	case ZodFirstPartyTypeKind.ZodIntersection: return parseIntersectionDef(def, refs);
10514	case ZodFirstPartyTypeKind.ZodTuple: return parseTupleDef(def, refs);
10515	case ZodFirstPartyTypeKind.ZodRecord: return parseRecordDef(def, refs);
10516	case ZodFirstPartyTypeKind.ZodLiteral: return parseLiteralDef(def, refs);
10517	case ZodFirstPartyTypeKind.ZodEnum: return parseEnumDef(def);
10518	case ZodFirstPartyTypeKind.ZodNativeEnum: return parseNativeEnumDef(def);
10519	case ZodFirstPartyTypeKind.ZodNullable: return parseNullableDef(def, refs);
10520	case ZodFirstPartyTypeKind.ZodOptional: return parseOptionalDef(def, refs);
10521	case ZodFirstPartyTypeKind.ZodMap: return parseMapDef(def, refs);
10522	case ZodFirstPartyTypeKind.ZodSet: return parseSetDef(def, refs);
10523	case ZodFirstPartyTypeKind.ZodLazy: return () => def.getter()._def;
10524	case ZodFirstPartyTypeKind.ZodPromise: return parsePromiseDef(def, refs);
10525	case ZodFirstPartyTypeKind.ZodNaN:
10526	case ZodFirstPartyTypeKind.ZodNever: return parseNeverDef(refs);
10527	case ZodFirstPartyTypeKind.ZodEffects: return parseEffectsDef(def, refs);
10528	case ZodFirstPartyTypeKind.ZodAny: return parseAnyDef(refs);
10529	case ZodFirstPartyTypeKind.ZodUnknown: return parseUnknownDef(refs);
10530	case ZodFirstPartyTypeKind.ZodDefault: return parseDefaultDef(def, refs);
10531	case ZodFirstPartyTypeKind.ZodBranded: return parseBrandedDef(def, refs);
10532	case ZodFirstPartyTypeKind.ZodReadonly: return parseReadonlyDef(def, refs);
10533	case ZodFirstPartyTypeKind.ZodCatch: return parseCatchDef(def, refs);
10534	case ZodFirstPartyTypeKind.ZodPipeline: return parsePipelineDef(def, refs);
10535	case ZodFirstPartyTypeKind.ZodFunction:
10536	case ZodFirstPartyTypeKind.ZodVoid:
10537	case ZodFirstPartyTypeKind.ZodSymbol: return;
10538	default: return ((_) => void 0)(typeName);
10539	}
10540	};
10541
10542	//#endregion
10543	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parseDef.js
10544	function parseDef(def, refs, forceResolution = false) {
10545	const seenItem = refs.seen.get(def);
10546	if (refs.override) {
10547	const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
10548	if (overrideResult !== ignoreOverride) return overrideResult;
10549	}
10550	if (seenItem && !forceResolution) {
10551	const seenSchema = get$ref(seenItem, refs);
10552	if (seenSchema !== void 0) return seenSchema;
10553	}
10554	const newItem = {
10555	def,
10556	path: refs.currentPath,
10557	jsonSchema: void 0
10558	};
10559	refs.seen.set(def, newItem);
10560	const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
10561	const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
10562	if (jsonSchema) addMeta(def, refs, jsonSchema);
10563	if (refs.postProcess) {
10564	const postProcessResult = refs.postProcess(jsonSchema, def, refs);
10565	newItem.jsonSchema = jsonSchema;
10566	return postProcessResult;
10567	}
10568	newItem.jsonSchema = jsonSchema;
10569	return jsonSchema;
10570	}
10571	var get$ref = (item, refs) => {
10572	switch (refs.$refStrategy) {
10573	case "root": return { $ref: item.path.join("/") };
10574	case "relative": return { $ref: getRelativePath(refs.currentPath, item.path) };
10575	case "none":
10576	case "seen":
10577	if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
10578	console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
10579	return parseAnyDef(refs);
10580	}
10581	return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
10582	}
10583	};
10584	var addMeta = (def, refs, jsonSchema) => {
10585	if (def.description) {
10586	jsonSchema.description = def.description;
10587	if (refs.markdownDescription) jsonSchema.markdownDescription = def.description;
10588	}
10589	return jsonSchema;
10590	};
10591
10592	//#endregion
10593	//#region node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
10594	var zodToJsonSchema = (schema, options) => {
10595	const refs = getRefs(options);
10596	let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({
10597	...acc,
10598	[name]: parseDef(schema._def, {
10599	...refs,
10600	currentPath: [
10601	...refs.basePath,
10602	refs.definitionPath,
10603	name
10604	]
10605	}, true) ?? parseAnyDef(refs)
10606	}), {}) : void 0;
10607	const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
10608	const main = parseDef(schema._def, name === void 0 ? refs : {
10609	...refs,
10610	currentPath: [
10611	...refs.basePath,
10612	refs.definitionPath,
10613	name
10614	]
10615	}, false) ?? parseAnyDef(refs);
10616	const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
10617	if (title !== void 0) main.title = title;
10618	if (refs.flags.hasReferencedOpenAiAnyType) {
10619	if (!definitions) definitions = {};
10620	if (!definitions[refs.openAiAnyTypeName]) definitions[refs.openAiAnyTypeName] = {
10621	type: [
10622	"string",
10623	"number",
10624	"integer",
10625	"boolean",
10626	"array",
10627	"null"
10628	],
10629	items: { $ref: refs.$refStrategy === "relative" ? "1" : [
10630	...refs.basePath,
10631	refs.definitionPath,
10632	refs.openAiAnyTypeName
10633	].join("/") }
10634	};
10635	}
10636	const combined = name === void 0 ? definitions ? {
10637	...main,
10638	[refs.definitionPath]: definitions
10639	} : main : {
10640	$ref: [
10641	...refs.$refStrategy === "relative" ? [] : refs.basePath,
10642	refs.definitionPath,
10643	name
10644	].join("/"),
10645	[refs.definitionPath]: {
10646	...definitions,
10647	[name]: main
10648	}
10649	};
10650	if (refs.target === "jsonSchema7") combined.$schema = "http://json-schema.org/draft-07/schema#";
10651	else if (refs.target === "jsonSchema2019-09" \|\| refs.target === "openAi") combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
10652	if (refs.target === "openAi" && ("anyOf" in combined \|\| "oneOf" in combined \|\| "allOf" in combined \|\| "type" in combined && Array.isArray(combined.type))) console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
10653	return combined;
10654	};
10655
10656	//#endregion
10657	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
10658	function mapMiniTarget(t) {
10659	if (!t) return "draft-7";
10660	if (t === "jsonSchema7" \|\| t === "draft-7") return "draft-7";
10661	if (t === "jsonSchema2019-09" \|\| t === "draft-2020-12") return "draft-2020-12";
10662	return "draft-7";
10663	}
10664	function toJsonSchemaCompat(schema, opts) {
10665	if (isZ4Schema(schema)) return toJSONSchema(schema, {
10666	target: mapMiniTarget(opts?.target),
10667	io: opts?.pipeStrategy ?? "input"
10668	});
10669	return zodToJsonSchema(schema, {
10670	strictUnions: opts?.strictUnions ?? true,
10671	pipeStrategy: opts?.pipeStrategy ?? "input"
10672	});
10673	}
10674	function getMethodLiteral(schema) {
10675	const methodSchema = getObjectShape(schema)?.method;
10676	if (!methodSchema) throw new Error("Schema is missing a method literal");
10677	const value = getLiteralValue(methodSchema);
10678	if (typeof value !== "string") throw new Error("Schema method literal must be a string");
10679	return value;
10680	}
10681	function parseWithCompat(schema, data) {
10682	const result = safeParse$1(schema, data);
10683	if (!result.success) throw result.error;
10684	return result.data;
10685	}
10686
10687	//#endregion
10688	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
10689	/**
10690	* The default request timeout, in miliseconds.
10691	*/
10692	var DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
10693	/**
10694	* Implements MCP protocol framing on top of a pluggable transport, including
10695	* features like request/response linking, notifications, and progress.
10696	*/
10697	var Protocol = class {
10698	constructor(_options) {
10699	this._options = _options;
10700	this._requestMessageId = 0;
10701	this._requestHandlers = /* @__PURE__ */ new Map();
10702	this._requestHandlerAbortControllers = /* @__PURE__ */ new Map();
10703	this._notificationHandlers = /* @__PURE__ */ new Map();
10704	this._responseHandlers = /* @__PURE__ */ new Map();
10705	this._progressHandlers = /* @__PURE__ */ new Map();
10706	this._timeoutInfo = /* @__PURE__ */ new Map();
10707	this._pendingDebouncedNotifications = /* @__PURE__ */ new Set();
10708	this._taskProgressTokens = /* @__PURE__ */ new Map();
10709	this._requestResolvers = /* @__PURE__ */ new Map();
10710	this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
10711	this._oncancel(notification);
10712	});
10713	this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
10714	this._onprogress(notification);
10715	});
10716	this.setRequestHandler(PingRequestSchema, (_request) => ({}));
10717	this._taskStore = _options?.taskStore;
10718	this._taskMessageQueue = _options?.taskMessageQueue;
10719	if (this._taskStore) {
10720	this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
10721	const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
10722	if (!task) throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
10723	return { ...task };
10724	});
10725	this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
10726	const handleTaskResult = async () => {
10727	const taskId = request.params.taskId;
10728	if (this._taskMessageQueue) {
10729	let queuedMessage;
10730	while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
10731	if (queuedMessage.type === "response" \|\| queuedMessage.type === "error") {
10732	const message = queuedMessage.message;
10733	const requestId = message.id;
10734	const resolver = this._requestResolvers.get(requestId);
10735	if (resolver) {
10736	this._requestResolvers.delete(requestId);
10737	if (queuedMessage.type === "response") resolver(message);
10738	else {
10739	const errorMessage = message;
10740	resolver(new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data));
10741	}
10742	} else {
10743	const messageType = queuedMessage.type === "response" ? "Response" : "Error";
10744	this._onerror(/* @__PURE__ */ new Error(`${messageType} handler missing for request ${requestId}`));
10745	}
10746	continue;
10747	}
10748	await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId });
10749	}
10750	}
10751	const task = await this._taskStore.getTask(taskId, extra.sessionId);
10752	if (!task) throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
10753	if (!isTerminal(task.status)) {
10754	await this._waitForTaskUpdate(taskId, extra.signal);
10755	return await handleTaskResult();
10756	}
10757	if (isTerminal(task.status)) {
10758	const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
10759	this._clearTaskQueue(taskId);
10760	return {
10761	...result,
10762	_meta: {
10763	...result._meta,
10764	[RELATED_TASK_META_KEY]: { taskId }
10765	}
10766	};
10767	}
10768	return await handleTaskResult();
10769	};
10770	return await handleTaskResult();
10771	});
10772	this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
10773	try {
10774	const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
10775	return {
10776	tasks,
10777	nextCursor,
10778	_meta: {}
10779	};
10780	} catch (error) {
10781	throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error instanceof Error ? error.message : String(error)}`);
10782	}
10783	});
10784	this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
10785	try {
10786	const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
10787	if (!task) throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
10788	if (isTerminal(task.status)) throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
10789	await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
10790	this._clearTaskQueue(request.params.taskId);
10791	const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
10792	if (!cancelledTask) throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
10793	return {
10794	_meta: {},
10795	...cancelledTask
10796	};
10797	} catch (error) {
10798	if (error instanceof McpError) throw error;
10799	throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error instanceof Error ? error.message : String(error)}`);
10800	}
10801	});
10802	}
10803	}
10804	async _oncancel(notification) {
10805	if (!notification.params.requestId) return;
10806	this._requestHandlerAbortControllers.get(notification.params.requestId)?.abort(notification.params.reason);
10807	}
10808	_setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
10809	this._timeoutInfo.set(messageId, {
10810	timeoutId: setTimeout(onTimeout, timeout),
10811	startTime: Date.now(),
10812	timeout,
10813	maxTotalTimeout,
10814	resetTimeoutOnProgress,
10815	onTimeout
10816	});
10817	}
10818	_resetTimeout(messageId) {
10819	const info = this._timeoutInfo.get(messageId);
10820	if (!info) return false;
10821	const totalElapsed = Date.now() - info.startTime;
10822	if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
10823	this._timeoutInfo.delete(messageId);
10824	throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
10825	maxTotalTimeout: info.maxTotalTimeout,
10826	totalElapsed
10827	});
10828	}
10829	clearTimeout(info.timeoutId);
10830	info.timeoutId = setTimeout(info.onTimeout, info.timeout);
10831	return true;
10832	}
10833	_cleanupTimeout(messageId) {
10834	const info = this._timeoutInfo.get(messageId);
10835	if (info) {
10836	clearTimeout(info.timeoutId);
10837	this._timeoutInfo.delete(messageId);
10838	}
10839	}
10840	/**
10841	* Attaches to the given transport, starts it, and starts listening for messages.
10842	*
10843	* The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
10844	*/
10845	async connect(transport) {
10846	if (this._transport) throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection.");
10847	this._transport = transport;
10848	const _onclose = this.transport?.onclose;
10849	this._transport.onclose = () => {
10850	_onclose?.();
10851	this._onclose();
10852	};
10853	const _onerror = this.transport?.onerror;
10854	this._transport.onerror = (error) => {
10855	_onerror?.(error);
10856	this._onerror(error);
10857	};
10858	const _onmessage = this._transport?.onmessage;
10859	this._transport.onmessage = (message, extra) => {
10860	_onmessage?.(message, extra);
10861	if (isJSONRPCResultResponse(message) \|\| isJSONRPCErrorResponse(message)) this._onresponse(message);
10862	else if (isJSONRPCRequest(message)) this._onrequest(message, extra);
10863	else if (isJSONRPCNotification(message)) this._onnotification(message);
10864	else this._onerror(/* @__PURE__ */ new Error(`Unknown message type: ${JSON.stringify(message)}`));
10865	};
10866	await this._transport.start();
10867	}
10868	_onclose() {
10869	const responseHandlers = this._responseHandlers;
10870	this._responseHandlers = /* @__PURE__ */ new Map();
10871	this._progressHandlers.clear();
10872	this._taskProgressTokens.clear();
10873	this._pendingDebouncedNotifications.clear();
10874	for (const controller of this._requestHandlerAbortControllers.values()) controller.abort();
10875	this._requestHandlerAbortControllers.clear();
10876	const error = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
10877	this._transport = void 0;
10878	this.onclose?.();
10879	for (const handler of responseHandlers.values()) handler(error);
10880	}
10881	_onerror(error) {
10882	this.onerror?.(error);
10883	}
10884	_onnotification(notification) {
10885	const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
10886	if (handler === void 0) return;
10887	Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Uncaught error in notification handler: ${error}`)));
10888	}
10889	_onrequest(request, extra) {
10890	const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
10891	const capturedTransport = this._transport;
10892	const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
10893	if (handler === void 0) {
10894	const errorResponse = {
10895	jsonrpc: "2.0",
10896	id: request.id,
10897	error: {
10898	code: ErrorCode.MethodNotFound,
10899	message: "Method not found"
10900	}
10901	};
10902	if (relatedTaskId && this._taskMessageQueue) this._enqueueTaskMessage(relatedTaskId, {
10903	type: "error",
10904	message: errorResponse,
10905	timestamp: Date.now()
10906	}, capturedTransport?.sessionId).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to enqueue error response: ${error}`)));
10907	else capturedTransport?.send(errorResponse).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send an error response: ${error}`)));
10908	return;
10909	}
10910	const abortController = new AbortController();
10911	this._requestHandlerAbortControllers.set(request.id, abortController);
10912	const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : void 0;
10913	const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : void 0;
10914	const fullExtra = {
10915	signal: abortController.signal,
10916	sessionId: capturedTransport?.sessionId,
10917	_meta: request.params?._meta,
10918	sendNotification: async (notification) => {
10919	if (abortController.signal.aborted) return;
10920	const notificationOptions = { relatedRequestId: request.id };
10921	if (relatedTaskId) notificationOptions.relatedTask = { taskId: relatedTaskId };
10922	await this.notification(notification, notificationOptions);
10923	},
10924	sendRequest: async (r, resultSchema, options) => {
10925	if (abortController.signal.aborted) throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
10926	const requestOptions = {
10927	...options,
10928	relatedRequestId: request.id
10929	};
10930	if (relatedTaskId && !requestOptions.relatedTask) requestOptions.relatedTask = { taskId: relatedTaskId };
10931	const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId;
10932	if (effectiveTaskId && taskStore) await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
10933	return await this.request(r, resultSchema, requestOptions);
10934	},
10935	authInfo: extra?.authInfo,
10936	requestId: request.id,
10937	requestInfo: extra?.requestInfo,
10938	taskId: relatedTaskId,
10939	taskStore,
10940	taskRequestedTtl: taskCreationParams?.ttl,
10941	closeSSEStream: extra?.closeSSEStream,
10942	closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
10943	};
10944	Promise.resolve().then(() => {
10945	if (taskCreationParams) this.assertTaskHandlerCapability(request.method);
10946	}).then(() => handler(request, fullExtra)).then(async (result) => {
10947	if (abortController.signal.aborted) return;
10948	const response = {
10949	result,
10950	jsonrpc: "2.0",
10951	id: request.id
10952	};
10953	if (relatedTaskId && this._taskMessageQueue) await this._enqueueTaskMessage(relatedTaskId, {
10954	type: "response",
10955	message: response,
10956	timestamp: Date.now()
10957	}, capturedTransport?.sessionId);
10958	else await capturedTransport?.send(response);
10959	}, async (error) => {
10960	if (abortController.signal.aborted) return;
10961	const errorResponse = {
10962	jsonrpc: "2.0",
10963	id: request.id,
10964	error: {
10965	code: Number.isSafeInteger(error["code"]) ? error["code"] : ErrorCode.InternalError,
10966	message: error.message ?? "Internal error",
10967	...error["data"] !== void 0 && { data: error["data"] }
10968	}
10969	};
10970	if (relatedTaskId && this._taskMessageQueue) await this._enqueueTaskMessage(relatedTaskId, {
10971	type: "error",
10972	message: errorResponse,
10973	timestamp: Date.now()
10974	}, capturedTransport?.sessionId);
10975	else await capturedTransport?.send(errorResponse);
10976	}).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send response: ${error}`))).finally(() => {
10977	this._requestHandlerAbortControllers.delete(request.id);
10978	});
10979	}
10980	_onprogress(notification) {
10981	const { progressToken, ...params } = notification.params;
10982	const messageId = Number(progressToken);
10983	const handler = this._progressHandlers.get(messageId);
10984	if (!handler) {
10985	this._onerror(/* @__PURE__ */ new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
10986	return;
10987	}
10988	const responseHandler = this._responseHandlers.get(messageId);
10989	const timeoutInfo = this._timeoutInfo.get(messageId);
10990	if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) try {
10991	this._resetTimeout(messageId);
10992	} catch (error) {
10993	this._responseHandlers.delete(messageId);
10994	this._progressHandlers.delete(messageId);
10995	this._cleanupTimeout(messageId);
10996	responseHandler(error);
10997	return;
10998	}
10999	handler(params);
11000	}
11001	_onresponse(response) {
11002	const messageId = Number(response.id);
11003	const resolver = this._requestResolvers.get(messageId);
11004	if (resolver) {
11005	this._requestResolvers.delete(messageId);
11006	if (isJSONRPCResultResponse(response)) resolver(response);
11007	else resolver(new McpError(response.error.code, response.error.message, response.error.data));
11008	return;
11009	}
11010	const handler = this._responseHandlers.get(messageId);
11011	if (handler === void 0) {
11012	this._onerror(/* @__PURE__ */ new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
11013	return;
11014	}
11015	this._responseHandlers.delete(messageId);
11016	this._cleanupTimeout(messageId);
11017	let isTaskResponse = false;
11018	if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
11019	const result = response.result;
11020	if (result.task && typeof result.task === "object") {
11021	const task = result.task;
11022	if (typeof task.taskId === "string") {
11023	isTaskResponse = true;
11024	this._taskProgressTokens.set(task.taskId, messageId);
11025	}
11026	}
11027	}
11028	if (!isTaskResponse) this._progressHandlers.delete(messageId);
11029	if (isJSONRPCResultResponse(response)) handler(response);
11030	else handler(McpError.fromError(response.error.code, response.error.message, response.error.data));
11031	}
11032	get transport() {
11033	return this._transport;
11034	}
11035	/**
11036	* Closes the connection.
11037	*/
11038	async close() {
11039	await this._transport?.close();
11040	}
11041	/**
11042	* Sends a request and returns an AsyncGenerator that yields response messages.
11043	* The generator is guaranteed to end with either a 'result' or 'error' message.
11044	*
11045	* @example
11046	* ```typescript
11047	* const stream = protocol.requestStream(request, resultSchema, options);
11048	* for await (const message of stream) {
11049	* switch (message.type) {
11050	* case 'taskCreated':
11051	* console.log('Task created:', message.task.taskId);
11052	* break;
11053	* case 'taskStatus':
11054	* console.log('Task status:', message.task.status);
11055	* break;
11056	* case 'result':
11057	* console.log('Final result:', message.result);
11058	* break;
11059	* case 'error':
11060	* console.error('Error:', message.error);
11061	* break;
11062	* }
11063	* }
11064	* ```
11065	*
11066	* @experimental Use `client.experimental.tasks.requestStream()` to access this method.
11067	*/
11068	async *requestStream(request, resultSchema, options) {
11069	const { task } = options ?? {};
11070	if (!task) {
11071	try {
11072	yield {
11073	type: "result",
11074	result: await this.request(request, resultSchema, options)
11075	};
11076	} catch (error) {
11077	yield {
11078	type: "error",
11079	error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
11080	};
11081	}
11082	return;
11083	}
11084	let taskId;
11085	try {
11086	const createResult = await this.request(request, CreateTaskResultSchema, options);
11087	if (createResult.task) {
11088	taskId = createResult.task.taskId;
11089	yield {
11090	type: "taskCreated",
11091	task: createResult.task
11092	};
11093	} else throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
11094	while (true) {
11095	const task = await this.getTask({ taskId }, options);
11096	yield {
11097	type: "taskStatus",
11098	task
11099	};
11100	if (isTerminal(task.status)) {
11101	if (task.status === "completed") yield {
11102	type: "result",
11103	result: await this.getTaskResult({ taskId }, resultSchema, options)
11104	};
11105	else if (task.status === "failed") yield {
11106	type: "error",
11107	error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
11108	};
11109	else if (task.status === "cancelled") yield {
11110	type: "error",
11111	error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
11112	};
11113	return;
11114	}
11115	if (task.status === "input_required") {
11116	yield {
11117	type: "result",
11118	result: await this.getTaskResult({ taskId }, resultSchema, options)
11119	};
11120	return;
11121	}
11122	const pollInterval = task.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
11123	await new Promise((resolve) => setTimeout(resolve, pollInterval));
11124	options?.signal?.throwIfAborted();
11125	}
11126	} catch (error) {
11127	yield {
11128	type: "error",
11129	error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
11130	};
11131	}
11132	}
11133	/**
11134	* Sends a request and waits for a response.
11135	*
11136	* Do not use this method to emit notifications! Use notification() instead.
11137	*/
11138	request(request, resultSchema, options) {
11139	const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
11140	return new Promise((resolve, reject) => {
11141	const earlyReject = (error) => {
11142	reject(error);
11143	};
11144	if (!this._transport) {
11145	earlyReject(/* @__PURE__ */ new Error("Not connected"));
11146	return;
11147	}
11148	if (this._options?.enforceStrictCapabilities === true) try {
11149	this.assertCapabilityForMethod(request.method);
11150	if (task) this.assertTaskCapability(request.method);
11151	} catch (e) {
11152	earlyReject(e);
11153	return;
11154	}
11155	options?.signal?.throwIfAborted();
11156	const messageId = this._requestMessageId++;
11157	const jsonrpcRequest = {
11158	...request,
11159	jsonrpc: "2.0",
11160	id: messageId
11161	};
11162	if (options?.onprogress) {
11163	this._progressHandlers.set(messageId, options.onprogress);
11164	jsonrpcRequest.params = {
11165	...request.params,
11166	_meta: {
11167	...request.params?._meta \|\| {},
11168	progressToken: messageId
11169	}
11170	};
11171	}
11172	if (task) jsonrpcRequest.params = {
11173	...jsonrpcRequest.params,
11174	task
11175	};
11176	if (relatedTask) jsonrpcRequest.params = {
11177	...jsonrpcRequest.params,
11178	_meta: {
11179	...jsonrpcRequest.params?._meta \|\| {},
11180	[RELATED_TASK_META_KEY]: relatedTask
11181	}
11182	};
11183	const cancel = (reason) => {
11184	this._responseHandlers.delete(messageId);
11185	this._progressHandlers.delete(messageId);
11186	this._cleanupTimeout(messageId);
11187	this._transport?.send({
11188	jsonrpc: "2.0",
11189	method: "notifications/cancelled",
11190	params: {
11191	requestId: messageId,
11192	reason: String(reason)
11193	}
11194	}, {
11195	relatedRequestId,
11196	resumptionToken,
11197	onresumptiontoken
11198	}).catch((error) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error}`)));
11199	reject(reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason)));
11200	};
11201	this._responseHandlers.set(messageId, (response) => {
11202	if (options?.signal?.aborted) return;
11203	if (response instanceof Error) return reject(response);
11204	try {
11205	const parseResult = safeParse$1(resultSchema, response.result);
11206	if (!parseResult.success) reject(parseResult.error);
11207	else resolve(parseResult.data);
11208	} catch (error) {
11209	reject(error);
11210	}
11211	});
11212	options?.signal?.addEventListener("abort", () => {
11213	cancel(options?.signal?.reason);
11214	});
11215	const timeout = options?.timeout ?? 6e4;
11216	const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
11217	this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
11218	const relatedTaskId = relatedTask?.taskId;
11219	if (relatedTaskId) {
11220	const responseResolver = (response) => {
11221	const handler = this._responseHandlers.get(messageId);
11222	if (handler) handler(response);
11223	else this._onerror(/* @__PURE__ */ new Error(`Response handler missing for side-channeled request ${messageId}`));
11224	};
11225	this._requestResolvers.set(messageId, responseResolver);
11226	this._enqueueTaskMessage(relatedTaskId, {
11227	type: "request",
11228	message: jsonrpcRequest,
11229	timestamp: Date.now()
11230	}).catch((error) => {
11231	this._cleanupTimeout(messageId);
11232	reject(error);
11233	});
11234	} else this._transport.send(jsonrpcRequest, {
11235	relatedRequestId,
11236	resumptionToken,
11237	onresumptiontoken
11238	}).catch((error) => {
11239	this._cleanupTimeout(messageId);
11240	reject(error);
11241	});
11242	});
11243	}
11244	/**
11245	* Gets the current status of a task.
11246	*
11247	* @experimental Use `client.experimental.tasks.getTask()` to access this method.
11248	*/
11249	async getTask(params, options) {
11250	return this.request({
11251	method: "tasks/get",
11252	params
11253	}, GetTaskResultSchema, options);
11254	}
11255	/**
11256	* Retrieves the result of a completed task.
11257	*
11258	* @experimental Use `client.experimental.tasks.getTaskResult()` to access this method.
11259	*/
11260	async getTaskResult(params, resultSchema, options) {
11261	return this.request({
11262	method: "tasks/result",
11263	params
11264	}, resultSchema, options);
11265	}
11266	/**
11267	* Lists tasks, optionally starting from a pagination cursor.
11268	*
11269	* @experimental Use `client.experimental.tasks.listTasks()` to access this method.
11270	*/
11271	async listTasks(params, options) {
11272	return this.request({
11273	method: "tasks/list",
11274	params
11275	}, ListTasksResultSchema, options);
11276	}
11277	/**
11278	* Cancels a specific task.
11279	*
11280	* @experimental Use `client.experimental.tasks.cancelTask()` to access this method.
11281	*/
11282	async cancelTask(params, options) {
11283	return this.request({
11284	method: "tasks/cancel",
11285	params
11286	}, CancelTaskResultSchema, options);
11287	}
11288	/**
11289	* Emits a notification, which is a one-way message that does not expect a response.
11290	*/
11291	async notification(notification, options) {
11292	if (!this._transport) throw new Error("Not connected");
11293	this.assertNotificationCapability(notification.method);
11294	const relatedTaskId = options?.relatedTask?.taskId;
11295	if (relatedTaskId) {
11296	const jsonrpcNotification = {
11297	...notification,
11298	jsonrpc: "2.0",
11299	params: {
11300	...notification.params,
11301	_meta: {
11302	...notification.params?._meta \|\| {},
11303	[RELATED_TASK_META_KEY]: options.relatedTask
11304	}
11305	}
11306	};
11307	await this._enqueueTaskMessage(relatedTaskId, {
11308	type: "notification",
11309	message: jsonrpcNotification,
11310	timestamp: Date.now()
11311	});
11312	return;
11313	}
11314	if ((this._options?.debouncedNotificationMethods ?? []).includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask) {
11315	if (this._pendingDebouncedNotifications.has(notification.method)) return;
11316	this._pendingDebouncedNotifications.add(notification.method);
11317	Promise.resolve().then(() => {
11318	this._pendingDebouncedNotifications.delete(notification.method);
11319	if (!this._transport) return;
11320	let jsonrpcNotification = {
11321	...notification,
11322	jsonrpc: "2.0"
11323	};
11324	if (options?.relatedTask) jsonrpcNotification = {
11325	...jsonrpcNotification,
11326	params: {
11327	...jsonrpcNotification.params,
11328	_meta: {
11329	...jsonrpcNotification.params?._meta \|\| {},
11330	[RELATED_TASK_META_KEY]: options.relatedTask
11331	}
11332	}
11333	};
11334	this._transport?.send(jsonrpcNotification, options).catch((error) => this._onerror(error));
11335	});
11336	return;
11337	}
11338	let jsonrpcNotification = {
11339	...notification,
11340	jsonrpc: "2.0"
11341	};
11342	if (options?.relatedTask) jsonrpcNotification = {
11343	...jsonrpcNotification,
11344	params: {
11345	...jsonrpcNotification.params,
11346	_meta: {
11347	...jsonrpcNotification.params?._meta \|\| {},
11348	[RELATED_TASK_META_KEY]: options.relatedTask
11349	}
11350	}
11351	};
11352	await this._transport.send(jsonrpcNotification, options);
11353	}
11354	/**
11355	* Registers a handler to invoke when this protocol object receives a request with the given method.
11356	*
11357	* Note that this will replace any previous request handler for the same method.
11358	*/
11359	setRequestHandler(requestSchema, handler) {
11360	const method = getMethodLiteral(requestSchema);
11361	this.assertRequestHandlerCapability(method);
11362	this._requestHandlers.set(method, (request, extra) => {
11363	const parsed = parseWithCompat(requestSchema, request);
11364	return Promise.resolve(handler(parsed, extra));
11365	});
11366	}
11367	/**
11368	* Removes the request handler for the given method.
11369	*/
11370	removeRequestHandler(method) {
11371	this._requestHandlers.delete(method);
11372	}
11373	/**
11374	* Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed.
11375	*/
11376	assertCanSetRequestHandler(method) {
11377	if (this._requestHandlers.has(method)) throw new Error(`A request handler for ${method} already exists, which would be overridden`);
11378	}
11379	/**
11380	* Registers a handler to invoke when this protocol object receives a notification with the given method.
11381	*
11382	* Note that this will replace any previous notification handler for the same method.
11383	*/
11384	setNotificationHandler(notificationSchema, handler) {
11385	const method = getMethodLiteral(notificationSchema);
11386	this._notificationHandlers.set(method, (notification) => {
11387	const parsed = parseWithCompat(notificationSchema, notification);
11388	return Promise.resolve(handler(parsed));
11389	});
11390	}
11391	/**
11392	* Removes the notification handler for the given method.
11393	*/
11394	removeNotificationHandler(method) {
11395	this._notificationHandlers.delete(method);
11396	}
11397	/**
11398	* Cleans up the progress handler associated with a task.
11399	* This should be called when a task reaches a terminal status.
11400	*/
11401	_cleanupTaskProgressHandler(taskId) {
11402	const progressToken = this._taskProgressTokens.get(taskId);
11403	if (progressToken !== void 0) {
11404	this._progressHandlers.delete(progressToken);
11405	this._taskProgressTokens.delete(taskId);
11406	}
11407	}
11408	/**
11409	* Enqueues a task-related message for side-channel delivery via tasks/result.
11410	* @param taskId The task ID to associate the message with
11411	* @param message The message to enqueue
11412	* @param sessionId Optional session ID for binding the operation to a specific session
11413	* @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow)
11414	*
11415	* Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle
11416	* the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
11417	* simply propagates the error.
11418	*/
11419	async _enqueueTaskMessage(taskId, message, sessionId) {
11420	if (!this._taskStore \|\| !this._taskMessageQueue) throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
11421	const maxQueueSize = this._options?.maxTaskQueueSize;
11422	await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
11423	}
11424	/**
11425	* Clears the message queue for a task and rejects any pending request resolvers.
11426	* @param taskId The task ID whose queue should be cleared
11427	* @param sessionId Optional session ID for binding the operation to a specific session
11428	*/
11429	async _clearTaskQueue(taskId, sessionId) {
11430	if (this._taskMessageQueue) {
11431	const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
11432	for (const message of messages) if (message.type === "request" && isJSONRPCRequest(message.message)) {
11433	const requestId = message.message.id;
11434	const resolver = this._requestResolvers.get(requestId);
11435	if (resolver) {
11436	resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
11437	this._requestResolvers.delete(requestId);
11438	} else this._onerror(/* @__PURE__ */ new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
11439	}
11440	}
11441	}
11442	/**
11443	* Waits for a task update (new messages or status change) with abort signal support.
11444	* Uses polling to check for updates at the task's configured poll interval.
11445	* @param taskId The task ID to wait for
11446	* @param signal Abort signal to cancel the wait
11447	* @returns Promise that resolves when an update occurs or rejects if aborted
11448	*/
11449	async _waitForTaskUpdate(taskId, signal) {
11450	let interval = this._options?.defaultTaskPollInterval ?? 1e3;
11451	try {
11452	const task = await this._taskStore?.getTask(taskId);
11453	if (task?.pollInterval) interval = task.pollInterval;
11454	} catch {}
11455	return new Promise((resolve, reject) => {
11456	if (signal.aborted) {
11457	reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
11458	return;
11459	}
11460	const timeoutId = setTimeout(resolve, interval);
11461	signal.addEventListener("abort", () => {
11462	clearTimeout(timeoutId);
11463	reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
11464	}, { once: true });
11465	});
11466	}
11467	requestTaskStore(request, sessionId) {
11468	const taskStore = this._taskStore;
11469	if (!taskStore) throw new Error("No task store configured");
11470	return {
11471	createTask: async (taskParams) => {
11472	if (!request) throw new Error("No request provided");
11473	return await taskStore.createTask(taskParams, request.id, {
11474	method: request.method,
11475	params: request.params
11476	}, sessionId);
11477	},
11478	getTask: async (taskId) => {
11479	const task = await taskStore.getTask(taskId, sessionId);
11480	if (!task) throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
11481	return task;
11482	},
11483	storeTaskResult: async (taskId, status, result) => {
11484	await taskStore.storeTaskResult(taskId, status, result, sessionId);
11485	const task = await taskStore.getTask(taskId, sessionId);
11486	if (task) {
11487	const notification = TaskStatusNotificationSchema.parse({
11488	method: "notifications/tasks/status",
11489	params: task
11490	});
11491	await this.notification(notification);
11492	if (isTerminal(task.status)) this._cleanupTaskProgressHandler(taskId);
11493	}
11494	},
11495	getTaskResult: (taskId) => {
11496	return taskStore.getTaskResult(taskId, sessionId);
11497	},
11498	updateTaskStatus: async (taskId, status, statusMessage) => {
11499	const task = await taskStore.getTask(taskId, sessionId);
11500	if (!task) throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
11501	if (isTerminal(task.status)) throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
11502	await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
11503	const updatedTask = await taskStore.getTask(taskId, sessionId);
11504	if (updatedTask) {
11505	const notification = TaskStatusNotificationSchema.parse({
11506	method: "notifications/tasks/status",
11507	params: updatedTask
11508	});
11509	await this.notification(notification);
11510	if (isTerminal(updatedTask.status)) this._cleanupTaskProgressHandler(taskId);
11511	}
11512	},
11513	listTasks: (cursor) => {
11514	return taskStore.listTasks(cursor, sessionId);
11515	}
11516	};
11517	}
11518	};
11519	function isPlainObject(value) {
11520	return value !== null && typeof value === "object" && !Array.isArray(value);
11521	}
11522	function mergeCapabilities(base, additional) {
11523	const result = { ...base };
11524	for (const key in additional) {
11525	const k = key;
11526	const addValue = additional[k];
11527	if (addValue === void 0) continue;
11528	const baseValue = result[k];
11529	if (isPlainObject(baseValue) && isPlainObject(addValue)) result[k] = {
11530	...baseValue,
11531	...addValue
11532	};
11533	else result[k] = addValue;
11534	}
11535	return result;
11536	}
11537
11538	//#endregion
11539	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/codegen/code.js
11540	var require_code$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
11541	Object.defineProperty(exports, "__esModule", { value: true });
11542	exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
11543	var _CodeOrName = class {};
11544	exports._CodeOrName = _CodeOrName;
11545	exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
11546	var Name = class extends _CodeOrName {
11547	constructor(s) {
11548	super();
11549	if (!exports.IDENTIFIER.test(s)) throw new Error("CodeGen: name must be a valid identifier");
11550	this.str = s;
11551	}
11552	toString() {
11553	return this.str;
11554	}
11555	emptyStr() {
11556	return false;
11557	}
11558	get names() {
11559	return { [this.str]: 1 };
11560	}
11561	};
11562	exports.Name = Name;
11563	var _Code = class extends _CodeOrName {
11564	constructor(code) {
11565	super();
11566	this._items = typeof code === "string" ? [code] : code;
11567	}
11568	toString() {
11569	return this.str;
11570	}
11571	emptyStr() {
11572	if (this._items.length > 1) return false;
11573	const item = this._items[0];
11574	return item === "" \|\| item === "\"\"";
11575	}
11576	get str() {
11577	var _a;
11578	return (_a = this._str) !== null && _a !== void 0 ? _a : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
11579	}
11580	get names() {
11581	var _a;
11582	return (_a = this._names) !== null && _a !== void 0 ? _a : this._names = this._items.reduce((names, c) => {
11583	if (c instanceof Name) names[c.str] = (names[c.str] \|\| 0) + 1;
11584	return names;
11585	}, {});
11586	}
11587	};
11588	exports._Code = _Code;
11589	exports.nil = new _Code("");
11590	function _(strs, ...args) {
11591	const code = [strs[0]];
11592	let i = 0;
11593	while (i < args.length) {
11594	addCodeArg(code, args[i]);
11595	code.push(strs[++i]);
11596	}
11597	return new _Code(code);
11598	}
11599	exports._ = _;
11600	var plus = new _Code("+");
11601	function str(strs, ...args) {
11602	const expr = [safeStringify(strs[0])];
11603	let i = 0;
11604	while (i < args.length) {
11605	expr.push(plus);
11606	addCodeArg(expr, args[i]);
11607	expr.push(plus, safeStringify(strs[++i]));
11608	}
11609	optimize(expr);
11610	return new _Code(expr);
11611	}
11612	exports.str = str;
11613	function addCodeArg(code, arg) {
11614	if (arg instanceof _Code) code.push(...arg._items);
11615	else if (arg instanceof Name) code.push(arg);
11616	else code.push(interpolate(arg));
11617	}
11618	exports.addCodeArg = addCodeArg;
11619	function optimize(expr) {
11620	let i = 1;
11621	while (i < expr.length - 1) {
11622	if (expr[i] === plus) {
11623	const res = mergeExprItems(expr[i - 1], expr[i + 1]);
11624	if (res !== void 0) {
11625	expr.splice(i - 1, 3, res);
11626	continue;
11627	}
11628	expr[i++] = "+";
11629	}
11630	i++;
11631	}
11632	}
11633	function mergeExprItems(a, b) {
11634	if (b === "\"\"") return a;
11635	if (a === "\"\"") return b;
11636	if (typeof a == "string") {
11637	if (b instanceof Name \|\| a[a.length - 1] !== "\"") return;
11638	if (typeof b != "string") return `${a.slice(0, -1)}${b}"`;
11639	if (b[0] === "\"") return a.slice(0, -1) + b.slice(1);
11640	return;
11641	}
11642	if (typeof b == "string" && b[0] === "\"" && !(a instanceof Name)) return `"${a}${b.slice(1)}`;
11643	}
11644	function strConcat(c1, c2) {
11645	return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
11646	}
11647	exports.strConcat = strConcat;
11648	function interpolate(x) {
11649	return typeof x == "number" \|\| typeof x == "boolean" \|\| x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
11650	}
11651	function stringify(x) {
11652	return new _Code(safeStringify(x));
11653	}
11654	exports.stringify = stringify;
11655	function safeStringify(x) {
11656	return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
11657	}
11658	exports.safeStringify = safeStringify;
11659	function getProperty(key) {
11660	return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
11661	}
11662	exports.getProperty = getProperty;
11663	function getEsmExportName(key) {
11664	if (typeof key == "string" && exports.IDENTIFIER.test(key)) return new _Code(`${key}`);
11665	throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
11666	}
11667	exports.getEsmExportName = getEsmExportName;
11668	function regexpCode(rx) {
11669	return new _Code(rx.toString());
11670	}
11671	exports.regexpCode = regexpCode;
11672	}));
11673
11674	//#endregion
11675	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/codegen/scope.js
11676	var require_scope = /* @__PURE__ */ __commonJSMin(((exports) => {
11677	Object.defineProperty(exports, "__esModule", { value: true });
11678	exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
11679	var code_1 = require_code$1();
11680	var ValueError = class extends Error {
11681	constructor(name) {
11682	super(`CodeGen: "code" for ${name} not defined`);
11683	this.value = name.value;
11684	}
11685	};
11686	var UsedValueState;
11687	(function(UsedValueState) {
11688	UsedValueState[UsedValueState["Started"] = 0] = "Started";
11689	UsedValueState[UsedValueState["Completed"] = 1] = "Completed";
11690	})(UsedValueState \|\| (exports.UsedValueState = UsedValueState = {}));
11691	exports.varKinds = {
11692	const: new code_1.Name("const"),
11693	let: new code_1.Name("let"),
11694	var: new code_1.Name("var")
11695	};
11696	var Scope = class {
11697	constructor({ prefixes, parent } = {}) {
11698	this._names = {};
11699	this._prefixes = prefixes;
11700	this._parent = parent;
11701	}
11702	toName(nameOrPrefix) {
11703	return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
11704	}
11705	name(prefix) {
11706	return new code_1.Name(this._newName(prefix));
11707	}
11708	_newName(prefix) {
11709	const ng = this._names[prefix] \|\| this._nameGroup(prefix);
11710	return `${prefix}${ng.index++}`;
11711	}
11712	_nameGroup(prefix) {
11713	var _a;
11714	var _b;
11715	if (((_b = (_a = this._parent) === null \|\| _a === void 0 ? void 0 : _a._prefixes) === null \|\| _b === void 0 ? void 0 : _b.has(prefix)) \|\| this._prefixes && !this._prefixes.has(prefix)) throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
11716	return this._names[prefix] = {
11717	prefix,
11718	index: 0
11719	};
11720	}
11721	};
11722	exports.Scope = Scope;
11723	var ValueScopeName = class extends code_1.Name {
11724	constructor(prefix, nameStr) {
11725	super(nameStr);
11726	this.prefix = prefix;
11727	}
11728	setValue(value, { property, itemIndex }) {
11729	this.value = value;
11730	this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
11731	}
11732	};
11733	exports.ValueScopeName = ValueScopeName;
11734	var line = (0, code_1._)`\n`;
11735	var ValueScope = class extends Scope {
11736	constructor(opts) {
11737	super(opts);
11738	this._values = {};
11739	this._scope = opts.scope;
11740	this.opts = {
11741	...opts,
11742	_n: opts.lines ? line : code_1.nil
11743	};
11744	}
11745	get() {
11746	return this._scope;
11747	}
11748	name(prefix) {
11749	return new ValueScopeName(prefix, this._newName(prefix));
11750	}
11751	value(nameOrPrefix, value) {
11752	var _a;
11753	if (value.ref === void 0) throw new Error("CodeGen: ref must be passed in value");
11754	const name = this.toName(nameOrPrefix);
11755	const { prefix } = name;
11756	const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
11757	let vs = this._values[prefix];
11758	if (vs) {
11759	const _name = vs.get(valueKey);
11760	if (_name) return _name;
11761	} else vs = this._values[prefix] = /* @__PURE__ */ new Map();
11762	vs.set(valueKey, name);
11763	const s = this._scope[prefix] \|\| (this._scope[prefix] = []);
11764	const itemIndex = s.length;
11765	s[itemIndex] = value.ref;
11766	name.setValue(value, {
11767	property: prefix,
11768	itemIndex
11769	});
11770	return name;
11771	}
11772	getValue(prefix, keyOrRef) {
11773	const vs = this._values[prefix];
11774	if (!vs) return;
11775	return vs.get(keyOrRef);
11776	}
11777	scopeRefs(scopeName, values = this._values) {
11778	return this._reduceValues(values, (name) => {
11779	if (name.scopePath === void 0) throw new Error(`CodeGen: name "${name}" has no value`);
11780	return (0, code_1._)`${scopeName}${name.scopePath}`;
11781	});
11782	}
11783	scopeCode(values = this._values, usedValues, getCode) {
11784	return this._reduceValues(values, (name) => {
11785	if (name.value === void 0) throw new Error(`CodeGen: name "${name}" has no value`);
11786	return name.value.code;
11787	}, usedValues, getCode);
11788	}
11789	_reduceValues(values, valueCode, usedValues = {}, getCode) {
11790	let code = code_1.nil;
11791	for (const prefix in values) {
11792	const vs = values[prefix];
11793	if (!vs) continue;
11794	const nameSet = usedValues[prefix] = usedValues[prefix] \|\| /* @__PURE__ */ new Map();
11795	vs.forEach((name) => {
11796	if (nameSet.has(name)) return;
11797	nameSet.set(name, UsedValueState.Started);
11798	let c = valueCode(name);
11799	if (c) {
11800	const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;
11801	code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
11802	} else if (c = getCode === null \|\| getCode === void 0 ? void 0 : getCode(name)) code = (0, code_1._)`${code}${c}${this.opts._n}`;
11803	else throw new ValueError(name);
11804	nameSet.set(name, UsedValueState.Completed);
11805	});
11806	}
11807	return code;
11808	}
11809	};
11810	exports.ValueScope = ValueScope;
11811	}));
11812
11813	//#endregion
11814	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/codegen/index.js
11815	var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
11816	Object.defineProperty(exports, "__esModule", { value: true });
11817	exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0;
11818	var code_1 = require_code$1();
11819	var scope_1 = require_scope();
11820	var code_2 = require_code$1();
11821	Object.defineProperty(exports, "_", {
11822	enumerable: true,
11823	get: function() {
11824	return code_2._;
11825	}
11826	});
11827	Object.defineProperty(exports, "str", {
11828	enumerable: true,
11829	get: function() {
11830	return code_2.str;
11831	}
11832	});
11833	Object.defineProperty(exports, "strConcat", {
11834	enumerable: true,
11835	get: function() {
11836	return code_2.strConcat;
11837	}
11838	});
11839	Object.defineProperty(exports, "nil", {
11840	enumerable: true,
11841	get: function() {
11842	return code_2.nil;
11843	}
11844	});
11845	Object.defineProperty(exports, "getProperty", {
11846	enumerable: true,
11847	get: function() {
11848	return code_2.getProperty;
11849	}
11850	});
11851	Object.defineProperty(exports, "stringify", {
11852	enumerable: true,
11853	get: function() {
11854	return code_2.stringify;
11855	}
11856	});
11857	Object.defineProperty(exports, "regexpCode", {
11858	enumerable: true,
11859	get: function() {
11860	return code_2.regexpCode;
11861	}
11862	});
11863	Object.defineProperty(exports, "Name", {
11864	enumerable: true,
11865	get: function() {
11866	return code_2.Name;
11867	}
11868	});
11869	var scope_2 = require_scope();
11870	Object.defineProperty(exports, "Scope", {
11871	enumerable: true,
11872	get: function() {
11873	return scope_2.Scope;
11874	}
11875	});
11876	Object.defineProperty(exports, "ValueScope", {
11877	enumerable: true,
11878	get: function() {
11879	return scope_2.ValueScope;
11880	}
11881	});
11882	Object.defineProperty(exports, "ValueScopeName", {
11883	enumerable: true,
11884	get: function() {
11885	return scope_2.ValueScopeName;
11886	}
11887	});
11888	Object.defineProperty(exports, "varKinds", {
11889	enumerable: true,
11890	get: function() {
11891	return scope_2.varKinds;
11892	}
11893	});
11894	exports.operators = {
11895	GT: new code_1._Code(">"),
11896	GTE: new code_1._Code(">="),
11897	LT: new code_1._Code("<"),
11898	LTE: new code_1._Code("<="),
11899	EQ: new code_1._Code("==="),
11900	NEQ: new code_1._Code("!=="),
11901	NOT: new code_1._Code("!"),
11902	OR: new code_1._Code("\|\|"),
11903	AND: new code_1._Code("&&"),
11904	ADD: new code_1._Code("+")
11905	};
11906	var Node = class {
11907	optimizeNodes() {
11908	return this;
11909	}
11910	optimizeNames(_names, _constants) {
11911	return this;
11912	}
11913	};
11914	var Def = class extends Node {
11915	constructor(varKind, name, rhs) {
11916	super();
11917	this.varKind = varKind;
11918	this.name = name;
11919	this.rhs = rhs;
11920	}
11921	render({ es5, _n }) {
11922	const varKind = es5 ? scope_1.varKinds.var : this.varKind;
11923	const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
11924	return `${varKind} ${this.name}${rhs};` + _n;
11925	}
11926	optimizeNames(names, constants) {
11927	if (!names[this.name.str]) return;
11928	if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants);
11929	return this;
11930	}
11931	get names() {
11932	return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
11933	}
11934	};
11935	var Assign = class extends Node {
11936	constructor(lhs, rhs, sideEffects) {
11937	super();
11938	this.lhs = lhs;
11939	this.rhs = rhs;
11940	this.sideEffects = sideEffects;
11941	}
11942	render({ _n }) {
11943	return `${this.lhs} = ${this.rhs};` + _n;
11944	}
11945	optimizeNames(names, constants) {
11946	if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) return;
11947	this.rhs = optimizeExpr(this.rhs, names, constants);
11948	return this;
11949	}
11950	get names() {
11951	return addExprNames(this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names }, this.rhs);
11952	}
11953	};
11954	var AssignOp = class extends Assign {
11955	constructor(lhs, op, rhs, sideEffects) {
11956	super(lhs, rhs, sideEffects);
11957	this.op = op;
11958	}
11959	render({ _n }) {
11960	return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
11961	}
11962	};
11963	var Label = class extends Node {
11964	constructor(label) {
11965	super();
11966	this.label = label;
11967	this.names = {};
11968	}
11969	render({ _n }) {
11970	return `${this.label}:` + _n;
11971	}
11972	};
11973	var Break = class extends Node {
11974	constructor(label) {
11975	super();
11976	this.label = label;
11977	this.names = {};
11978	}
11979	render({ _n }) {
11980	return `break${this.label ? ` ${this.label}` : ""};` + _n;
11981	}
11982	};
11983	var Throw = class extends Node {
11984	constructor(error) {
11985	super();
11986	this.error = error;
11987	}
11988	render({ _n }) {
11989	return `throw ${this.error};` + _n;
11990	}
11991	get names() {
11992	return this.error.names;
11993	}
11994	};
11995	var AnyCode = class extends Node {
11996	constructor(code) {
11997	super();
11998	this.code = code;
11999	}
12000	render({ _n }) {
12001	return `${this.code};` + _n;
12002	}
12003	optimizeNodes() {
12004	return `${this.code}` ? this : void 0;
12005	}
12006	optimizeNames(names, constants) {
12007	this.code = optimizeExpr(this.code, names, constants);
12008	return this;
12009	}
12010	get names() {
12011	return this.code instanceof code_1._CodeOrName ? this.code.names : {};
12012	}
12013	};
12014	var ParentNode = class extends Node {
12015	constructor(nodes = []) {
12016	super();
12017	this.nodes = nodes;
12018	}
12019	render(opts) {
12020	return this.nodes.reduce((code, n) => code + n.render(opts), "");
12021	}
12022	optimizeNodes() {
12023	const { nodes } = this;
12024	let i = nodes.length;
12025	while (i--) {
12026	const n = nodes[i].optimizeNodes();
12027	if (Array.isArray(n)) nodes.splice(i, 1, ...n);
12028	else if (n) nodes[i] = n;
12029	else nodes.splice(i, 1);
12030	}
12031	return nodes.length > 0 ? this : void 0;
12032	}
12033	optimizeNames(names, constants) {
12034	const { nodes } = this;
12035	let i = nodes.length;
12036	while (i--) {
12037	const n = nodes[i];
12038	if (n.optimizeNames(names, constants)) continue;
12039	subtractNames(names, n.names);
12040	nodes.splice(i, 1);
12041	}
12042	return nodes.length > 0 ? this : void 0;
12043	}
12044	get names() {
12045	return this.nodes.reduce((names, n) => addNames(names, n.names), {});
12046	}
12047	};
12048	var BlockNode = class extends ParentNode {
12049	render(opts) {
12050	return "{" + opts._n + super.render(opts) + "}" + opts._n;
12051	}
12052	};
12053	var Root = class extends ParentNode {};
12054	var Else = class extends BlockNode {};
12055	Else.kind = "else";
12056	var If = class If extends BlockNode {
12057	constructor(condition, nodes) {
12058	super(nodes);
12059	this.condition = condition;
12060	}
12061	render(opts) {
12062	let code = `if(${this.condition})` + super.render(opts);
12063	if (this.else) code += "else " + this.else.render(opts);
12064	return code;
12065	}
12066	optimizeNodes() {
12067	super.optimizeNodes();
12068	const cond = this.condition;
12069	if (cond === true) return this.nodes;
12070	let e = this.else;
12071	if (e) {
12072	const ns = e.optimizeNodes();
12073	e = this.else = Array.isArray(ns) ? new Else(ns) : ns;
12074	}
12075	if (e) {
12076	if (cond === false) return e instanceof If ? e : e.nodes;
12077	if (this.nodes.length) return this;
12078	return new If(not(cond), e instanceof If ? [e] : e.nodes);
12079	}
12080	if (cond === false \|\| !this.nodes.length) return void 0;
12081	return this;
12082	}
12083	optimizeNames(names, constants) {
12084	var _a;
12085	this.else = (_a = this.else) === null \|\| _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
12086	if (!(super.optimizeNames(names, constants) \|\| this.else)) return;
12087	this.condition = optimizeExpr(this.condition, names, constants);
12088	return this;
12089	}
12090	get names() {
12091	const names = super.names;
12092	addExprNames(names, this.condition);
12093	if (this.else) addNames(names, this.else.names);
12094	return names;
12095	}
12096	};
12097	If.kind = "if";
12098	var For = class extends BlockNode {};
12099	For.kind = "for";
12100	var ForLoop = class extends For {
12101	constructor(iteration) {
12102	super();
12103	this.iteration = iteration;
12104	}
12105	render(opts) {
12106	return `for(${this.iteration})` + super.render(opts);
12107	}
12108	optimizeNames(names, constants) {
12109	if (!super.optimizeNames(names, constants)) return;
12110	this.iteration = optimizeExpr(this.iteration, names, constants);
12111	return this;
12112	}
12113	get names() {
12114	return addNames(super.names, this.iteration.names);
12115	}
12116	};
12117	var ForRange = class extends For {
12118	constructor(varKind, name, from, to) {
12119	super();
12120	this.varKind = varKind;
12121	this.name = name;
12122	this.from = from;
12123	this.to = to;
12124	}
12125	render(opts) {
12126	const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind;
12127	const { name, from, to } = this;
12128	return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts);
12129	}
12130	get names() {
12131	return addExprNames(addExprNames(super.names, this.from), this.to);
12132	}
12133	};
12134	var ForIter = class extends For {
12135	constructor(loop, varKind, name, iterable) {
12136	super();
12137	this.loop = loop;
12138	this.varKind = varKind;
12139	this.name = name;
12140	this.iterable = iterable;
12141	}
12142	render(opts) {
12143	return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
12144	}
12145	optimizeNames(names, constants) {
12146	if (!super.optimizeNames(names, constants)) return;
12147	this.iterable = optimizeExpr(this.iterable, names, constants);
12148	return this;
12149	}
12150	get names() {
12151	return addNames(super.names, this.iterable.names);
12152	}
12153	};
12154	var Func = class extends BlockNode {
12155	constructor(name, args, async) {
12156	super();
12157	this.name = name;
12158	this.args = args;
12159	this.async = async;
12160	}
12161	render(opts) {
12162	return `${this.async ? "async " : ""}function ${this.name}(${this.args})` + super.render(opts);
12163	}
12164	};
12165	Func.kind = "func";
12166	var Return = class extends ParentNode {
12167	render(opts) {
12168	return "return " + super.render(opts);
12169	}
12170	};
12171	Return.kind = "return";
12172	var Try = class extends BlockNode {
12173	render(opts) {
12174	let code = "try" + super.render(opts);
12175	if (this.catch) code += this.catch.render(opts);
12176	if (this.finally) code += this.finally.render(opts);
12177	return code;
12178	}
12179	optimizeNodes() {
12180	var _a;
12181	var _b;
12182	super.optimizeNodes();
12183	(_a = this.catch) === null \|\| _a === void 0 \|\| _a.optimizeNodes();
12184	(_b = this.finally) === null \|\| _b === void 0 \|\| _b.optimizeNodes();
12185	return this;
12186	}
12187	optimizeNames(names, constants) {
12188	var _a;
12189	var _b;
12190	super.optimizeNames(names, constants);
12191	(_a = this.catch) === null \|\| _a === void 0 \|\| _a.optimizeNames(names, constants);
12192	(_b = this.finally) === null \|\| _b === void 0 \|\| _b.optimizeNames(names, constants);
12193	return this;
12194	}
12195	get names() {
12196	const names = super.names;
12197	if (this.catch) addNames(names, this.catch.names);
12198	if (this.finally) addNames(names, this.finally.names);
12199	return names;
12200	}
12201	};
12202	var Catch = class extends BlockNode {
12203	constructor(error) {
12204	super();
12205	this.error = error;
12206	}
12207	render(opts) {
12208	return `catch(${this.error})` + super.render(opts);
12209	}
12210	};
12211	Catch.kind = "catch";
12212	var Finally = class extends BlockNode {
12213	render(opts) {
12214	return "finally" + super.render(opts);
12215	}
12216	};
12217	Finally.kind = "finally";
12218	var CodeGen = class {
12219	constructor(extScope, opts = {}) {
12220	this._values = {};
12221	this._blockStarts = [];
12222	this._constants = {};
12223	this.opts = {
12224	...opts,
12225	_n: opts.lines ? "\n" : ""
12226	};
12227	this._extScope = extScope;
12228	this._scope = new scope_1.Scope({ parent: extScope });
12229	this._nodes = [new Root()];
12230	}
12231	toString() {
12232	return this._root.render(this.opts);
12233	}
12234	name(prefix) {
12235	return this._scope.name(prefix);
12236	}
12237	scopeName(prefix) {
12238	return this._extScope.name(prefix);
12239	}
12240	scopeValue(prefixOrName, value) {
12241	const name = this._extScope.value(prefixOrName, value);
12242	(this._values[name.prefix] \|\| (this._values[name.prefix] = /* @__PURE__ */ new Set())).add(name);
12243	return name;
12244	}
12245	getScopeValue(prefix, keyOrRef) {
12246	return this._extScope.getValue(prefix, keyOrRef);
12247	}
12248	scopeRefs(scopeName) {
12249	return this._extScope.scopeRefs(scopeName, this._values);
12250	}
12251	scopeCode() {
12252	return this._extScope.scopeCode(this._values);
12253	}
12254	_def(varKind, nameOrPrefix, rhs, constant) {
12255	const name = this._scope.toName(nameOrPrefix);
12256	if (rhs !== void 0 && constant) this._constants[name.str] = rhs;
12257	this._leafNode(new Def(varKind, name, rhs));
12258	return name;
12259	}
12260	const(nameOrPrefix, rhs, _constant) {
12261	return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
12262	}
12263	let(nameOrPrefix, rhs, _constant) {
12264	return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
12265	}
12266	var(nameOrPrefix, rhs, _constant) {
12267	return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
12268	}
12269	assign(lhs, rhs, sideEffects) {
12270	return this._leafNode(new Assign(lhs, rhs, sideEffects));
12271	}
12272	add(lhs, rhs) {
12273	return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
12274	}
12275	code(c) {
12276	if (typeof c == "function") c();
12277	else if (c !== code_1.nil) this._leafNode(new AnyCode(c));
12278	return this;
12279	}
12280	object(...keyValues) {
12281	const code = ["{"];
12282	for (const [key, value] of keyValues) {
12283	if (code.length > 1) code.push(",");
12284	code.push(key);
12285	if (key !== value \|\| this.opts.es5) {
12286	code.push(":");
12287	(0, code_1.addCodeArg)(code, value);
12288	}
12289	}
12290	code.push("}");
12291	return new code_1._Code(code);
12292	}
12293	if(condition, thenBody, elseBody) {
12294	this._blockNode(new If(condition));
12295	if (thenBody && elseBody) this.code(thenBody).else().code(elseBody).endIf();
12296	else if (thenBody) this.code(thenBody).endIf();
12297	else if (elseBody) throw new Error("CodeGen: \"else\" body without \"then\" body");
12298	return this;
12299	}
12300	elseIf(condition) {
12301	return this._elseNode(new If(condition));
12302	}
12303	else() {
12304	return this._elseNode(new Else());
12305	}
12306	endIf() {
12307	return this._endBlockNode(If, Else);
12308	}
12309	_for(node, forBody) {
12310	this._blockNode(node);
12311	if (forBody) this.code(forBody).endFor();
12312	return this;
12313	}
12314	for(iteration, forBody) {
12315	return this._for(new ForLoop(iteration), forBody);
12316	}
12317	forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) {
12318	const name = this._scope.toName(nameOrPrefix);
12319	return this._for(new ForRange(varKind, name, from, to), () => forBody(name));
12320	}
12321	forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
12322	const name = this._scope.toName(nameOrPrefix);
12323	if (this.opts.es5) {
12324	const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable);
12325	return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i) => {
12326	this.var(name, (0, code_1._)`${arr}[${i}]`);
12327	forBody(name);
12328	});
12329	}
12330	return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name));
12331	}
12332	forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) {
12333	if (this.opts.ownProperties) return this.forOf(nameOrPrefix, (0, code_1._)`Object.keys(${obj})`, forBody);
12334	const name = this._scope.toName(nameOrPrefix);
12335	return this._for(new ForIter("in", varKind, name, obj), () => forBody(name));
12336	}
12337	endFor() {
12338	return this._endBlockNode(For);
12339	}
12340	label(label) {
12341	return this._leafNode(new Label(label));
12342	}
12343	break(label) {
12344	return this._leafNode(new Break(label));
12345	}
12346	return(value) {
12347	const node = new Return();
12348	this._blockNode(node);
12349	this.code(value);
12350	if (node.nodes.length !== 1) throw new Error("CodeGen: \"return\" should have one node");
12351	return this._endBlockNode(Return);
12352	}
12353	try(tryBody, catchCode, finallyCode) {
12354	if (!catchCode && !finallyCode) throw new Error("CodeGen: \"try\" without \"catch\" and \"finally\"");
12355	const node = new Try();
12356	this._blockNode(node);
12357	this.code(tryBody);
12358	if (catchCode) {
12359	const error = this.name("e");
12360	this._currNode = node.catch = new Catch(error);
12361	catchCode(error);
12362	}
12363	if (finallyCode) {
12364	this._currNode = node.finally = new Finally();
12365	this.code(finallyCode);
12366	}
12367	return this._endBlockNode(Catch, Finally);
12368	}
12369	throw(error) {
12370	return this._leafNode(new Throw(error));
12371	}
12372	block(body, nodeCount) {
12373	this._blockStarts.push(this._nodes.length);
12374	if (body) this.code(body).endBlock(nodeCount);
12375	return this;
12376	}
12377	endBlock(nodeCount) {
12378	const len = this._blockStarts.pop();
12379	if (len === void 0) throw new Error("CodeGen: not in self-balancing block");
12380	const toClose = this._nodes.length - len;
12381	if (toClose < 0 \|\| nodeCount !== void 0 && toClose !== nodeCount) throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
12382	this._nodes.length = len;
12383	return this;
12384	}
12385	func(name, args = code_1.nil, async, funcBody) {
12386	this._blockNode(new Func(name, args, async));
12387	if (funcBody) this.code(funcBody).endFunc();
12388	return this;
12389	}
12390	endFunc() {
12391	return this._endBlockNode(Func);
12392	}
12393	optimize(n = 1) {
12394	while (n-- > 0) {
12395	this._root.optimizeNodes();
12396	this._root.optimizeNames(this._root.names, this._constants);
12397	}
12398	}
12399	_leafNode(node) {
12400	this._currNode.nodes.push(node);
12401	return this;
12402	}
12403	_blockNode(node) {
12404	this._currNode.nodes.push(node);
12405	this._nodes.push(node);
12406	}
12407	_endBlockNode(N1, N2) {
12408	const n = this._currNode;
12409	if (n instanceof N1 \|\| N2 && n instanceof N2) {
12410	this._nodes.pop();
12411	return this;
12412	}
12413	throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`);
12414	}
12415	_elseNode(node) {
12416	const n = this._currNode;
12417	if (!(n instanceof If)) throw new Error("CodeGen: \"else\" without \"if\"");
12418	this._currNode = n.else = node;
12419	return this;
12420	}
12421	get _root() {
12422	return this._nodes[0];
12423	}
12424	get _currNode() {
12425	const ns = this._nodes;
12426	return ns[ns.length - 1];
12427	}
12428	set _currNode(node) {
12429	const ns = this._nodes;
12430	ns[ns.length - 1] = node;
12431	}
12432	};
12433	exports.CodeGen = CodeGen;
12434	function addNames(names, from) {
12435	for (const n in from) names[n] = (names[n] \|\| 0) + (from[n] \|\| 0);
12436	return names;
12437	}
12438	function addExprNames(names, from) {
12439	return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
12440	}
12441	function optimizeExpr(expr, names, constants) {
12442	if (expr instanceof code_1.Name) return replaceName(expr);
12443	if (!canOptimize(expr)) return expr;
12444	return new code_1._Code(expr._items.reduce((items, c) => {
12445	if (c instanceof code_1.Name) c = replaceName(c);
12446	if (c instanceof code_1._Code) items.push(...c._items);
12447	else items.push(c);
12448	return items;
12449	}, []));
12450	function replaceName(n) {
12451	const c = constants[n.str];
12452	if (c === void 0 \|\| names[n.str] !== 1) return n;
12453	delete names[n.str];
12454	return c;
12455	}
12456	function canOptimize(e) {
12457	return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== void 0);
12458	}
12459	}
12460	function subtractNames(names, from) {
12461	for (const n in from) names[n] = (names[n] \|\| 0) - (from[n] \|\| 0);
12462	}
12463	function not(x) {
12464	return typeof x == "boolean" \|\| typeof x == "number" \|\| x === null ? !x : (0, code_1._)`!${par(x)}`;
12465	}
12466	exports.not = not;
12467	var andCode = mappend(exports.operators.AND);
12468	function and(...args) {
12469	return args.reduce(andCode);
12470	}
12471	exports.and = and;
12472	var orCode = mappend(exports.operators.OR);
12473	function or(...args) {
12474	return args.reduce(orCode);
12475	}
12476	exports.or = or;
12477	function mappend(op) {
12478	return (x, y) => x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._)`${par(x)} ${op} ${par(y)}`;
12479	}
12480	function par(x) {
12481	return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`;
12482	}
12483	}));
12484
12485	//#endregion
12486	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/util.js
12487	var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
12488	Object.defineProperty(exports, "__esModule", { value: true });
12489	exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0;
12490	var codegen_1 = require_codegen();
12491	var code_1 = require_code$1();
12492	function toHash(arr) {
12493	const hash = {};
12494	for (const item of arr) hash[item] = true;
12495	return hash;
12496	}
12497	exports.toHash = toHash;
12498	function alwaysValidSchema(it, schema) {
12499	if (typeof schema == "boolean") return schema;
12500	if (Object.keys(schema).length === 0) return true;
12501	checkUnknownRules(it, schema);
12502	return !schemaHasRules(schema, it.self.RULES.all);
12503	}
12504	exports.alwaysValidSchema = alwaysValidSchema;
12505	function checkUnknownRules(it, schema = it.schema) {
12506	const { opts, self } = it;
12507	if (!opts.strictSchema) return;
12508	if (typeof schema === "boolean") return;
12509	const rules = self.RULES.keywords;
12510	for (const key in schema) if (!rules[key]) checkStrictMode(it, `unknown keyword: "${key}"`);
12511	}
12512	exports.checkUnknownRules = checkUnknownRules;
12513	function schemaHasRules(schema, rules) {
12514	if (typeof schema == "boolean") return !schema;
12515	for (const key in schema) if (rules[key]) return true;
12516	return false;
12517	}
12518	exports.schemaHasRules = schemaHasRules;
12519	function schemaHasRulesButRef(schema, RULES) {
12520	if (typeof schema == "boolean") return !schema;
12521	for (const key in schema) if (key !== "$ref" && RULES.all[key]) return true;
12522	return false;
12523	}
12524	exports.schemaHasRulesButRef = schemaHasRulesButRef;
12525	function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
12526	if (!$data) {
12527	if (typeof schema == "number" \|\| typeof schema == "boolean") return schema;
12528	if (typeof schema == "string") return (0, codegen_1._)`${schema}`;
12529	}
12530	return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
12531	}
12532	exports.schemaRefOrVal = schemaRefOrVal;
12533	function unescapeFragment(str) {
12534	return unescapeJsonPointer(decodeURIComponent(str));
12535	}
12536	exports.unescapeFragment = unescapeFragment;
12537	function escapeFragment(str) {
12538	return encodeURIComponent(escapeJsonPointer(str));
12539	}
12540	exports.escapeFragment = escapeFragment;
12541	function escapeJsonPointer(str) {
12542	if (typeof str == "number") return `${str}`;
12543	return str.replace(/~/g, "~0").replace(/\//g, "~1");
12544	}
12545	exports.escapeJsonPointer = escapeJsonPointer;
12546	function unescapeJsonPointer(str) {
12547	return str.replace(/~1/g, "/").replace(/~0/g, "~");
12548	}
12549	exports.unescapeJsonPointer = unescapeJsonPointer;
12550	function eachItem(xs, f) {
12551	if (Array.isArray(xs)) for (const x of xs) f(x);
12552	else f(xs);
12553	}
12554	exports.eachItem = eachItem;
12555	function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues, resultToName }) {
12556	return (gen, from, to, toName) => {
12557	const res = to === void 0 ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues(from, to);
12558	return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
12559	};
12560	}
12561	exports.mergeEvaluated = {
12562	props: makeMergeEvaluated({
12563	mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => {
12564	gen.if((0, codegen_1._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._)`${to} \|\| {}`).code((0, codegen_1._)`Object.assign(${to}, ${from})`));
12565	}),
12566	mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => {
12567	if (from === true) gen.assign(to, true);
12568	else {
12569	gen.assign(to, (0, codegen_1._)`${to} \|\| {}`);
12570	setEvaluated(gen, to, from);
12571	}
12572	}),
12573	mergeValues: (from, to) => from === true ? true : {
12574	...from,
12575	...to
12576	},
12577	resultToName: evaluatedPropsToName
12578	}),
12579	items: makeMergeEvaluated({
12580	mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
12581	mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`)),
12582	mergeValues: (from, to) => from === true ? true : Math.max(from, to),
12583	resultToName: (gen, items) => gen.var("items", items)
12584	})
12585	};
12586	function evaluatedPropsToName(gen, ps) {
12587	if (ps === true) return gen.var("props", true);
12588	const props = gen.var("props", (0, codegen_1._)`{}`);
12589	if (ps !== void 0) setEvaluated(gen, props, ps);
12590	return props;
12591	}
12592	exports.evaluatedPropsToName = evaluatedPropsToName;
12593	function setEvaluated(gen, props, ps) {
12594	Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true));
12595	}
12596	exports.setEvaluated = setEvaluated;
12597	var snippets = {};
12598	function useFunc(gen, f) {
12599	return gen.scopeValue("func", {
12600	ref: f,
12601	code: snippets[f.code] \|\| (snippets[f.code] = new code_1._Code(f.code))
12602	});
12603	}
12604	exports.useFunc = useFunc;
12605	var Type;
12606	(function(Type) {
12607	Type[Type["Num"] = 0] = "Num";
12608	Type[Type["Str"] = 1] = "Str";
12609	})(Type \|\| (exports.Type = Type = {}));
12610	function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
12611	if (dataProp instanceof codegen_1.Name) {
12612	const isNumber = dataPropType === Type.Num;
12613	return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
12614	}
12615	return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
12616	}
12617	exports.getErrorPath = getErrorPath;
12618	function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
12619	if (!mode) return;
12620	msg = `strict mode: ${msg}`;
12621	if (mode === true) throw new Error(msg);
12622	it.self.logger.warn(msg);
12623	}
12624	exports.checkStrictMode = checkStrictMode;
12625	}));
12626
12627	//#endregion
12628	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/names.js
12629	var require_names = /* @__PURE__ */ __commonJSMin(((exports) => {
12630	Object.defineProperty(exports, "__esModule", { value: true });
12631	var codegen_1 = require_codegen();
12632	var names = {
12633	data: new codegen_1.Name("data"),
12634	valCxt: new codegen_1.Name("valCxt"),
12635	instancePath: new codegen_1.Name("instancePath"),
12636	parentData: new codegen_1.Name("parentData"),
12637	parentDataProperty: new codegen_1.Name("parentDataProperty"),
12638	rootData: new codegen_1.Name("rootData"),
12639	dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
12640	vErrors: new codegen_1.Name("vErrors"),
12641	errors: new codegen_1.Name("errors"),
12642	this: new codegen_1.Name("this"),
12643	self: new codegen_1.Name("self"),
12644	scope: new codegen_1.Name("scope"),
12645	json: new codegen_1.Name("json"),
12646	jsonPos: new codegen_1.Name("jsonPos"),
12647	jsonLen: new codegen_1.Name("jsonLen"),
12648	jsonPart: new codegen_1.Name("jsonPart")
12649	};
12650	exports.default = names;
12651	}));
12652
12653	//#endregion
12654	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/errors.js
12655	var require_errors = /* @__PURE__ */ __commonJSMin(((exports) => {
12656	Object.defineProperty(exports, "__esModule", { value: true });
12657	exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;
12658	var codegen_1 = require_codegen();
12659	var util_1 = require_util();
12660	var names_1 = require_names();
12661	exports.keywordError = { message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation` };
12662	exports.keyword$DataError = { message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)` };
12663	function reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) {
12664	const { it } = cxt;
12665	const { gen, compositeRule, allErrors } = it;
12666	const errObj = errorObjectCode(cxt, error, errorPaths);
12667	if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : compositeRule \|\| allErrors) addError(gen, errObj);
12668	else returnErrors(it, (0, codegen_1._)`[${errObj}]`);
12669	}
12670	exports.reportError = reportError;
12671	function reportExtraError(cxt, error = exports.keywordError, errorPaths) {
12672	const { it } = cxt;
12673	const { gen, compositeRule, allErrors } = it;
12674	addError(gen, errorObjectCode(cxt, error, errorPaths));
12675	if (!(compositeRule \|\| allErrors)) returnErrors(it, names_1.default.vErrors);
12676	}
12677	exports.reportExtraError = reportExtraError;
12678	function resetErrorsCount(gen, errsCount) {
12679	gen.assign(names_1.default.errors, errsCount);
12680	gen.if((0, codegen_1._)`${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._)`${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null)));
12681	}
12682	exports.resetErrorsCount = resetErrorsCount;
12683	function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) {
12684	/* istanbul ignore if */
12685	if (errsCount === void 0) throw new Error("ajv implementation error");
12686	const err = gen.name("err");
12687	gen.forRange("i", errsCount, names_1.default.errors, (i) => {
12688	gen.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
12689	gen.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
12690	gen.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
12691	if (it.opts.verbose) {
12692	gen.assign((0, codegen_1._)`${err}.schema`, schemaValue);
12693	gen.assign((0, codegen_1._)`${err}.data`, data);
12694	}
12695	});
12696	}
12697	exports.extendErrors = extendErrors;
12698	function addError(gen, errObj) {
12699	const err = gen.const("err", errObj);
12700	gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`);
12701	gen.code((0, codegen_1._)`${names_1.default.errors}++`);
12702	}
12703	function returnErrors(it, errs) {
12704	const { gen, validateName, schemaEnv } = it;
12705	if (schemaEnv.$async) gen.throw((0, codegen_1._)`new ${it.ValidationError}(${errs})`);
12706	else {
12707	gen.assign((0, codegen_1._)`${validateName}.errors`, errs);
12708	gen.return(false);
12709	}
12710	}
12711	var E = {
12712	keyword: new codegen_1.Name("keyword"),
12713	schemaPath: new codegen_1.Name("schemaPath"),
12714	params: new codegen_1.Name("params"),
12715	propertyName: new codegen_1.Name("propertyName"),
12716	message: new codegen_1.Name("message"),
12717	schema: new codegen_1.Name("schema"),
12718	parentSchema: new codegen_1.Name("parentSchema")
12719	};
12720	function errorObjectCode(cxt, error, errorPaths) {
12721	const { createErrors } = cxt.it;
12722	if (createErrors === false) return (0, codegen_1._)`{}`;
12723	return errorObject(cxt, error, errorPaths);
12724	}
12725	function errorObject(cxt, error, errorPaths = {}) {
12726	const { gen, it } = cxt;
12727	const keyValues = [errorInstancePath(it, errorPaths), errorSchemaPath(cxt, errorPaths)];
12728	extraErrorProps(cxt, error, keyValues);
12729	return gen.object(...keyValues);
12730	}
12731	function errorInstancePath({ errorPath }, { instancePath }) {
12732	const instPath = instancePath ? (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : errorPath;
12733	return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)];
12734	}
12735	function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
12736	let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str)`${errSchemaPath}/${keyword}`;
12737	if (schemaPath) schPath = (0, codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
12738	return [E.schemaPath, schPath];
12739	}
12740	function extraErrorProps(cxt, { params, message }, keyValues) {
12741	const { keyword, data, schemaValue, it } = cxt;
12742	const { opts, propertyName, topSchemaRef, schemaPath } = it;
12743	keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params \|\| (0, codegen_1._)`{}`]);
12744	if (opts.messages) keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]);
12745	if (opts.verbose) keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`], [names_1.default.data, data]);
12746	if (propertyName) keyValues.push([E.propertyName, propertyName]);
12747	}
12748	}));
12749
12750	//#endregion
12751	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/validate/boolSchema.js
12752	var require_boolSchema = /* @__PURE__ */ __commonJSMin(((exports) => {
12753	Object.defineProperty(exports, "__esModule", { value: true });
12754	exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
12755	var errors_1 = require_errors();
12756	var codegen_1 = require_codegen();
12757	var names_1 = require_names();
12758	var boolError = { message: "boolean schema is false" };
12759	function topBoolOrEmptySchema(it) {
12760	const { gen, schema, validateName } = it;
12761	if (schema === false) falseSchemaError(it, false);
12762	else if (typeof schema == "object" && schema.$async === true) gen.return(names_1.default.data);
12763	else {
12764	gen.assign((0, codegen_1._)`${validateName}.errors`, null);
12765	gen.return(true);
12766	}
12767	}
12768	exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
12769	function boolOrEmptySchema(it, valid) {
12770	const { gen, schema } = it;
12771	if (schema === false) {
12772	gen.var(valid, false);
12773	falseSchemaError(it);
12774	} else gen.var(valid, true);
12775	}
12776	exports.boolOrEmptySchema = boolOrEmptySchema;
12777	function falseSchemaError(it, overrideAllErrors) {
12778	const { gen, data } = it;
12779	const cxt = {
12780	gen,
12781	keyword: "false schema",
12782	data,
12783	schema: false,
12784	schemaCode: false,
12785	schemaValue: false,
12786	params: {},
12787	it
12788	};
12789	(0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors);
12790	}
12791	}));
12792
12793	//#endregion
12794	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/rules.js
12795	var require_rules = /* @__PURE__ */ __commonJSMin(((exports) => {
12796	Object.defineProperty(exports, "__esModule", { value: true });
12797	exports.getRules = exports.isJSONType = void 0;
12798	var jsonTypes = /* @__PURE__ */ new Set([
12799	"string",
12800	"number",
12801	"integer",
12802	"boolean",
12803	"null",
12804	"object",
12805	"array"
12806	]);
12807	function isJSONType(x) {
12808	return typeof x == "string" && jsonTypes.has(x);
12809	}
12810	exports.isJSONType = isJSONType;
12811	function getRules() {
12812	const groups = {
12813	number: {
12814	type: "number",
12815	rules: []
12816	},
12817	string: {
12818	type: "string",
12819	rules: []
12820	},
12821	array: {
12822	type: "array",
12823	rules: []
12824	},
12825	object: {
12826	type: "object",
12827	rules: []
12828	}
12829	};
12830	return {
12831	types: {
12832	...groups,
12833	integer: true,
12834	boolean: true,
12835	null: true
12836	},
12837	rules: [
12838	{ rules: [] },
12839	groups.number,
12840	groups.string,
12841	groups.array,
12842	groups.object
12843	],
12844	post: { rules: [] },
12845	all: {},
12846	keywords: {}
12847	};
12848	}
12849	exports.getRules = getRules;
12850	}));
12851
12852	//#endregion
12853	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/validate/applicability.js
12854	var require_applicability = /* @__PURE__ */ __commonJSMin(((exports) => {
12855	Object.defineProperty(exports, "__esModule", { value: true });
12856	exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
12857	function schemaHasRulesForType({ schema, self }, type) {
12858	const group = self.RULES.types[type];
12859	return group && group !== true && shouldUseGroup(schema, group);
12860	}
12861	exports.schemaHasRulesForType = schemaHasRulesForType;
12862	function shouldUseGroup(schema, group) {
12863	return group.rules.some((rule) => shouldUseRule(schema, rule));
12864	}
12865	exports.shouldUseGroup = shouldUseGroup;
12866	function shouldUseRule(schema, rule) {
12867	var _a;
12868	return schema[rule.keyword] !== void 0 \|\| ((_a = rule.definition.implements) === null \|\| _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== void 0));
12869	}
12870	exports.shouldUseRule = shouldUseRule;
12871	}));
12872
12873	//#endregion
12874	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/validate/dataType.js
12875	var require_dataType = /* @__PURE__ */ __commonJSMin(((exports) => {
12876	Object.defineProperty(exports, "__esModule", { value: true });
12877	exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
12878	var rules_1 = require_rules();
12879	var applicability_1 = require_applicability();
12880	var errors_1 = require_errors();
12881	var codegen_1 = require_codegen();
12882	var util_1 = require_util();
12883	var DataType;
12884	(function(DataType) {
12885	DataType[DataType["Correct"] = 0] = "Correct";
12886	DataType[DataType["Wrong"] = 1] = "Wrong";
12887	})(DataType \|\| (exports.DataType = DataType = {}));
12888	function getSchemaTypes(schema) {
12889	const types = getJSONTypes(schema.type);
12890	if (types.includes("null")) {
12891	if (schema.nullable === false) throw new Error("type: null contradicts nullable: false");
12892	} else {
12893	if (!types.length && schema.nullable !== void 0) throw new Error("\"nullable\" cannot be used without \"type\"");
12894	if (schema.nullable === true) types.push("null");
12895	}
12896	return types;
12897	}
12898	exports.getSchemaTypes = getSchemaTypes;
12899	function getJSONTypes(ts) {
12900	const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
12901	if (types.every(rules_1.isJSONType)) return types;
12902	throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
12903	}
12904	exports.getJSONTypes = getJSONTypes;
12905	function coerceAndCheckDataType(it, types) {
12906	const { gen, data, opts } = it;
12907	const coerceTo = coerceToTypes(types, opts.coerceTypes);
12908	const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
12909	if (checkTypes) {
12910	const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
12911	gen.if(wrongType, () => {
12912	if (coerceTo.length) coerceData(it, types, coerceTo);
12913	else reportTypeError(it);
12914	});
12915	}
12916	return checkTypes;
12917	}
12918	exports.coerceAndCheckDataType = coerceAndCheckDataType;
12919	var COERCIBLE = /* @__PURE__ */ new Set([
12920	"string",
12921	"number",
12922	"integer",
12923	"boolean",
12924	"null"
12925	]);
12926	function coerceToTypes(types, coerceTypes) {
12927	return coerceTypes ? types.filter((t) => COERCIBLE.has(t) \|\| coerceTypes === "array" && t === "array") : [];
12928	}
12929	function coerceData(it, types, coerceTo) {
12930	const { gen, data, opts } = it;
12931	const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
12932	const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
12933	if (opts.coerceTypes === "array") gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
12934	gen.if((0, codegen_1._)`${coerced} !== undefined`);
12935	for (const t of coerceTo) if (COERCIBLE.has(t) \|\| t === "array" && opts.coerceTypes === "array") coerceSpecificType(t);
12936	gen.else();
12937	reportTypeError(it);
12938	gen.endIf();
12939	gen.if((0, codegen_1._)`${coerced} !== undefined`, () => {
12940	gen.assign(data, coerced);
12941	assignParentData(it, coerced);
12942	});
12943	function coerceSpecificType(t) {
12944	switch (t) {
12945	case "string":
12946	gen.elseIf((0, codegen_1._)`${dataType} == "number" \|\| ${dataType} == "boolean"`).assign(coerced, (0, codegen_1._)`"" + ${data}`).elseIf((0, codegen_1._)`${data} === null`).assign(coerced, (0, codegen_1._)`""`);
12947	return;
12948	case "number":
12949	gen.elseIf((0, codegen_1._)`${dataType} == "boolean" \|\| ${data} === null
12950	\|\| (${dataType} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1._)`+${data}`);
12951	return;
12952	case "integer":
12953	gen.elseIf((0, codegen_1._)`${dataType} === "boolean" \|\| ${data} === null
12954	\|\| (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1._)`+${data}`);
12955	return;
12956	case "boolean":
12957	gen.elseIf((0, codegen_1._)`${data} === "false" \|\| ${data} === 0 \|\| ${data} === null`).assign(coerced, false).elseIf((0, codegen_1._)`${data} === "true" \|\| ${data} === 1`).assign(coerced, true);
12958	return;
12959	case "null":
12960	gen.elseIf((0, codegen_1._)`${data} === "" \|\| ${data} === 0 \|\| ${data} === false`);
12961	gen.assign(coerced, null);
12962	return;
12963	case "array": gen.elseIf((0, codegen_1._)`${dataType} === "string" \|\| ${dataType} === "number"
12964	\|\| ${dataType} === "boolean" \|\| ${data} === null`).assign(coerced, (0, codegen_1._)`[${data}]`);
12965	}
12966	}
12967	}
12968	function assignParentData({ gen, parentData, parentDataProperty }, expr) {
12969	gen.if((0, codegen_1._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1._)`${parentData}[${parentDataProperty}]`, expr));
12970	}
12971	function checkDataType(dataType, data, strictNums, correct = DataType.Correct) {
12972	const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ;
12973	let cond;
12974	switch (dataType) {
12975	case "null": return (0, codegen_1._)`${data} ${EQ} null`;
12976	case "array":
12977	cond = (0, codegen_1._)`Array.isArray(${data})`;
12978	break;
12979	case "object":
12980	cond = (0, codegen_1._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
12981	break;
12982	case "integer":
12983	cond = numCond((0, codegen_1._)`!(${data} % 1) && !isNaN(${data})`);
12984	break;
12985	case "number":
12986	cond = numCond();
12987	break;
12988	default: return (0, codegen_1._)`typeof ${data} ${EQ} ${dataType}`;
12989	}
12990	return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond);
12991	function numCond(_cond = codegen_1.nil) {
12992	return (0, codegen_1.and)((0, codegen_1._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._)`isFinite(${data})` : codegen_1.nil);
12993	}
12994	}
12995	exports.checkDataType = checkDataType;
12996	function checkDataTypes(dataTypes, data, strictNums, correct) {
12997	if (dataTypes.length === 1) return checkDataType(dataTypes[0], data, strictNums, correct);
12998	let cond;
12999	const types = (0, util_1.toHash)(dataTypes);
13000	if (types.array && types.object) {
13001	const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
13002	cond = types.null ? notObj : (0, codegen_1._)`!${data} \|\| ${notObj}`;
13003	delete types.null;
13004	delete types.array;
13005	delete types.object;
13006	} else cond = codegen_1.nil;
13007	if (types.number) delete types.integer;
13008	for (const t in types) cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
13009	return cond;
13010	}
13011	exports.checkDataTypes = checkDataTypes;
13012	var typeError = {
13013	message: ({ schema }) => `must be ${schema}`,
13014	params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}`
13015	};
13016	function reportTypeError(it) {
13017	const cxt = getTypeErrorContext(it);
13018	(0, errors_1.reportError)(cxt, typeError);
13019	}
13020	exports.reportTypeError = reportTypeError;
13021	function getTypeErrorContext(it) {
13022	const { gen, data, schema } = it;
13023	const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
13024	return {
13025	gen,
13026	keyword: "type",
13027	data,
13028	schema: schema.type,
13029	schemaCode,
13030	schemaValue: schemaCode,
13031	parentSchema: schema,
13032	params: {},
13033	it
13034	};
13035	}
13036	}));
13037
13038	//#endregion
13039	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/validate/defaults.js
13040	var require_defaults = /* @__PURE__ */ __commonJSMin(((exports) => {
13041	Object.defineProperty(exports, "__esModule", { value: true });
13042	exports.assignDefaults = void 0;
13043	var codegen_1 = require_codegen();
13044	var util_1 = require_util();
13045	function assignDefaults(it, ty) {
13046	const { properties, items } = it.schema;
13047	if (ty === "object" && properties) for (const key in properties) assignDefault(it, key, properties[key].default);
13048	else if (ty === "array" && Array.isArray(items)) items.forEach((sch, i) => assignDefault(it, i, sch.default));
13049	}
13050	exports.assignDefaults = assignDefaults;
13051	function assignDefault(it, prop, defaultValue) {
13052	const { gen, compositeRule, data, opts } = it;
13053	if (defaultValue === void 0) return;
13054	const childData = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
13055	if (compositeRule) {
13056	(0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
13057	return;
13058	}
13059	let condition = (0, codegen_1._)`${childData} === undefined`;
13060	if (opts.useDefaults === "empty") condition = (0, codegen_1._)`${condition} \|\| ${childData} === null \|\| ${childData} === ""`;
13061	gen.if(condition, (0, codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);
13062	}
13063	}));
13064
13065	//#endregion
13066	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/code.js
13067	var require_code = /* @__PURE__ */ __commonJSMin(((exports) => {
13068	Object.defineProperty(exports, "__esModule", { value: true });
13069	exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0;
13070	var codegen_1 = require_codegen();
13071	var util_1 = require_util();
13072	var names_1 = require_names();
13073	var util_2 = require_util();
13074	function checkReportMissingProp(cxt, prop) {
13075	const { gen, data, it } = cxt;
13076	gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
13077	cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true);
13078	cxt.error();
13079	});
13080	}
13081	exports.checkReportMissingProp = checkReportMissingProp;
13082	function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
13083	return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._)`${missing} = ${prop}`)));
13084	}
13085	exports.checkMissingProp = checkMissingProp;
13086	function reportMissingProp(cxt, missing) {
13087	cxt.setParams({ missingProperty: missing }, true);
13088	cxt.error();
13089	}
13090	exports.reportMissingProp = reportMissingProp;
13091	function hasPropFunc(gen) {
13092	return gen.scopeValue("func", {
13093	ref: Object.prototype.hasOwnProperty,
13094	code: (0, codegen_1._)`Object.prototype.hasOwnProperty`
13095	});
13096	}
13097	exports.hasPropFunc = hasPropFunc;
13098	function isOwnProperty(gen, data, property) {
13099	return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
13100	}
13101	exports.isOwnProperty = isOwnProperty;
13102	function propertyInData(gen, data, property, ownProperties) {
13103	const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
13104	return ownProperties ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond;
13105	}
13106	exports.propertyInData = propertyInData;
13107	function noPropertyInData(gen, data, property, ownProperties) {
13108	const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
13109	return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond;
13110	}
13111	exports.noPropertyInData = noPropertyInData;
13112	function allSchemaProperties(schemaMap) {
13113	return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
13114	}
13115	exports.allSchemaProperties = allSchemaProperties;
13116	function schemaProperties(it, schemaMap) {
13117	return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
13118	}
13119	exports.schemaProperties = schemaProperties;
13120	function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
13121	const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
13122	const valCxt = [
13123	[names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
13124	[names_1.default.parentData, it.parentData],
13125	[names_1.default.parentDataProperty, it.parentDataProperty],
13126	[names_1.default.rootData, names_1.default.rootData]
13127	];
13128	if (it.opts.dynamicRef) valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
13129	const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
13130	return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`;
13131	}
13132	exports.callValidateCode = callValidateCode;
13133	var newRegExp = (0, codegen_1._)`new RegExp`;
13134	function usePattern({ gen, it: { opts } }, pattern) {
13135	const u = opts.unicodeRegExp ? "u" : "";
13136	const { regExp } = opts.code;
13137	const rx = regExp(pattern, u);
13138	return gen.scopeValue("pattern", {
13139	key: rx.toString(),
13140	ref: rx,
13141	code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`
13142	});
13143	}
13144	exports.usePattern = usePattern;
13145	function validateArray(cxt) {
13146	const { gen, data, keyword, it } = cxt;
13147	const valid = gen.name("valid");
13148	if (it.allErrors) {
13149	const validArr = gen.let("valid", true);
13150	validateItems(() => gen.assign(validArr, false));
13151	return validArr;
13152	}
13153	gen.var(valid, true);
13154	validateItems(() => gen.break());
13155	return valid;
13156	function validateItems(notValid) {
13157	const len = gen.const("len", (0, codegen_1._)`${data}.length`);
13158	gen.forRange("i", 0, len, (i) => {
13159	cxt.subschema({
13160	keyword,
13161	dataProp: i,
13162	dataPropType: util_1.Type.Num
13163	}, valid);
13164	gen.if((0, codegen_1.not)(valid), notValid);
13165	});
13166	}
13167	}
13168	exports.validateArray = validateArray;
13169	function validateUnion(cxt) {
13170	const { gen, schema, keyword, it } = cxt;
13171	/* istanbul ignore if */
13172	if (!Array.isArray(schema)) throw new Error("ajv implementation error");
13173	if (schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch)) && !it.opts.unevaluated) return;
13174	const valid = gen.let("valid", false);
13175	const schValid = gen.name("_valid");
13176	gen.block(() => schema.forEach((_sch, i) => {
13177	const schCxt = cxt.subschema({
13178	keyword,
13179	schemaProp: i,
13180	compositeRule: true
13181	}, schValid);
13182	gen.assign(valid, (0, codegen_1._)`${valid} \|\| ${schValid}`);
13183	if (!cxt.mergeValidEvaluated(schCxt, schValid)) gen.if((0, codegen_1.not)(valid));
13184	}));
13185	cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
13186	}
13187	exports.validateUnion = validateUnion;
13188	}));
13189
13190	//#endregion
13191	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/validate/keyword.js
13192	var require_keyword = /* @__PURE__ */ __commonJSMin(((exports) => {
13193	Object.defineProperty(exports, "__esModule", { value: true });
13194	exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0;
13195	var codegen_1 = require_codegen();
13196	var names_1 = require_names();
13197	var code_1 = require_code();
13198	var errors_1 = require_errors();
13199	function macroKeywordCode(cxt, def) {
13200	const { gen, keyword, schema, parentSchema, it } = cxt;
13201	const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
13202	const schemaRef = useKeyword(gen, keyword, macroSchema);
13203	if (it.opts.validateSchema !== false) it.self.validateSchema(macroSchema, true);
13204	const valid = gen.name("valid");
13205	cxt.subschema({
13206	schema: macroSchema,
13207	schemaPath: codegen_1.nil,
13208	errSchemaPath: `${it.errSchemaPath}/${keyword}`,
13209	topSchemaRef: schemaRef,
13210	compositeRule: true
13211	}, valid);
13212	cxt.pass(valid, () => cxt.error(true));
13213	}
13214	exports.macroKeywordCode = macroKeywordCode;
13215	function funcKeywordCode(cxt, def) {
13216	var _a;
13217	const { gen, keyword, schema, parentSchema, $data, it } = cxt;
13218	checkAsyncKeyword(it, def);
13219	const validateRef = useKeyword(gen, keyword, !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate);
13220	const valid = gen.let("valid");
13221	cxt.block$data(valid, validateKeyword);
13222	cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid);
13223	function validateKeyword() {
13224	if (def.errors === false) {
13225	assignValid();
13226	if (def.modifying) modifyData(cxt);
13227	reportErrs(() => cxt.error());
13228	} else {
13229	const ruleErrs = def.async ? validateAsync() : validateSync();
13230	if (def.modifying) modifyData(cxt);
13231	reportErrs(() => addErrs(cxt, ruleErrs));
13232	}
13233	}
13234	function validateAsync() {
13235	const ruleErrs = gen.let("ruleErrs", null);
13236	gen.try(() => assignValid((0, codegen_1._)`await `), (e) => gen.assign(valid, false).if((0, codegen_1._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1._)`${e}.errors`), () => gen.throw(e)));
13237	return ruleErrs;
13238	}
13239	function validateSync() {
13240	const validateErrs = (0, codegen_1._)`${validateRef}.errors`;
13241	gen.assign(validateErrs, null);
13242	assignValid(codegen_1.nil);
13243	return validateErrs;
13244	}
13245	function assignValid(_await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil) {
13246	const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self;
13247	const passSchema = !("compile" in def && !$data \|\| def.schema === false);
13248	gen.assign(valid, (0, codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying);
13249	}
13250	function reportErrs(errors) {
13251	var _a;
13252	gen.if((0, codegen_1.not)((_a = def.valid) !== null && _a !== void 0 ? _a : valid), errors);
13253	}
13254	}
13255	exports.funcKeywordCode = funcKeywordCode;
13256	function modifyData(cxt) {
13257	const { gen, data, it } = cxt;
13258	gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`));
13259	}
13260	function addErrs(cxt, errs) {
13261	const { gen } = cxt;
13262	gen.if((0, codegen_1._)`Array.isArray(${errs})`, () => {
13263	gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`).assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
13264	(0, errors_1.extendErrors)(cxt);
13265	}, () => cxt.error());
13266	}
13267	function checkAsyncKeyword({ schemaEnv }, def) {
13268	if (def.async && !schemaEnv.$async) throw new Error("async keyword in sync schema");
13269	}
13270	function useKeyword(gen, keyword, result) {
13271	if (result === void 0) throw new Error(`keyword "${keyword}" failed to compile`);
13272	return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : {
13273	ref: result,
13274	code: (0, codegen_1.stringify)(result)
13275	});
13276	}
13277	function validSchemaType(schema, schemaType, allowUndefined = false) {
13278	return !schemaType.length \|\| schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st \|\| allowUndefined && typeof schema == "undefined");
13279	}
13280	exports.validSchemaType = validSchemaType;
13281	function validateKeywordUsage({ schema, opts, self, errSchemaPath }, def, keyword) {
13282	/* istanbul ignore if */
13283	if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) throw new Error("ajv implementation error");
13284	const deps = def.dependencies;
13285	if (deps === null \|\| deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
13286	if (def.validateSchema) {
13287	if (!def.validateSchema(schema[keyword])) {
13288	const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self.errorsText(def.validateSchema.errors);
13289	if (opts.validateSchema === "log") self.logger.error(msg);
13290	else throw new Error(msg);
13291	}
13292	}
13293	}
13294	exports.validateKeywordUsage = validateKeywordUsage;
13295	}));
13296
13297	//#endregion
13298	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/validate/subschema.js
13299	var require_subschema = /* @__PURE__ */ __commonJSMin(((exports) => {
13300	Object.defineProperty(exports, "__esModule", { value: true });
13301	exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
13302	var codegen_1 = require_codegen();
13303	var util_1 = require_util();
13304	function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
13305	if (keyword !== void 0 && schema !== void 0) throw new Error("both \"keyword\" and \"schema\" passed, only one allowed");
13306	if (keyword !== void 0) {
13307	const sch = it.schema[keyword];
13308	return schemaProp === void 0 ? {
13309	schema: sch,
13310	schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
13311	errSchemaPath: `${it.errSchemaPath}/${keyword}`
13312	} : {
13313	schema: sch[schemaProp],
13314	schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
13315	errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
13316	};
13317	}
13318	if (schema !== void 0) {
13319	if (schemaPath === void 0 \|\| errSchemaPath === void 0 \|\| topSchemaRef === void 0) throw new Error("\"schemaPath\", \"errSchemaPath\" and \"topSchemaRef\" are required with \"schema\"");
13320	return {
13321	schema,
13322	schemaPath,
13323	topSchemaRef,
13324	errSchemaPath
13325	};
13326	}
13327	throw new Error("either \"keyword\" or \"schema\" must be passed");
13328	}
13329	exports.getSubschema = getSubschema;
13330	function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
13331	if (data !== void 0 && dataProp !== void 0) throw new Error("both \"data\" and \"dataProp\" passed, only one allowed");
13332	const { gen } = it;
13333	if (dataProp !== void 0) {
13334	const { errorPath, dataPathArr, opts } = it;
13335	dataContextProps(gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true));
13336	subschema.errorPath = (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
13337	subschema.parentDataProperty = (0, codegen_1._)`${dataProp}`;
13338	subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];
13339	}
13340	if (data !== void 0) {
13341	dataContextProps(data instanceof codegen_1.Name ? data : gen.let("data", data, true));
13342	if (propertyName !== void 0) subschema.propertyName = propertyName;
13343	}
13344	if (dataTypes) subschema.dataTypes = dataTypes;
13345	function dataContextProps(_nextData) {
13346	subschema.data = _nextData;
13347	subschema.dataLevel = it.dataLevel + 1;
13348	subschema.dataTypes = [];
13349	it.definedProperties = /* @__PURE__ */ new Set();
13350	subschema.parentData = it.data;
13351	subschema.dataNames = [...it.dataNames, _nextData];
13352	}
13353	}
13354	exports.extendSubschemaData = extendSubschemaData;
13355	function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
13356	if (compositeRule !== void 0) subschema.compositeRule = compositeRule;
13357	if (createErrors !== void 0) subschema.createErrors = createErrors;
13358	if (allErrors !== void 0) subschema.allErrors = allErrors;
13359	subschema.jtdDiscriminator = jtdDiscriminator;
13360	subschema.jtdMetadata = jtdMetadata;
13361	}
13362	exports.extendSubschemaMode = extendSubschemaMode;
13363	}));
13364
13365	//#endregion
13366	//#region node_modules/fast-deep-equal/index.js
13367	var require_fast_deep_equal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
13368	module.exports = function equal(a, b) {
13369	if (a === b) return true;
13370	if (a && b && typeof a == "object" && typeof b == "object") {
13371	if (a.constructor !== b.constructor) return false;
13372	var length;
13373	var i;
13374	var keys;
13375	if (Array.isArray(a)) {
13376	length = a.length;
13377	if (length != b.length) return false;
13378	for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;
13379	return true;
13380	}
13381	if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
13382	if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
13383	if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
13384	keys = Object.keys(a);
13385	length = keys.length;
13386	if (length !== Object.keys(b).length) return false;
13387	for (i = length; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
13388	for (i = length; i-- !== 0;) {
13389	var key = keys[i];
13390	if (!equal(a[key], b[key])) return false;
13391	}
13392	return true;
13393	}
13394	return a !== a && b !== b;
13395	};
13396	}));
13397
13398	//#endregion
13399	//#region node_modules/@modelcontextprotocol/sdk/node_modules/json-schema-traverse/index.js
13400	var require_json_schema_traverse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
13401	var traverse = module.exports = function(schema, opts, cb) {
13402	if (typeof opts == "function") {
13403	cb = opts;
13404	opts = {};
13405	}
13406	cb = opts.cb \|\| cb;
13407	var pre = typeof cb == "function" ? cb : cb.pre \|\| function() {};
13408	var post = cb.post \|\| function() {};
13409	_traverse(opts, pre, post, schema, "", schema);
13410	};
13411	traverse.keywords = {
13412	additionalItems: true,
13413	items: true,
13414	contains: true,
13415	additionalProperties: true,
13416	propertyNames: true,
13417	not: true,
13418	if: true,
13419	then: true,
13420	else: true
13421	};
13422	traverse.arrayKeywords = {
13423	items: true,
13424	allOf: true,
13425	anyOf: true,
13426	oneOf: true
13427	};
13428	traverse.propsKeywords = {
13429	$defs: true,
13430	definitions: true,
13431	properties: true,
13432	patternProperties: true,
13433	dependencies: true
13434	};
13435	traverse.skipKeywords = {
13436	default: true,
13437	enum: true,
13438	const: true,
13439	required: true,
13440	maximum: true,
13441	minimum: true,
13442	exclusiveMaximum: true,
13443	exclusiveMinimum: true,
13444	multipleOf: true,
13445	maxLength: true,
13446	minLength: true,
13447	pattern: true,
13448	format: true,
13449	maxItems: true,
13450	minItems: true,
13451	uniqueItems: true,
13452	maxProperties: true,
13453	minProperties: true
13454	};
13455	function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
13456	if (schema && typeof schema == "object" && !Array.isArray(schema)) {
13457	pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
13458	for (var key in schema) {
13459	var sch = schema[key];
13460	if (Array.isArray(sch)) {
13461	if (key in traverse.arrayKeywords) for (var i = 0; i < sch.length; i++) _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
13462	} else if (key in traverse.propsKeywords) {
13463	if (sch && typeof sch == "object") for (var prop in sch) _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
13464	} else if (key in traverse.keywords \|\| opts.allKeys && !(key in traverse.skipKeywords)) _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
13465	}
13466	post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
13467	}
13468	}
13469	function escapeJsonPtr(str) {
13470	return str.replace(/~/g, "~0").replace(/\//g, "~1");
13471	}
13472	}));
13473
13474	//#endregion
13475	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/resolve.js
13476	var require_resolve = /* @__PURE__ */ __commonJSMin(((exports) => {
13477	Object.defineProperty(exports, "__esModule", { value: true });
13478	exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;
13479	var util_1 = require_util();
13480	var equal = require_fast_deep_equal();
13481	var traverse = require_json_schema_traverse();
13482	var SIMPLE_INLINED = /* @__PURE__ */ new Set([
13483	"type",
13484	"format",
13485	"pattern",
13486	"maxLength",
13487	"minLength",
13488	"maxProperties",
13489	"minProperties",
13490	"maxItems",
13491	"minItems",
13492	"maximum",
13493	"minimum",
13494	"uniqueItems",
13495	"multipleOf",
13496	"required",
13497	"enum",
13498	"const"
13499	]);
13500	function inlineRef(schema, limit = true) {
13501	if (typeof schema == "boolean") return true;
13502	if (limit === true) return !hasRef(schema);
13503	if (!limit) return false;
13504	return countKeys(schema) <= limit;
13505	}
13506	exports.inlineRef = inlineRef;
13507	var REF_KEYWORDS = /* @__PURE__ */ new Set([
13508	"$ref",
13509	"$recursiveRef",
13510	"$recursiveAnchor",
13511	"$dynamicRef",
13512	"$dynamicAnchor"
13513	]);
13514	function hasRef(schema) {
13515	for (const key in schema) {
13516	if (REF_KEYWORDS.has(key)) return true;
13517	const sch = schema[key];
13518	if (Array.isArray(sch) && sch.some(hasRef)) return true;
13519	if (typeof sch == "object" && hasRef(sch)) return true;
13520	}
13521	return false;
13522	}
13523	function countKeys(schema) {
13524	let count = 0;
13525	for (const key in schema) {
13526	if (key === "$ref") return Infinity;
13527	count++;
13528	if (SIMPLE_INLINED.has(key)) continue;
13529	if (typeof schema[key] == "object") (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
13530	if (count === Infinity) return Infinity;
13531	}
13532	return count;
13533	}
13534	function getFullPath(resolver, id = "", normalize) {
13535	if (normalize !== false) id = normalizeId(id);
13536	return _getFullPath(resolver, resolver.parse(id));
13537	}
13538	exports.getFullPath = getFullPath;
13539	function _getFullPath(resolver, p) {
13540	return resolver.serialize(p).split("#")[0] + "#";
13541	}
13542	exports._getFullPath = _getFullPath;
13543	var TRAILING_SLASH_HASH = /#\/?$/;
13544	function normalizeId(id) {
13545	return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
13546	}
13547	exports.normalizeId = normalizeId;
13548	function resolveUrl(resolver, baseId, id) {
13549	id = normalizeId(id);
13550	return resolver.resolve(baseId, id);
13551	}
13552	exports.resolveUrl = resolveUrl;
13553	var ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
13554	function getSchemaRefs(schema, baseId) {
13555	if (typeof schema == "boolean") return {};
13556	const { schemaId, uriResolver } = this.opts;
13557	const schId = normalizeId(schema[schemaId] \|\| baseId);
13558	const baseIds = { "": schId };
13559	const pathPrefix = getFullPath(uriResolver, schId, false);
13560	const localRefs = {};
13561	const schemaRefs = /* @__PURE__ */ new Set();
13562	traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
13563	if (parentJsonPtr === void 0) return;
13564	const fullPath = pathPrefix + jsonPtr;
13565	let innerBaseId = baseIds[parentJsonPtr];
13566	if (typeof sch[schemaId] == "string") innerBaseId = addRef.call(this, sch[schemaId]);
13567	addAnchor.call(this, sch.$anchor);
13568	addAnchor.call(this, sch.$dynamicAnchor);
13569	baseIds[jsonPtr] = innerBaseId;
13570	function addRef(ref) {
13571	const _resolve = this.opts.uriResolver.resolve;
13572	ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
13573	if (schemaRefs.has(ref)) throw ambiguos(ref);
13574	schemaRefs.add(ref);
13575	let schOrRef = this.refs[ref];
13576	if (typeof schOrRef == "string") schOrRef = this.refs[schOrRef];
13577	if (typeof schOrRef == "object") checkAmbiguosRef(sch, schOrRef.schema, ref);
13578	else if (ref !== normalizeId(fullPath)) if (ref[0] === "#") {
13579	checkAmbiguosRef(sch, localRefs[ref], ref);
13580	localRefs[ref] = sch;
13581	} else this.refs[ref] = fullPath;
13582	return ref;
13583	}
13584	function addAnchor(anchor) {
13585	if (typeof anchor == "string") {
13586	if (!ANCHOR.test(anchor)) throw new Error(`invalid anchor "${anchor}"`);
13587	addRef.call(this, `#${anchor}`);
13588	}
13589	}
13590	});
13591	return localRefs;
13592	function checkAmbiguosRef(sch1, sch2, ref) {
13593	if (sch2 !== void 0 && !equal(sch1, sch2)) throw ambiguos(ref);
13594	}
13595	function ambiguos(ref) {
13596	return /* @__PURE__ */ new Error(`reference "${ref}" resolves to more than one schema`);
13597	}
13598	}
13599	exports.getSchemaRefs = getSchemaRefs;
13600	}));
13601
13602	//#endregion
13603	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/validate/index.js
13604	var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
13605	Object.defineProperty(exports, "__esModule", { value: true });
13606	exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;
13607	var boolSchema_1 = require_boolSchema();
13608	var dataType_1 = require_dataType();
13609	var applicability_1 = require_applicability();
13610	var dataType_2 = require_dataType();
13611	var defaults_1 = require_defaults();
13612	var keyword_1 = require_keyword();
13613	var subschema_1 = require_subschema();
13614	var codegen_1 = require_codegen();
13615	var names_1 = require_names();
13616	var resolve_1 = require_resolve();
13617	var util_1 = require_util();
13618	var errors_1 = require_errors();
13619	function validateFunctionCode(it) {
13620	if (isSchemaObj(it)) {
13621	checkKeywords(it);
13622	if (schemaCxtHasRules(it)) {
13623	topSchemaObjCode(it);
13624	return;
13625	}
13626	}
13627	validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
13628	}
13629	exports.validateFunctionCode = validateFunctionCode;
13630	function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
13631	if (opts.code.es5) gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
13632	gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
13633	destructureValCxtES5(gen, opts);
13634	gen.code(body);
13635	});
13636	else gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
13637	}
13638	function destructureValCxt(opts) {
13639	return (0, codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
13640	}
13641	function destructureValCxtES5(gen, opts) {
13642	gen.if(names_1.default.valCxt, () => {
13643	gen.var(names_1.default.instancePath, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`);
13644	gen.var(names_1.default.parentData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`);
13645	gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`);
13646	gen.var(names_1.default.rootData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`);
13647	if (opts.dynamicRef) gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`);
13648	}, () => {
13649	gen.var(names_1.default.instancePath, (0, codegen_1._)`""`);
13650	gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`);
13651	gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`undefined`);
13652	gen.var(names_1.default.rootData, names_1.default.data);
13653	if (opts.dynamicRef) gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`);
13654	});
13655	}
13656	function topSchemaObjCode(it) {
13657	const { schema, opts, gen } = it;
13658	validateFunction(it, () => {
13659	if (opts.$comment && schema.$comment) commentKeyword(it);
13660	checkNoDefault(it);
13661	gen.let(names_1.default.vErrors, null);
13662	gen.let(names_1.default.errors, 0);
13663	if (opts.unevaluated) resetEvaluated(it);
13664	typeAndKeywords(it);
13665	returnResults(it);
13666	});
13667	}
13668	function resetEvaluated(it) {
13669	const { gen, validateName } = it;
13670	it.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName}.evaluated`);
13671	gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`));
13672	gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`));
13673	}
13674	function funcSourceUrl(schema, opts) {
13675	const schId = typeof schema == "object" && schema[opts.schemaId];
13676	return schId && (opts.code.source \|\| opts.code.process) ? (0, codegen_1._)`/# sourceURL=${schId} /` : codegen_1.nil;
13677	}
13678	function subschemaCode(it, valid) {
13679	if (isSchemaObj(it)) {
13680	checkKeywords(it);
13681	if (schemaCxtHasRules(it)) {
13682	subSchemaObjCode(it, valid);
13683	return;
13684	}
13685	}
13686	(0, boolSchema_1.boolOrEmptySchema)(it, valid);
13687	}
13688	function schemaCxtHasRules({ schema, self }) {
13689	if (typeof schema == "boolean") return !schema;
13690	for (const key in schema) if (self.RULES.all[key]) return true;
13691	return false;
13692	}
13693	function isSchemaObj(it) {
13694	return typeof it.schema != "boolean";
13695	}
13696	function subSchemaObjCode(it, valid) {
13697	const { schema, gen, opts } = it;
13698	if (opts.$comment && schema.$comment) commentKeyword(it);
13699	updateContext(it);
13700	checkAsyncSchema(it);
13701	const errsCount = gen.const("_errs", names_1.default.errors);
13702	typeAndKeywords(it, errsCount);
13703	gen.var(valid, (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
13704	}
13705	function checkKeywords(it) {
13706	(0, util_1.checkUnknownRules)(it);
13707	checkRefsAndKeywords(it);
13708	}
13709	function typeAndKeywords(it, errsCount) {
13710	if (it.opts.jtd) return schemaKeywords(it, [], false, errsCount);
13711	const types = (0, dataType_1.getSchemaTypes)(it.schema);
13712	schemaKeywords(it, types, !(0, dataType_1.coerceAndCheckDataType)(it, types), errsCount);
13713	}
13714	function checkRefsAndKeywords(it) {
13715	const { schema, errSchemaPath, opts, self } = it;
13716	if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self.RULES)) self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
13717	}
13718	function checkNoDefault(it) {
13719	const { schema, opts } = it;
13720	if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) (0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
13721	}
13722	function updateContext(it) {
13723	const schId = it.schema[it.opts.schemaId];
13724	if (schId) it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId);
13725	}
13726	function checkAsyncSchema(it) {
13727	if (it.schema.$async && !it.schemaEnv.$async) throw new Error("async schema in sync schema");
13728	}
13729	function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
13730	const msg = schema.$comment;
13731	if (opts.$comment === true) gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
13732	else if (typeof opts.$comment == "function") {
13733	const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`;
13734	const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
13735	gen.code((0, codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
13736	}
13737	}
13738	function returnResults(it) {
13739	const { gen, schemaEnv, validateName, ValidationError, opts } = it;
13740	if (schemaEnv.$async) gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`));
13741	else {
13742	gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
13743	if (opts.unevaluated) assignEvaluated(it);
13744	gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
13745	}
13746	}
13747	function assignEvaluated({ gen, evaluated, props, items }) {
13748	if (props instanceof codegen_1.Name) gen.assign((0, codegen_1._)`${evaluated}.props`, props);
13749	if (items instanceof codegen_1.Name) gen.assign((0, codegen_1._)`${evaluated}.items`, items);
13750	}
13751	function schemaKeywords(it, types, typeErrors, errsCount) {
13752	const { gen, schema, data, allErrors, opts, self } = it;
13753	const { RULES } = self;
13754	if (schema.$ref && (opts.ignoreKeywordsWithRef \|\| !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
13755	gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
13756	return;
13757	}
13758	if (!opts.jtd) checkStrictTypes(it, types);
13759	gen.block(() => {
13760	for (const group of RULES.rules) groupKeywords(group);
13761	groupKeywords(RULES.post);
13762	});
13763	function groupKeywords(group) {
13764	if (!(0, applicability_1.shouldUseGroup)(schema, group)) return;
13765	if (group.type) {
13766	gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
13767	iterateKeywords(it, group);
13768	if (types.length === 1 && types[0] === group.type && typeErrors) {
13769	gen.else();
13770	(0, dataType_2.reportTypeError)(it);
13771	}
13772	gen.endIf();
13773	} else iterateKeywords(it, group);
13774	if (!allErrors) gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount \|\| 0}`);
13775	}
13776	}
13777	function iterateKeywords(it, group) {
13778	const { gen, schema, opts: { useDefaults } } = it;
13779	if (useDefaults) (0, defaults_1.assignDefaults)(it, group.type);
13780	gen.block(() => {
13781	for (const rule of group.rules) if ((0, applicability_1.shouldUseRule)(schema, rule)) keywordCode(it, rule.keyword, rule.definition, group.type);
13782	});
13783	}
13784	function checkStrictTypes(it, types) {
13785	if (it.schemaEnv.meta \|\| !it.opts.strictTypes) return;
13786	checkContextTypes(it, types);
13787	if (!it.opts.allowUnionTypes) checkMultipleTypes(it, types);
13788	checkKeywordTypes(it, it.dataTypes);
13789	}
13790	function checkContextTypes(it, types) {
13791	if (!types.length) return;
13792	if (!it.dataTypes.length) {
13793	it.dataTypes = types;
13794	return;
13795	}
13796	types.forEach((t) => {
13797	if (!includesType(it.dataTypes, t)) strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
13798	});
13799	narrowSchemaTypes(it, types);
13800	}
13801	function checkMultipleTypes(it, ts) {
13802	if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) strictTypesError(it, "use allowUnionTypes to allow union type keyword");
13803	}
13804	function checkKeywordTypes(it, ts) {
13805	const rules = it.self.RULES.all;
13806	for (const keyword in rules) {
13807	const rule = rules[keyword];
13808	if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {
13809	const { type } = rule.definition;
13810	if (type.length && !type.some((t) => hasApplicableType(ts, t))) strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`);
13811	}
13812	}
13813	}
13814	function hasApplicableType(schTs, kwdT) {
13815	return schTs.includes(kwdT) \|\| kwdT === "number" && schTs.includes("integer");
13816	}
13817	function includesType(ts, t) {
13818	return ts.includes(t) \|\| t === "integer" && ts.includes("number");
13819	}
13820	function narrowSchemaTypes(it, withTypes) {
13821	const ts = [];
13822	for (const t of it.dataTypes) if (includesType(withTypes, t)) ts.push(t);
13823	else if (withTypes.includes("integer") && t === "number") ts.push("integer");
13824	it.dataTypes = ts;
13825	}
13826	function strictTypesError(it, msg) {
13827	const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
13828	msg += ` at "${schemaPath}" (strictTypes)`;
13829	(0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes);
13830	}
13831	var KeywordCxt = class {
13832	constructor(it, def, keyword) {
13833	(0, keyword_1.validateKeywordUsage)(it, def, keyword);
13834	this.gen = it.gen;
13835	this.allErrors = it.allErrors;
13836	this.keyword = keyword;
13837	this.data = it.data;
13838	this.schema = it.schema[keyword];
13839	this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data;
13840	this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data);
13841	this.schemaType = def.schemaType;
13842	this.parentSchema = it.schema;
13843	this.params = {};
13844	this.it = it;
13845	this.def = def;
13846	if (this.$data) this.schemaCode = it.gen.const("vSchema", getData(this.$data, it));
13847	else {
13848	this.schemaCode = this.schemaValue;
13849	if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`);
13850	}
13851	if ("code" in def ? def.trackErrors : def.errors !== false) this.errsCount = it.gen.const("_errs", names_1.default.errors);
13852	}
13853	result(condition, successAction, failAction) {
13854	this.failResult((0, codegen_1.not)(condition), successAction, failAction);
13855	}
13856	failResult(condition, successAction, failAction) {
13857	this.gen.if(condition);
13858	if (failAction) failAction();
13859	else this.error();
13860	if (successAction) {
13861	this.gen.else();
13862	successAction();
13863	if (this.allErrors) this.gen.endIf();
13864	} else if (this.allErrors) this.gen.endIf();
13865	else this.gen.else();
13866	}
13867	pass(condition, failAction) {
13868	this.failResult((0, codegen_1.not)(condition), void 0, failAction);
13869	}
13870	fail(condition) {
13871	if (condition === void 0) {
13872	this.error();
13873	if (!this.allErrors) this.gen.if(false);
13874	return;
13875	}
13876	this.gen.if(condition);
13877	this.error();
13878	if (this.allErrors) this.gen.endIf();
13879	else this.gen.else();
13880	}
13881	fail$data(condition) {
13882	if (!this.$data) return this.fail(condition);
13883	const { schemaCode } = this;
13884	this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`);
13885	}
13886	error(append, errorParams, errorPaths) {
13887	if (errorParams) {
13888	this.setParams(errorParams);
13889	this._error(append, errorPaths);
13890	this.setParams({});
13891	return;
13892	}
13893	this._error(append, errorPaths);
13894	}
13895	_error(append, errorPaths) {
13896	(append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
13897	}
13898	$dataError() {
13899	(0, errors_1.reportError)(this, this.def.$dataError \|\| errors_1.keyword$DataError);
13900	}
13901	reset() {
13902	if (this.errsCount === void 0) throw new Error("add \"trackErrors\" to keyword definition");
13903	(0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
13904	}
13905	ok(cond) {
13906	if (!this.allErrors) this.gen.if(cond);
13907	}
13908	setParams(obj, assign) {
13909	if (assign) Object.assign(this.params, obj);
13910	else this.params = obj;
13911	}
13912	block$data(valid, codeBlock, $dataValid = codegen_1.nil) {
13913	this.gen.block(() => {
13914	this.check$data(valid, $dataValid);
13915	codeBlock();
13916	});
13917	}
13918	check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {
13919	if (!this.$data) return;
13920	const { gen, schemaCode, schemaType, def } = this;
13921	gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid));
13922	if (valid !== codegen_1.nil) gen.assign(valid, true);
13923	if (schemaType.length \|\| def.validateSchema) {
13924	gen.elseIf(this.invalid$data());
13925	this.$dataError();
13926	if (valid !== codegen_1.nil) gen.assign(valid, false);
13927	}
13928	gen.else();
13929	}
13930	invalid$data() {
13931	const { gen, schemaCode, schemaType, def, it } = this;
13932	return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());
13933	function wrong$DataType() {
13934	if (schemaType.length) {
13935	/* istanbul ignore if */
13936	if (!(schemaCode instanceof codegen_1.Name)) throw new Error("ajv implementation error");
13937	const st = Array.isArray(schemaType) ? schemaType : [schemaType];
13938	return (0, codegen_1._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
13939	}
13940	return codegen_1.nil;
13941	}
13942	function invalid$DataSchema() {
13943	if (def.validateSchema) {
13944	const validateSchemaRef = gen.scopeValue("validate$data", { ref: def.validateSchema });
13945	return (0, codegen_1._)`!${validateSchemaRef}(${schemaCode})`;
13946	}
13947	return codegen_1.nil;
13948	}
13949	}
13950	subschema(appl, valid) {
13951	const subschema = (0, subschema_1.getSubschema)(this.it, appl);
13952	(0, subschema_1.extendSubschemaData)(subschema, this.it, appl);
13953	(0, subschema_1.extendSubschemaMode)(subschema, appl);
13954	const nextContext = {
13955	...this.it,
13956	...subschema,
13957	items: void 0,
13958	props: void 0
13959	};
13960	subschemaCode(nextContext, valid);
13961	return nextContext;
13962	}
13963	mergeEvaluated(schemaCxt, toName) {
13964	const { it, gen } = this;
13965	if (!it.opts.unevaluated) return;
13966	if (it.props !== true && schemaCxt.props !== void 0) it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
13967	if (it.items !== true && schemaCxt.items !== void 0) it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
13968	}
13969	mergeValidEvaluated(schemaCxt, valid) {
13970	const { it, gen } = this;
13971	if (it.opts.unevaluated && (it.props !== true \|\| it.items !== true)) {
13972	gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name));
13973	return true;
13974	}
13975	}
13976	};
13977	exports.KeywordCxt = KeywordCxt;
13978	function keywordCode(it, keyword, def, ruleType) {
13979	const cxt = new KeywordCxt(it, def, keyword);
13980	if ("code" in def) def.code(cxt, ruleType);
13981	else if (cxt.$data && def.validate) (0, keyword_1.funcKeywordCode)(cxt, def);
13982	else if ("macro" in def) (0, keyword_1.macroKeywordCode)(cxt, def);
13983	else if (def.compile \|\| def.validate) (0, keyword_1.funcKeywordCode)(cxt, def);
13984	}
13985	var JSON_POINTER = /^\/(?:[^~]\|~0\|~1)*$/;
13986	var RELATIVE_JSON_POINTER = /^([0-9]+)(#\|\/(?:[^~]\|~0\|~1)*)?$/;
13987	function getData($data, { dataLevel, dataNames, dataPathArr }) {
13988	let jsonPointer;
13989	let data;
13990	if ($data === "") return names_1.default.rootData;
13991	if ($data[0] === "/") {
13992	if (!JSON_POINTER.test($data)) throw new Error(`Invalid JSON-pointer: ${$data}`);
13993	jsonPointer = $data;
13994	data = names_1.default.rootData;
13995	} else {
13996	const matches = RELATIVE_JSON_POINTER.exec($data);
13997	if (!matches) throw new Error(`Invalid JSON-pointer: ${$data}`);
13998	const up = +matches[1];
13999	jsonPointer = matches[2];
14000	if (jsonPointer === "#") {
14001	if (up >= dataLevel) throw new Error(errorMsg("property/index", up));
14002	return dataPathArr[dataLevel - up];
14003	}
14004	if (up > dataLevel) throw new Error(errorMsg("data", up));
14005	data = dataNames[dataLevel - up];
14006	if (!jsonPointer) return data;
14007	}
14008	let expr = data;
14009	const segments = jsonPointer.split("/");
14010	for (const segment of segments) if (segment) {
14011	data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`;
14012	expr = (0, codegen_1._)`${expr} && ${data}`;
14013	}
14014	return expr;
14015	function errorMsg(pointerType, up) {
14016	return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
14017	}
14018	}
14019	exports.getData = getData;
14020	}));
14021
14022	//#endregion
14023	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/runtime/validation_error.js
14024	var require_validation_error = /* @__PURE__ */ __commonJSMin(((exports) => {
14025	Object.defineProperty(exports, "__esModule", { value: true });
14026	var ValidationError = class extends Error {
14027	constructor(errors) {
14028	super("validation failed");
14029	this.errors = errors;
14030	this.ajv = this.validation = true;
14031	}
14032	};
14033	exports.default = ValidationError;
14034	}));
14035
14036	//#endregion
14037	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/ref_error.js
14038	var require_ref_error = /* @__PURE__ */ __commonJSMin(((exports) => {
14039	Object.defineProperty(exports, "__esModule", { value: true });
14040	var resolve_1 = require_resolve();
14041	var MissingRefError = class extends Error {
14042	constructor(resolver, baseId, ref, msg) {
14043	super(msg \|\| `can't resolve reference ${ref} from id ${baseId}`);
14044	this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
14045	this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef));
14046	}
14047	};
14048	exports.default = MissingRefError;
14049	}));
14050
14051	//#endregion
14052	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/index.js
14053	var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
14054	Object.defineProperty(exports, "__esModule", { value: true });
14055	exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
14056	var codegen_1 = require_codegen();
14057	var validation_error_1 = require_validation_error();
14058	var names_1 = require_names();
14059	var resolve_1 = require_resolve();
14060	var util_1 = require_util();
14061	var validate_1 = require_validate();
14062	var SchemaEnv = class {
14063	constructor(env) {
14064	var _a;
14065	this.refs = {};
14066	this.dynamicAnchors = {};
14067	let schema;
14068	if (typeof env.schema == "object") schema = env.schema;
14069	this.schema = env.schema;
14070	this.schemaId = env.schemaId;
14071	this.root = env.root \|\| this;
14072	this.baseId = (_a = env.baseId) !== null && _a !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null \|\| schema === void 0 ? void 0 : schema[env.schemaId \|\| "$id"]);
14073	this.schemaPath = env.schemaPath;
14074	this.localRefs = env.localRefs;
14075	this.meta = env.meta;
14076	this.$async = schema === null \|\| schema === void 0 ? void 0 : schema.$async;
14077	this.refs = {};
14078	}
14079	};
14080	exports.SchemaEnv = SchemaEnv;
14081	function compileSchema(sch) {
14082	const _sch = getCompilingSchema.call(this, sch);
14083	if (_sch) return _sch;
14084	const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId);
14085	const { es5, lines } = this.opts.code;
14086	const { ownProperties } = this.opts;
14087	const gen = new codegen_1.CodeGen(this.scope, {
14088	es5,
14089	lines,
14090	ownProperties
14091	});
14092	let _ValidationError;
14093	if (sch.$async) _ValidationError = gen.scopeValue("Error", {
14094	ref: validation_error_1.default,
14095	code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default`
14096	});
14097	const validateName = gen.scopeName("validate");
14098	sch.validateName = validateName;
14099	const schemaCxt = {
14100	gen,
14101	allErrors: this.opts.allErrors,
14102	data: names_1.default.data,
14103	parentData: names_1.default.parentData,
14104	parentDataProperty: names_1.default.parentDataProperty,
14105	dataNames: [names_1.default.data],
14106	dataPathArr: [codegen_1.nil],
14107	dataLevel: 0,
14108	dataTypes: [],
14109	definedProperties: /* @__PURE__ */ new Set(),
14110	topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? {
14111	ref: sch.schema,
14112	code: (0, codegen_1.stringify)(sch.schema)
14113	} : { ref: sch.schema }),
14114	validateName,
14115	ValidationError: _ValidationError,
14116	schema: sch.schema,
14117	schemaEnv: sch,
14118	rootId,
14119	baseId: sch.baseId \|\| rootId,
14120	schemaPath: codegen_1.nil,
14121	errSchemaPath: sch.schemaPath \|\| (this.opts.jtd ? "" : "#"),
14122	errorPath: (0, codegen_1._)`""`,
14123	opts: this.opts,
14124	self: this
14125	};
14126	let sourceCode;
14127	try {
14128	this._compilations.add(sch);
14129	(0, validate_1.validateFunctionCode)(schemaCxt);
14130	gen.optimize(this.opts.code.optimize);
14131	const validateCode = gen.toString();
14132	sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
14133	if (this.opts.code.process) sourceCode = this.opts.code.process(sourceCode, sch);
14134	const validate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode)(this, this.scope.get());
14135	this.scope.value(validateName, { ref: validate });
14136	validate.errors = null;
14137	validate.schema = sch.schema;
14138	validate.schemaEnv = sch;
14139	if (sch.$async) validate.$async = true;
14140	if (this.opts.code.source === true) validate.source = {
14141	validateName,
14142	validateCode,
14143	scopeValues: gen._values
14144	};
14145	if (this.opts.unevaluated) {
14146	const { props, items } = schemaCxt;
14147	validate.evaluated = {
14148	props: props instanceof codegen_1.Name ? void 0 : props,
14149	items: items instanceof codegen_1.Name ? void 0 : items,
14150	dynamicProps: props instanceof codegen_1.Name,
14151	dynamicItems: items instanceof codegen_1.Name
14152	};
14153	if (validate.source) validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
14154	}
14155	sch.validate = validate;
14156	return sch;
14157	} catch (e) {
14158	delete sch.validate;
14159	delete sch.validateName;
14160	if (sourceCode) this.logger.error("Error compiling schema, function code:", sourceCode);
14161	throw e;
14162	} finally {
14163	this._compilations.delete(sch);
14164	}
14165	}
14166	exports.compileSchema = compileSchema;
14167	function resolveRef(root, baseId, ref) {
14168	var _a;
14169	ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
14170	const schOrFunc = root.refs[ref];
14171	if (schOrFunc) return schOrFunc;
14172	let _sch = resolve.call(this, root, ref);
14173	if (_sch === void 0) {
14174	const schema = (_a = root.localRefs) === null \|\| _a === void 0 ? void 0 : _a[ref];
14175	const { schemaId } = this.opts;
14176	if (schema) _sch = new SchemaEnv({
14177	schema,
14178	schemaId,
14179	root,
14180	baseId
14181	});
14182	}
14183	if (_sch === void 0) return;
14184	return root.refs[ref] = inlineOrCompile.call(this, _sch);
14185	}
14186	exports.resolveRef = resolveRef;
14187	function inlineOrCompile(sch) {
14188	if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs)) return sch.schema;
14189	return sch.validate ? sch : compileSchema.call(this, sch);
14190	}
14191	function getCompilingSchema(schEnv) {
14192	for (const sch of this._compilations) if (sameSchemaEnv(sch, schEnv)) return sch;
14193	}
14194	exports.getCompilingSchema = getCompilingSchema;
14195	function sameSchemaEnv(s1, s2) {
14196	return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
14197	}
14198	function resolve(root, ref) {
14199	let sch;
14200	while (typeof (sch = this.refs[ref]) == "string") ref = sch;
14201	return sch \|\| this.schemas[ref] \|\| resolveSchema.call(this, root, ref);
14202	}
14203	function resolveSchema(root, ref) {
14204	const p = this.opts.uriResolver.parse(ref);
14205	const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
14206	let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0);
14207	if (Object.keys(root.schema).length > 0 && refPath === baseId) return getJsonPointer.call(this, p, root);
14208	const id = (0, resolve_1.normalizeId)(refPath);
14209	const schOrRef = this.refs[id] \|\| this.schemas[id];
14210	if (typeof schOrRef == "string") {
14211	const sch = resolveSchema.call(this, root, schOrRef);
14212	if (typeof (sch === null \|\| sch === void 0 ? void 0 : sch.schema) !== "object") return;
14213	return getJsonPointer.call(this, p, sch);
14214	}
14215	if (typeof (schOrRef === null \|\| schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object") return;
14216	if (!schOrRef.validate) compileSchema.call(this, schOrRef);
14217	if (id === (0, resolve_1.normalizeId)(ref)) {
14218	const { schema } = schOrRef;
14219	const { schemaId } = this.opts;
14220	const schId = schema[schemaId];
14221	if (schId) baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
14222	return new SchemaEnv({
14223	schema,
14224	schemaId,
14225	root,
14226	baseId
14227	});
14228	}
14229	return getJsonPointer.call(this, p, schOrRef);
14230	}
14231	exports.resolveSchema = resolveSchema;
14232	var PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([
14233	"properties",
14234	"patternProperties",
14235	"enum",
14236	"dependencies",
14237	"definitions"
14238	]);
14239	function getJsonPointer(parsedRef, { baseId, schema, root }) {
14240	var _a;
14241	if (((_a = parsedRef.fragment) === null \|\| _a === void 0 ? void 0 : _a[0]) !== "/") return;
14242	for (const part of parsedRef.fragment.slice(1).split("/")) {
14243	if (typeof schema === "boolean") return;
14244	const partSchema = schema[(0, util_1.unescapeFragment)(part)];
14245	if (partSchema === void 0) return;
14246	schema = partSchema;
14247	const schId = typeof schema === "object" && schema[this.opts.schemaId];
14248	if (!PREVENT_SCOPE_CHANGE.has(part) && schId) baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
14249	}
14250	let env;
14251	if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
14252	const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
14253	env = resolveSchema.call(this, root, $ref);
14254	}
14255	const { schemaId } = this.opts;
14256	env = env \|\| new SchemaEnv({
14257	schema,
14258	schemaId,
14259	root,
14260	baseId
14261	});
14262	if (env.schema !== env.root.schema) return env;
14263	}
14264	}));
14265
14266	//#endregion
14267	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/refs/data.json
14268	var data_exports = /* @__PURE__ */ __exportAll({
14269	$id: () => $id$1,
14270	additionalProperties: () => false,
14271	default: () => data_default,
14272	description: () => description,
14273	properties: () => properties$1,
14274	required: () => required,
14275	type: () => type$1
14276	});
14277	var $id$1, description, type$1, required, properties$1, additionalProperties, data_default;
14278	var init_data = __esmMin((() => {
14279	$id$1 = "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#";
14280	description = "Meta-schema for $data reference (JSON AnySchema extension proposal)";
14281	type$1 = "object";
14282	required = ["$data"];
14283	properties$1 = { "$data": {
14284	"type": "string",
14285	"anyOf": [{ "format": "relative-json-pointer" }, { "format": "json-pointer" }]
14286	} };
14287	additionalProperties = false;
14288	data_default = {
14289	$id: $id$1,
14290	description,
14291	type: type$1,
14292	required,
14293	properties: properties$1,
14294	additionalProperties: false
14295	};
14296	}));
14297
14298	//#endregion
14299	//#region node_modules/fast-uri/lib/utils.js
14300	var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
14301	/** @type {(value: string) => boolean} */
14302	var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
14303	/** @type {(value: string) => boolean} */
14304	var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]\|2[0-4]\d\|1\d{2}\|[1-9]\d\|\d)\.){3}(?:25[0-5]\|2[0-4]\d\|1\d{2}\|[1-9]\d\|\d)$/u);
14305	/**
14306	* @param {Array<string>} input
14307	* @returns {string}
14308	*/
14309	function stringArrayToHexStripped(input) {
14310	let acc = "";
14311	let code = 0;
14312	let i = 0;
14313	for (i = 0; i < input.length; i++) {
14314	code = input[i].charCodeAt(0);
14315	if (code === 48) continue;
14316	if (!(code >= 48 && code <= 57 \|\| code >= 65 && code <= 70 \|\| code >= 97 && code <= 102)) return "";
14317	acc += input[i];
14318	break;
14319	}
14320	for (i += 1; i < input.length; i++) {
14321	code = input[i].charCodeAt(0);
14322	if (!(code >= 48 && code <= 57 \|\| code >= 65 && code <= 70 \|\| code >= 97 && code <= 102)) return "";
14323	acc += input[i];
14324	}
14325	return acc;
14326	}
14327	/**
14328	* @typedef {Object} GetIPV6Result
14329	* @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
14330	* @property {string} address - The parsed IPv6 address.
14331	* @property {string} [zone] - The zone identifier, if present.
14332	*/
14333	/**
14334	* @param {string} value
14335	* @returns {boolean}
14336	*/
14337	var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
14338	/**
14339	* @param {Array<string>} buffer
14340	* @returns {boolean}
14341	*/
14342	function consumeIsZone(buffer) {
14343	buffer.length = 0;
14344	return true;
14345	}
14346	/**
14347	* @param {Array<string>} buffer
14348	* @param {Array<string>} address
14349	* @param {GetIPV6Result} output
14350	* @returns {boolean}
14351	*/
14352	function consumeHextets(buffer, address, output) {
14353	if (buffer.length) {
14354	const hex = stringArrayToHexStripped(buffer);
14355	if (hex !== "") address.push(hex);
14356	else {
14357	output.error = true;
14358	return false;
14359	}
14360	buffer.length = 0;
14361	}
14362	return true;
14363	}
14364	/**
14365	* @param {string} input
14366	* @returns {GetIPV6Result}
14367	*/
14368	function getIPV6(input) {
14369	let tokenCount = 0;
14370	const output = {
14371	error: false,
14372	address: "",
14373	zone: ""
14374	};
14375	/** @type {Array<string>} */
14376	const address = [];
14377	/** @type {Array<string>} */
14378	const buffer = [];
14379	let endipv6Encountered = false;
14380	let endIpv6 = false;
14381	let consume = consumeHextets;
14382	for (let i = 0; i < input.length; i++) {
14383	const cursor = input[i];
14384	if (cursor === "[" \|\| cursor === "]") continue;
14385	if (cursor === ":") {
14386	if (endipv6Encountered === true) endIpv6 = true;
14387	if (!consume(buffer, address, output)) break;
14388	if (++tokenCount > 7) {
14389	output.error = true;
14390	break;
14391	}
14392	if (i > 0 && input[i - 1] === ":") endipv6Encountered = true;
14393	address.push(":");
14394	continue;
14395	} else if (cursor === "%") {
14396	if (!consume(buffer, address, output)) break;
14397	consume = consumeIsZone;
14398	} else {
14399	buffer.push(cursor);
14400	continue;
14401	}
14402	}
14403	if (buffer.length) if (consume === consumeIsZone) output.zone = buffer.join("");
14404	else if (endIpv6) address.push(buffer.join(""));
14405	else address.push(stringArrayToHexStripped(buffer));
14406	output.address = address.join("");
14407	return output;
14408	}
14409	/**
14410	* @typedef {Object} NormalizeIPv6Result
14411	* @property {string} host - The normalized host.
14412	* @property {string} [escapedHost] - The escaped host.
14413	* @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
14414	*/
14415	/**
14416	* @param {string} host
14417	* @returns {NormalizeIPv6Result}
14418	*/
14419	function normalizeIPv6(host) {
14420	if (findToken(host, ":") < 2) return {
14421	host,
14422	isIPV6: false
14423	};
14424	const ipv6 = getIPV6(host);
14425	if (!ipv6.error) {
14426	let newHost = ipv6.address;
14427	let escapedHost = ipv6.address;
14428	if (ipv6.zone) {
14429	newHost += "%" + ipv6.zone;
14430	escapedHost += "%25" + ipv6.zone;
14431	}
14432	return {
14433	host: newHost,
14434	isIPV6: true,
14435	escapedHost
14436	};
14437	} else return {
14438	host,
14439	isIPV6: false
14440	};
14441	}
14442	/**
14443	* @param {string} str
14444	* @param {string} token
14445	* @returns {number}
14446	*/
14447	function findToken(str, token) {
14448	let ind = 0;
14449	for (let i = 0; i < str.length; i++) if (str[i] === token) ind++;
14450	return ind;
14451	}
14452	/**
14453	* @param {string} path
14454	* @returns {string}
14455	*
14456	* @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
14457	*/
14458	function removeDotSegments(path) {
14459	let input = path;
14460	const output = [];
14461	let nextSlash = -1;
14462	let len = 0;
14463	while (len = input.length) {
14464	if (len === 1) if (input === ".") break;
14465	else if (input === "/") {
14466	output.push("/");
14467	break;
14468	} else {
14469	output.push(input);
14470	break;
14471	}
14472	else if (len === 2) {
14473	if (input[0] === ".") {
14474	if (input[1] === ".") break;
14475	else if (input[1] === "/") {
14476	input = input.slice(2);
14477	continue;
14478	}
14479	} else if (input[0] === "/") {
14480	if (input[1] === "." \|\| input[1] === "/") {
14481	output.push("/");
14482	break;
14483	}
14484	}
14485	} else if (len === 3) {
14486	if (input === "/..") {
14487	if (output.length !== 0) output.pop();
14488	output.push("/");
14489	break;
14490	}
14491	}
14492	if (input[0] === ".") {
14493	if (input[1] === ".") {
14494	if (input[2] === "/") {
14495	input = input.slice(3);
14496	continue;
14497	}
14498	} else if (input[1] === "/") {
14499	input = input.slice(2);
14500	continue;
14501	}
14502	} else if (input[0] === "/") {
14503	if (input[1] === ".") {
14504	if (input[2] === "/") {
14505	input = input.slice(2);
14506	continue;
14507	} else if (input[2] === ".") {
14508	if (input[3] === "/") {
14509	input = input.slice(3);
14510	if (output.length !== 0) output.pop();
14511	continue;
14512	}
14513	}
14514	}
14515	}
14516	if ((nextSlash = input.indexOf("/", 1)) === -1) {
14517	output.push(input);
14518	break;
14519	} else {
14520	output.push(input.slice(0, nextSlash));
14521	input = input.slice(nextSlash);
14522	}
14523	}
14524	return output.join("");
14525	}
14526	/**
14527	* @param {import('../types/index').URIComponent} component
14528	* @param {boolean} esc
14529	* @returns {import('../types/index').URIComponent}
14530	*/
14531	function normalizeComponentEncoding(component, esc) {
14532	const func = esc !== true ? escape : unescape;
14533	if (component.scheme !== void 0) component.scheme = func(component.scheme);
14534	if (component.userinfo !== void 0) component.userinfo = func(component.userinfo);
14535	if (component.host !== void 0) component.host = func(component.host);
14536	if (component.path !== void 0) component.path = func(component.path);
14537	if (component.query !== void 0) component.query = func(component.query);
14538	if (component.fragment !== void 0) component.fragment = func(component.fragment);
14539	return component;
14540	}
14541	/**
14542	* @param {import('../types/index').URIComponent} component
14543	* @returns {string\|undefined}
14544	*/
14545	function recomposeAuthority(component) {
14546	const uriTokens = [];
14547	if (component.userinfo !== void 0) {
14548	uriTokens.push(component.userinfo);
14549	uriTokens.push("@");
14550	}
14551	if (component.host !== void 0) {
14552	let host = unescape(component.host);
14553	if (!isIPv4(host)) {
14554	const ipV6res = normalizeIPv6(host);
14555	if (ipV6res.isIPV6 === true) host = `[${ipV6res.escapedHost}]`;
14556	else host = component.host;
14557	}
14558	uriTokens.push(host);
14559	}
14560	if (typeof component.port === "number" \|\| typeof component.port === "string") {
14561	uriTokens.push(":");
14562	uriTokens.push(String(component.port));
14563	}
14564	return uriTokens.length ? uriTokens.join("") : void 0;
14565	}
14566	module.exports = {
14567	nonSimpleDomain,
14568	recomposeAuthority,
14569	normalizeComponentEncoding,
14570	removeDotSegments,
14571	isIPv4,
14572	isUUID,
14573	normalizeIPv6,
14574	stringArrayToHexStripped
14575	};
14576	}));
14577
14578	//#endregion
14579	//#region node_modules/fast-uri/lib/schemes.js
14580	var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
14581	var { isUUID } = require_utils();
14582	var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]\|%[\da-f]{2})+)/iu;
14583	var supportedSchemeNames = [
14584	"http",
14585	"https",
14586	"ws",
14587	"wss",
14588	"urn",
14589	"urn:uuid"
14590	];
14591	/** @typedef {supportedSchemeNames[number]} SchemeName */
14592	/**
14593	* @param {string} name
14594	* @returns {name is SchemeName}
14595	*/
14596	function isValidSchemeName(name) {
14597	return supportedSchemeNames.indexOf(name) !== -1;
14598	}
14599	/**
14600	* @callback SchemeFn
14601	* @param {import('../types/index').URIComponent} component
14602	* @param {import('../types/index').Options} options
14603	* @returns {import('../types/index').URIComponent}
14604	*/
14605	/**
14606	* @typedef {Object} SchemeHandler
14607	* @property {SchemeName} scheme - The scheme name.
14608	* @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.
14609	* @property {SchemeFn} parse - Function to parse the URI component for this scheme.
14610	* @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.
14611	* @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.
14612	* @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.
14613	* @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.
14614	*/
14615	/**
14616	* @param {import('../types/index').URIComponent} wsComponent
14617	* @returns {boolean}
14618	*/
14619	function wsIsSecure(wsComponent) {
14620	if (wsComponent.secure === true) return true;
14621	else if (wsComponent.secure === false) return false;
14622	else if (wsComponent.scheme) return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" \|\| wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" \|\| wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" \|\| wsComponent.scheme[2] === "S");
14623	else return false;
14624	}
14625	/** @type {SchemeFn} */
14626	function httpParse(component) {
14627	if (!component.host) component.error = component.error \|\| "HTTP URIs must have a host.";
14628	return component;
14629	}
14630	/** @type {SchemeFn} */
14631	function httpSerialize(component) {
14632	const secure = String(component.scheme).toLowerCase() === "https";
14633	if (component.port === (secure ? 443 : 80) \|\| component.port === "") component.port = void 0;
14634	if (!component.path) component.path = "/";
14635	return component;
14636	}
14637	/** @type {SchemeFn} */
14638	function wsParse(wsComponent) {
14639	wsComponent.secure = wsIsSecure(wsComponent);
14640	wsComponent.resourceName = (wsComponent.path \|\| "/") + (wsComponent.query ? "?" + wsComponent.query : "");
14641	wsComponent.path = void 0;
14642	wsComponent.query = void 0;
14643	return wsComponent;
14644	}
14645	/** @type {SchemeFn} */
14646	function wsSerialize(wsComponent) {
14647	if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) \|\| wsComponent.port === "") wsComponent.port = void 0;
14648	if (typeof wsComponent.secure === "boolean") {
14649	wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
14650	wsComponent.secure = void 0;
14651	}
14652	if (wsComponent.resourceName) {
14653	const [path, query] = wsComponent.resourceName.split("?");
14654	wsComponent.path = path && path !== "/" ? path : void 0;
14655	wsComponent.query = query;
14656	wsComponent.resourceName = void 0;
14657	}
14658	wsComponent.fragment = void 0;
14659	return wsComponent;
14660	}
14661	/** @type {SchemeFn} */
14662	function urnParse(urnComponent, options) {
14663	if (!urnComponent.path) {
14664	urnComponent.error = "URN can not be parsed";
14665	return urnComponent;
14666	}
14667	const matches = urnComponent.path.match(URN_REG);
14668	if (matches) {
14669	const scheme = options.scheme \|\| urnComponent.scheme \|\| "urn";
14670	urnComponent.nid = matches[1].toLowerCase();
14671	urnComponent.nss = matches[2];
14672	const schemeHandler = getSchemeHandler(`${scheme}:${options.nid \|\| urnComponent.nid}`);
14673	urnComponent.path = void 0;
14674	if (schemeHandler) urnComponent = schemeHandler.parse(urnComponent, options);
14675	} else urnComponent.error = urnComponent.error \|\| "URN can not be parsed.";
14676	return urnComponent;
14677	}
14678	/** @type {SchemeFn} */
14679	function urnSerialize(urnComponent, options) {
14680	if (urnComponent.nid === void 0) throw new Error("URN without nid cannot be serialized");
14681	const scheme = options.scheme \|\| urnComponent.scheme \|\| "urn";
14682	const nid = urnComponent.nid.toLowerCase();
14683	const schemeHandler = getSchemeHandler(`${scheme}:${options.nid \|\| nid}`);
14684	if (schemeHandler) urnComponent = schemeHandler.serialize(urnComponent, options);
14685	const uriComponent = urnComponent;
14686	const nss = urnComponent.nss;
14687	uriComponent.path = `${nid \|\| options.nid}:${nss}`;
14688	options.skipEscape = true;
14689	return uriComponent;
14690	}
14691	/** @type {SchemeFn} */
14692	function urnuuidParse(urnComponent, options) {
14693	const uuidComponent = urnComponent;
14694	uuidComponent.uuid = uuidComponent.nss;
14695	uuidComponent.nss = void 0;
14696	if (!options.tolerant && (!uuidComponent.uuid \|\| !isUUID(uuidComponent.uuid))) uuidComponent.error = uuidComponent.error \|\| "UUID is not valid.";
14697	return uuidComponent;
14698	}
14699	/** @type {SchemeFn} */
14700	function urnuuidSerialize(uuidComponent) {
14701	const urnComponent = uuidComponent;
14702	urnComponent.nss = (uuidComponent.uuid \|\| "").toLowerCase();
14703	return urnComponent;
14704	}
14705	var http = {
14706	scheme: "http",
14707	domainHost: true,
14708	parse: httpParse,
14709	serialize: httpSerialize
14710	};
14711	var https = {
14712	scheme: "https",
14713	domainHost: http.domainHost,
14714	parse: httpParse,
14715	serialize: httpSerialize
14716	};
14717	var ws = {
14718	scheme: "ws",
14719	domainHost: true,
14720	parse: wsParse,
14721	serialize: wsSerialize
14722	};
14723	var SCHEMES = {
14724	http,
14725	https,
14726	ws,
14727	wss: {
14728	scheme: "wss",
14729	domainHost: ws.domainHost,
14730	parse: ws.parse,
14731	serialize: ws.serialize
14732	},
14733	urn: {
14734	scheme: "urn",
14735	parse: urnParse,
14736	serialize: urnSerialize,
14737	skipNormalize: true
14738	},
14739	"urn:uuid": {
14740	scheme: "urn:uuid",
14741	parse: urnuuidParse,
14742	serialize: urnuuidSerialize,
14743	skipNormalize: true
14744	}
14745	};
14746	Object.setPrototypeOf(SCHEMES, null);
14747	/**
14748	* @param {string\|undefined} scheme
14749	* @returns {SchemeHandler\|undefined}
14750	*/
14751	function getSchemeHandler(scheme) {
14752	return scheme && (SCHEMES[scheme] \|\| SCHEMES[scheme.toLowerCase()]) \|\| void 0;
14753	}
14754	module.exports = {
14755	wsIsSecure,
14756	SCHEMES,
14757	isValidSchemeName,
14758	getSchemeHandler
14759	};
14760	}));
14761
14762	//#endregion
14763	//#region node_modules/fast-uri/index.js
14764	var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
14765	var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
14766	var { SCHEMES, getSchemeHandler } = require_schemes();
14767	/**
14768	* @template {import('./types/index').URIComponent\|string} T
14769	* @param {T} uri
14770	* @param {import('./types/index').Options} [options]
14771	* @returns {T}
14772	*/
14773	function normalize(uri, options) {
14774	if (typeof uri === "string") uri = serialize(parse(uri, options), options);
14775	else if (typeof uri === "object") uri = parse(serialize(uri, options), options);
14776	return uri;
14777	}
14778	/**
14779	* @param {string} baseURI
14780	* @param {string} relativeURI
14781	* @param {import('./types/index').Options} [options]
14782	* @returns {string}
14783	*/
14784	function resolve(baseURI, relativeURI, options) {
14785	const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
14786	const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
14787	schemelessOptions.skipEscape = true;
14788	return serialize(resolved, schemelessOptions);
14789	}
14790	/**
14791	* @param {import ('./types/index').URIComponent} base
14792	* @param {import ('./types/index').URIComponent} relative
14793	* @param {import('./types/index').Options} [options]
14794	* @param {boolean} [skipNormalization=false]
14795	* @returns {import ('./types/index').URIComponent}
14796	*/
14797	function resolveComponent(base, relative, options, skipNormalization) {
14798	/** @type {import('./types/index').URIComponent} */
14799	const target = {};
14800	if (!skipNormalization) {
14801	base = parse(serialize(base, options), options);
14802	relative = parse(serialize(relative, options), options);
14803	}
14804	options = options \|\| {};
14805	if (!options.tolerant && relative.scheme) {
14806	target.scheme = relative.scheme;
14807	target.userinfo = relative.userinfo;
14808	target.host = relative.host;
14809	target.port = relative.port;
14810	target.path = removeDotSegments(relative.path \|\| "");
14811	target.query = relative.query;
14812	} else {
14813	if (relative.userinfo !== void 0 \|\| relative.host !== void 0 \|\| relative.port !== void 0) {
14814	target.userinfo = relative.userinfo;
14815	target.host = relative.host;
14816	target.port = relative.port;
14817	target.path = removeDotSegments(relative.path \|\| "");
14818	target.query = relative.query;
14819	} else {
14820	if (!relative.path) {
14821	target.path = base.path;
14822	if (relative.query !== void 0) target.query = relative.query;
14823	else target.query = base.query;
14824	} else {
14825	if (relative.path[0] === "/") target.path = removeDotSegments(relative.path);
14826	else {
14827	if ((base.userinfo !== void 0 \|\| base.host !== void 0 \|\| base.port !== void 0) && !base.path) target.path = "/" + relative.path;
14828	else if (!base.path) target.path = relative.path;
14829	else target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
14830	target.path = removeDotSegments(target.path);
14831	}
14832	target.query = relative.query;
14833	}
14834	target.userinfo = base.userinfo;
14835	target.host = base.host;
14836	target.port = base.port;
14837	}
14838	target.scheme = base.scheme;
14839	}
14840	target.fragment = relative.fragment;
14841	return target;
14842	}
14843	/**
14844	* @param {import ('./types/index').URIComponent\|string} uriA
14845	* @param {import ('./types/index').URIComponent\|string} uriB
14846	* @param {import ('./types/index').Options} options
14847	* @returns {boolean}
14848	*/
14849	function equal(uriA, uriB, options) {
14850	if (typeof uriA === "string") {
14851	uriA = unescape(uriA);
14852	uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), {
14853	...options,
14854	skipEscape: true
14855	});
14856	} else if (typeof uriA === "object") uriA = serialize(normalizeComponentEncoding(uriA, true), {
14857	...options,
14858	skipEscape: true
14859	});
14860	if (typeof uriB === "string") {
14861	uriB = unescape(uriB);
14862	uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), {
14863	...options,
14864	skipEscape: true
14865	});
14866	} else if (typeof uriB === "object") uriB = serialize(normalizeComponentEncoding(uriB, true), {
14867	...options,
14868	skipEscape: true
14869	});
14870	return uriA.toLowerCase() === uriB.toLowerCase();
14871	}
14872	/**
14873	* @param {Readonly<import('./types/index').URIComponent>} cmpts
14874	* @param {import('./types/index').Options} [opts]
14875	* @returns {string}
14876	*/
14877	function serialize(cmpts, opts) {
14878	const component = {
14879	host: cmpts.host,
14880	scheme: cmpts.scheme,
14881	userinfo: cmpts.userinfo,
14882	port: cmpts.port,
14883	path: cmpts.path,
14884	query: cmpts.query,
14885	nid: cmpts.nid,
14886	nss: cmpts.nss,
14887	uuid: cmpts.uuid,
14888	fragment: cmpts.fragment,
14889	reference: cmpts.reference,
14890	resourceName: cmpts.resourceName,
14891	secure: cmpts.secure,
14892	error: ""
14893	};
14894	const options = Object.assign({}, opts);
14895	const uriTokens = [];
14896	const schemeHandler = getSchemeHandler(options.scheme \|\| component.scheme);
14897	if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
14898	if (component.path !== void 0) if (!options.skipEscape) {
14899	component.path = escape(component.path);
14900	if (component.scheme !== void 0) component.path = component.path.split("%3A").join(":");
14901	} else component.path = unescape(component.path);
14902	if (options.reference !== "suffix" && component.scheme) uriTokens.push(component.scheme, ":");
14903	const authority = recomposeAuthority(component);
14904	if (authority !== void 0) {
14905	if (options.reference !== "suffix") uriTokens.push("//");
14906	uriTokens.push(authority);
14907	if (component.path && component.path[0] !== "/") uriTokens.push("/");
14908	}
14909	if (component.path !== void 0) {
14910	let s = component.path;
14911	if (!options.absolutePath && (!schemeHandler \|\| !schemeHandler.absolutePath)) s = removeDotSegments(s);
14912	if (authority === void 0 && s[0] === "/" && s[1] === "/") s = "/%2F" + s.slice(2);
14913	uriTokens.push(s);
14914	}
14915	if (component.query !== void 0) uriTokens.push("?", component.query);
14916	if (component.fragment !== void 0) uriTokens.push("#", component.fragment);
14917	return uriTokens.join("");
14918	}
14919	var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@])@)?(\[[^#/?\]]+\]\|[^#/:?])(?::(\d))?))?([^#?])(?:\?([^#]))?(?:#((?:.\|[\n\r])))?/u;
14920	/**
14921	* @param {string} uri
14922	* @param {import('./types/index').Options} [opts]
14923	* @returns
14924	*/
14925	function parse(uri, opts) {
14926	const options = Object.assign({}, opts);
14927	/** @type {import('./types/index').URIComponent} */
14928	const parsed = {
14929	scheme: void 0,
14930	userinfo: void 0,
14931	host: "",
14932	port: void 0,
14933	path: "",
14934	query: void 0,
14935	fragment: void 0
14936	};
14937	let isIP = false;
14938	if (options.reference === "suffix") if (options.scheme) uri = options.scheme + ":" + uri;
14939	else uri = "//" + uri;
14940	const matches = uri.match(URI_PARSE);
14941	if (matches) {
14942	parsed.scheme = matches[1];
14943	parsed.userinfo = matches[3];
14944	parsed.host = matches[4];
14945	parsed.port = parseInt(matches[5], 10);
14946	parsed.path = matches[6] \|\| "";
14947	parsed.query = matches[7];
14948	parsed.fragment = matches[8];
14949	if (isNaN(parsed.port)) parsed.port = matches[5];
14950	if (parsed.host) if (isIPv4(parsed.host) === false) {
14951	const ipv6result = normalizeIPv6(parsed.host);
14952	parsed.host = ipv6result.host.toLowerCase();
14953	isIP = ipv6result.isIPV6;
14954	} else isIP = true;
14955	if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) parsed.reference = "same-document";
14956	else if (parsed.scheme === void 0) parsed.reference = "relative";
14957	else if (parsed.fragment === void 0) parsed.reference = "absolute";
14958	else parsed.reference = "uri";
14959	if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) parsed.error = parsed.error \|\| "URI is not a " + options.reference + " reference.";
14960	const schemeHandler = getSchemeHandler(options.scheme \|\| parsed.scheme);
14961	if (!options.unicodeSupport && (!schemeHandler \|\| !schemeHandler.unicodeSupport)) {
14962	if (parsed.host && (options.domainHost \|\| schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) try {
14963	parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
14964	} catch (e) {
14965	parsed.error = parsed.error \|\| "Host's domain name can not be converted to ASCII: " + e;
14966	}
14967	}
14968	if (!schemeHandler \|\| schemeHandler && !schemeHandler.skipNormalize) {
14969	if (uri.indexOf("%") !== -1) {
14970	if (parsed.scheme !== void 0) parsed.scheme = unescape(parsed.scheme);
14971	if (parsed.host !== void 0) parsed.host = unescape(parsed.host);
14972	}
14973	if (parsed.path) parsed.path = escape(unescape(parsed.path));
14974	if (parsed.fragment) parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
14975	}
14976	if (schemeHandler && schemeHandler.parse) schemeHandler.parse(parsed, options);
14977	} else parsed.error = parsed.error \|\| "URI can not be parsed.";
14978	return parsed;
14979	}
14980	var fastUri = {
14981	SCHEMES,
14982	normalize,
14983	resolve,
14984	resolveComponent,
14985	equal,
14986	serialize,
14987	parse
14988	};
14989	module.exports = fastUri;
14990	module.exports.default = fastUri;
14991	module.exports.fastUri = fastUri;
14992	}));
14993
14994	//#endregion
14995	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/runtime/uri.js
14996	var require_uri = /* @__PURE__ */ __commonJSMin(((exports) => {
14997	Object.defineProperty(exports, "__esModule", { value: true });
14998	var uri = require_fast_uri();
14999	uri.code = "require(\"ajv/dist/runtime/uri\").default";
15000	exports.default = uri;
15001	}));
15002
15003	//#endregion
15004	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/core.js
15005	var require_core$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
15006	Object.defineProperty(exports, "__esModule", { value: true });
15007	exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
15008	var validate_1 = require_validate();
15009	Object.defineProperty(exports, "KeywordCxt", {
15010	enumerable: true,
15011	get: function() {
15012	return validate_1.KeywordCxt;
15013	}
15014	});
15015	var codegen_1 = require_codegen();
15016	Object.defineProperty(exports, "_", {
15017	enumerable: true,
15018	get: function() {
15019	return codegen_1._;
15020	}
15021	});
15022	Object.defineProperty(exports, "str", {
15023	enumerable: true,
15024	get: function() {
15025	return codegen_1.str;
15026	}
15027	});
15028	Object.defineProperty(exports, "stringify", {
15029	enumerable: true,
15030	get: function() {
15031	return codegen_1.stringify;
15032	}
15033	});
15034	Object.defineProperty(exports, "nil", {
15035	enumerable: true,
15036	get: function() {
15037	return codegen_1.nil;
15038	}
15039	});
15040	Object.defineProperty(exports, "Name", {
15041	enumerable: true,
15042	get: function() {
15043	return codegen_1.Name;
15044	}
15045	});
15046	Object.defineProperty(exports, "CodeGen", {
15047	enumerable: true,
15048	get: function() {
15049	return codegen_1.CodeGen;
15050	}
15051	});
15052	var validation_error_1 = require_validation_error();
15053	var ref_error_1 = require_ref_error();
15054	var rules_1 = require_rules();
15055	var compile_1 = require_compile();
15056	var codegen_2 = require_codegen();
15057	var resolve_1 = require_resolve();
15058	var dataType_1 = require_dataType();
15059	var util_1 = require_util();
15060	var $dataRefSchema = (init_data(), __toCommonJS(data_exports).default);
15061	var uri_1 = require_uri();
15062	var defaultRegExp = (str, flags) => new RegExp(str, flags);
15063	defaultRegExp.code = "new RegExp";
15064	var META_IGNORE_OPTIONS = [
15065	"removeAdditional",
15066	"useDefaults",
15067	"coerceTypes"
15068	];
15069	var EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
15070	"validate",
15071	"serialize",
15072	"parse",
15073	"wrapper",
15074	"root",
15075	"schema",
15076	"keyword",
15077	"pattern",
15078	"formats",
15079	"validate$data",
15080	"func",
15081	"obj",
15082	"Error"
15083	]);
15084	var removedOptions = {
15085	errorDataPath: "",
15086	format: "`validateFormats: false` can be used instead.",
15087	nullable: "\"nullable\" keyword is supported by default.",
15088	jsonPointers: "Deprecated jsPropertySyntax can be used instead.",
15089	extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.",
15090	missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.",
15091	processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`",
15092	sourceCode: "Use option `code: {source: true}`",
15093	strictDefaults: "It is default now, see option `strict`.",
15094	strictKeywords: "It is default now, see option `strict`.",
15095	uniqueItems: "\"uniqueItems\" keyword is always validated.",
15096	unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",
15097	cache: "Map is used as cache, schema object as key.",
15098	serialize: "Map is used as cache, schema object as key.",
15099	ajvErrors: "It is default now."
15100	};
15101	var deprecatedOptions = {
15102	ignoreKeywordsWithRef: "",
15103	jsPropertySyntax: "",
15104	unicode: "\"minLength\"/\"maxLength\" account for unicode characters by default."
15105	};
15106	var MAX_EXPRESSION = 200;
15107	function requiredOptions(o) {
15108	var _a;
15109	var _b;
15110	var _c;
15111	var _d;
15112	var _e;
15113	var _f;
15114	var _g;
15115	var _h;
15116	var _j;
15117	var _k;
15118	var _l;
15119	var _m;
15120	var _o;
15121	var _p;
15122	var _q;
15123	var _r;
15124	var _s;
15125	var _t;
15126	var _u;
15127	var _v;
15128	var _w;
15129	var _x;
15130	var _y;
15131	var _z;
15132	var _0;
15133	const s = o.strict;
15134	const _optz = (_a = o.code) === null \|\| _a === void 0 ? void 0 : _a.optimize;
15135	const optimize = _optz === true \|\| _optz === void 0 ? 1 : _optz \|\| 0;
15136	const regExp = (_c = (_b = o.code) === null \|\| _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;
15137	const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;
15138	return {
15139	strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,
15140	strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,
15141	strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log",
15142	strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log",
15143	strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,
15144	code: o.code ? {
15145	...o.code,
15146	optimize,
15147	regExp
15148	} : {
15149	optimize,
15150	regExp
15151	},
15152	loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,
15153	loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,
15154	meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,
15155	messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,
15156	inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,
15157	schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",
15158	addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,
15159	validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,
15160	validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,
15161	unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,
15162	int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,
15163	uriResolver
15164	};
15165	}
15166	var Ajv = class {
15167	constructor(opts = {}) {
15168	this.schemas = {};
15169	this.refs = {};
15170	this.formats = {};
15171	this._compilations = /* @__PURE__ */ new Set();
15172	this._loading = {};
15173	this._cache = /* @__PURE__ */ new Map();
15174	opts = this.opts = {
15175	...opts,
15176	...requiredOptions(opts)
15177	};
15178	const { es5, lines } = this.opts.code;
15179	this.scope = new codegen_2.ValueScope({
15180	scope: {},
15181	prefixes: EXT_SCOPE_NAMES,
15182	es5,
15183	lines
15184	});
15185	this.logger = getLogger(opts.logger);
15186	const formatOpt = opts.validateFormats;
15187	opts.validateFormats = false;
15188	this.RULES = (0, rules_1.getRules)();
15189	checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
15190	checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
15191	this._metaOpts = getMetaSchemaOptions.call(this);
15192	if (opts.formats) addInitialFormats.call(this);
15193	this._addVocabularies();
15194	this._addDefaultMetaSchema();
15195	if (opts.keywords) addInitialKeywords.call(this, opts.keywords);
15196	if (typeof opts.meta == "object") this.addMetaSchema(opts.meta);
15197	addInitialSchemas.call(this);
15198	opts.validateFormats = formatOpt;
15199	}
15200	_addVocabularies() {
15201	this.addKeyword("$async");
15202	}
15203	_addDefaultMetaSchema() {
15204	const { $data, meta, schemaId } = this.opts;
15205	let _dataRefSchema = $dataRefSchema;
15206	if (schemaId === "id") {
15207	_dataRefSchema = { ...$dataRefSchema };
15208	_dataRefSchema.id = _dataRefSchema.$id;
15209	delete _dataRefSchema.$id;
15210	}
15211	if (meta && $data) this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
15212	}
15213	defaultMeta() {
15214	const { meta, schemaId } = this.opts;
15215	return this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] \|\| meta : void 0;
15216	}
15217	validate(schemaKeyRef, data) {
15218	let v;
15219	if (typeof schemaKeyRef == "string") {
15220	v = this.getSchema(schemaKeyRef);
15221	if (!v) throw new Error(`no schema with key or ref "${schemaKeyRef}"`);
15222	} else v = this.compile(schemaKeyRef);
15223	const valid = v(data);
15224	if (!("$async" in v)) this.errors = v.errors;
15225	return valid;
15226	}
15227	compile(schema, _meta) {
15228	const sch = this._addSchema(schema, _meta);
15229	return sch.validate \|\| this._compileSchemaEnv(sch);
15230	}
15231	compileAsync(schema, meta) {
15232	if (typeof this.opts.loadSchema != "function") throw new Error("options.loadSchema should be a function");
15233	const { loadSchema } = this.opts;
15234	return runCompileAsync.call(this, schema, meta);
15235	async function runCompileAsync(_schema, _meta) {
15236	await loadMetaSchema.call(this, _schema.$schema);
15237	const sch = this._addSchema(_schema, _meta);
15238	return sch.validate \|\| _compileAsync.call(this, sch);
15239	}
15240	async function loadMetaSchema($ref) {
15241	if ($ref && !this.getSchema($ref)) await runCompileAsync.call(this, { $ref }, true);
15242	}
15243	async function _compileAsync(sch) {
15244	try {
15245	return this._compileSchemaEnv(sch);
15246	} catch (e) {
15247	if (!(e instanceof ref_error_1.default)) throw e;
15248	checkLoaded.call(this, e);
15249	await loadMissingSchema.call(this, e.missingSchema);
15250	return _compileAsync.call(this, sch);
15251	}
15252	}
15253	function checkLoaded({ missingSchema: ref, missingRef }) {
15254	if (this.refs[ref]) throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);
15255	}
15256	async function loadMissingSchema(ref) {
15257	const _schema = await _loadSchema.call(this, ref);
15258	if (!this.refs[ref]) await loadMetaSchema.call(this, _schema.$schema);
15259	if (!this.refs[ref]) this.addSchema(_schema, ref, meta);
15260	}
15261	async function _loadSchema(ref) {
15262	const p = this._loading[ref];
15263	if (p) return p;
15264	try {
15265	return await (this._loading[ref] = loadSchema(ref));
15266	} finally {
15267	delete this._loading[ref];
15268	}
15269	}
15270	}
15271	addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
15272	if (Array.isArray(schema)) {
15273	for (const sch of schema) this.addSchema(sch, void 0, _meta, _validateSchema);
15274	return this;
15275	}
15276	let id;
15277	if (typeof schema === "object") {
15278	const { schemaId } = this.opts;
15279	id = schema[schemaId];
15280	if (id !== void 0 && typeof id != "string") throw new Error(`schema ${schemaId} must be string`);
15281	}
15282	key = (0, resolve_1.normalizeId)(key \|\| id);
15283	this._checkUnique(key);
15284	this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
15285	return this;
15286	}
15287	addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
15288	this.addSchema(schema, key, true, _validateSchema);
15289	return this;
15290	}
15291	validateSchema(schema, throwOrLogError) {
15292	if (typeof schema == "boolean") return true;
15293	let $schema;
15294	$schema = schema.$schema;
15295	if ($schema !== void 0 && typeof $schema != "string") throw new Error("$schema must be a string");
15296	$schema = $schema \|\| this.opts.defaultMeta \|\| this.defaultMeta();
15297	if (!$schema) {
15298	this.logger.warn("meta-schema not available");
15299	this.errors = null;
15300	return true;
15301	}
15302	const valid = this.validate($schema, schema);
15303	if (!valid && throwOrLogError) {
15304	const message = "schema is invalid: " + this.errorsText();
15305	if (this.opts.validateSchema === "log") this.logger.error(message);
15306	else throw new Error(message);
15307	}
15308	return valid;
15309	}
15310	getSchema(keyRef) {
15311	let sch;
15312	while (typeof (sch = getSchEnv.call(this, keyRef)) == "string") keyRef = sch;
15313	if (sch === void 0) {
15314	const { schemaId } = this.opts;
15315	const root = new compile_1.SchemaEnv({
15316	schema: {},
15317	schemaId
15318	});
15319	sch = compile_1.resolveSchema.call(this, root, keyRef);
15320	if (!sch) return;
15321	this.refs[keyRef] = sch;
15322	}
15323	return sch.validate \|\| this._compileSchemaEnv(sch);
15324	}
15325	removeSchema(schemaKeyRef) {
15326	if (schemaKeyRef instanceof RegExp) {
15327	this._removeAllSchemas(this.schemas, schemaKeyRef);
15328	this._removeAllSchemas(this.refs, schemaKeyRef);
15329	return this;
15330	}
15331	switch (typeof schemaKeyRef) {
15332	case "undefined":
15333	this._removeAllSchemas(this.schemas);
15334	this._removeAllSchemas(this.refs);
15335	this._cache.clear();
15336	return this;
15337	case "string": {
15338	const sch = getSchEnv.call(this, schemaKeyRef);
15339	if (typeof sch == "object") this._cache.delete(sch.schema);
15340	delete this.schemas[schemaKeyRef];
15341	delete this.refs[schemaKeyRef];
15342	return this;
15343	}
15344	case "object": {
15345	const cacheKey = schemaKeyRef;
15346	this._cache.delete(cacheKey);
15347	let id = schemaKeyRef[this.opts.schemaId];
15348	if (id) {
15349	id = (0, resolve_1.normalizeId)(id);
15350	delete this.schemas[id];
15351	delete this.refs[id];
15352	}
15353	return this;
15354	}
15355	default: throw new Error("ajv.removeSchema: invalid parameter");
15356	}
15357	}
15358	addVocabulary(definitions) {
15359	for (const def of definitions) this.addKeyword(def);
15360	return this;
15361	}
15362	addKeyword(kwdOrDef, def) {
15363	let keyword;
15364	if (typeof kwdOrDef == "string") {
15365	keyword = kwdOrDef;
15366	if (typeof def == "object") {
15367	this.logger.warn("these parameters are deprecated, see docs for addKeyword");
15368	def.keyword = keyword;
15369	}
15370	} else if (typeof kwdOrDef == "object" && def === void 0) {
15371	def = kwdOrDef;
15372	keyword = def.keyword;
15373	if (Array.isArray(keyword) && !keyword.length) throw new Error("addKeywords: keyword must be string or non-empty array");
15374	} else throw new Error("invalid addKeywords parameters");
15375	checkKeyword.call(this, keyword, def);
15376	if (!def) {
15377	(0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));
15378	return this;
15379	}
15380	keywordMetaschema.call(this, def);
15381	const definition = {
15382	...def,
15383	type: (0, dataType_1.getJSONTypes)(def.type),
15384	schemaType: (0, dataType_1.getJSONTypes)(def.schemaType)
15385	};
15386	(0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));
15387	return this;
15388	}
15389	getKeyword(keyword) {
15390	const rule = this.RULES.all[keyword];
15391	return typeof rule == "object" ? rule.definition : !!rule;
15392	}
15393	removeKeyword(keyword) {
15394	const { RULES } = this;
15395	delete RULES.keywords[keyword];
15396	delete RULES.all[keyword];
15397	for (const group of RULES.rules) {
15398	const i = group.rules.findIndex((rule) => rule.keyword === keyword);
15399	if (i >= 0) group.rules.splice(i, 1);
15400	}
15401	return this;
15402	}
15403	addFormat(name, format) {
15404	if (typeof format == "string") format = new RegExp(format);
15405	this.formats[name] = format;
15406	return this;
15407	}
15408	errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
15409	if (!errors \|\| errors.length === 0) return "No errors";
15410	return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
15411	}
15412	$dataMetaSchema(metaSchema, keywordsJsonPointers) {
15413	const rules = this.RULES.all;
15414	metaSchema = JSON.parse(JSON.stringify(metaSchema));
15415	for (const jsonPointer of keywordsJsonPointers) {
15416	const segments = jsonPointer.split("/").slice(1);
15417	let keywords = metaSchema;
15418	for (const seg of segments) keywords = keywords[seg];
15419	for (const key in rules) {
15420	const rule = rules[key];
15421	if (typeof rule != "object") continue;
15422	const { $data } = rule.definition;
15423	const schema = keywords[key];
15424	if ($data && schema) keywords[key] = schemaOrData(schema);
15425	}
15426	}
15427	return metaSchema;
15428	}
15429	_removeAllSchemas(schemas, regex) {
15430	for (const keyRef in schemas) {
15431	const sch = schemas[keyRef];
15432	if (!regex \|\| regex.test(keyRef)) {
15433	if (typeof sch == "string") delete schemas[keyRef];
15434	else if (sch && !sch.meta) {
15435	this._cache.delete(sch.schema);
15436	delete schemas[keyRef];
15437	}
15438	}
15439	}
15440	}
15441	_addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
15442	let id;
15443	const { schemaId } = this.opts;
15444	if (typeof schema == "object") id = schema[schemaId];
15445	else if (this.opts.jtd) throw new Error("schema must be object");
15446	else if (typeof schema != "boolean") throw new Error("schema must be object or boolean");
15447	let sch = this._cache.get(schema);
15448	if (sch !== void 0) return sch;
15449	baseId = (0, resolve_1.normalizeId)(id \|\| baseId);
15450	const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
15451	sch = new compile_1.SchemaEnv({
15452	schema,
15453	schemaId,
15454	meta,
15455	baseId,
15456	localRefs
15457	});
15458	this._cache.set(sch.schema, sch);
15459	if (addSchema && !baseId.startsWith("#")) {
15460	if (baseId) this._checkUnique(baseId);
15461	this.refs[baseId] = sch;
15462	}
15463	if (validateSchema) this.validateSchema(schema, true);
15464	return sch;
15465	}
15466	_checkUnique(id) {
15467	if (this.schemas[id] \|\| this.refs[id]) throw new Error(`schema with key or id "${id}" already exists`);
15468	}
15469	_compileSchemaEnv(sch) {
15470	if (sch.meta) this._compileMetaSchema(sch);
15471	else compile_1.compileSchema.call(this, sch);
15472	/* istanbul ignore if */
15473	if (!sch.validate) throw new Error("ajv implementation error");
15474	return sch.validate;
15475	}
15476	_compileMetaSchema(sch) {
15477	const currentOpts = this.opts;
15478	this.opts = this._metaOpts;
15479	try {
15480	compile_1.compileSchema.call(this, sch);
15481	} finally {
15482	this.opts = currentOpts;
15483	}
15484	}
15485	};
15486	Ajv.ValidationError = validation_error_1.default;
15487	Ajv.MissingRefError = ref_error_1.default;
15488	exports.default = Ajv;
15489	function checkOptions(checkOpts, options, msg, log = "error") {
15490	for (const key in checkOpts) {
15491	const opt = key;
15492	if (opt in options) this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
15493	}
15494	}
15495	function getSchEnv(keyRef) {
15496	keyRef = (0, resolve_1.normalizeId)(keyRef);
15497	return this.schemas[keyRef] \|\| this.refs[keyRef];
15498	}
15499	function addInitialSchemas() {
15500	const optsSchemas = this.opts.schemas;
15501	if (!optsSchemas) return;
15502	if (Array.isArray(optsSchemas)) this.addSchema(optsSchemas);
15503	else for (const key in optsSchemas) this.addSchema(optsSchemas[key], key);
15504	}
15505	function addInitialFormats() {
15506	for (const name in this.opts.formats) {
15507	const format = this.opts.formats[name];
15508	if (format) this.addFormat(name, format);
15509	}
15510	}
15511	function addInitialKeywords(defs) {
15512	if (Array.isArray(defs)) {
15513	this.addVocabulary(defs);
15514	return;
15515	}
15516	this.logger.warn("keywords option as map is deprecated, pass array");
15517	for (const keyword in defs) {
15518	const def = defs[keyword];
15519	if (!def.keyword) def.keyword = keyword;
15520	this.addKeyword(def);
15521	}
15522	}
15523	function getMetaSchemaOptions() {
15524	const metaOpts = { ...this.opts };
15525	for (const opt of META_IGNORE_OPTIONS) delete metaOpts[opt];
15526	return metaOpts;
15527	}
15528	var noLogs = {
15529	log() {},
15530	warn() {},
15531	error() {}
15532	};
15533	function getLogger(logger) {
15534	if (logger === false) return noLogs;
15535	if (logger === void 0) return console;
15536	if (logger.log && logger.warn && logger.error) return logger;
15537	throw new Error("logger must implement log, warn and error methods");
15538	}
15539	var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
15540	function checkKeyword(keyword, def) {
15541	const { RULES } = this;
15542	(0, util_1.eachItem)(keyword, (kwd) => {
15543	if (RULES.keywords[kwd]) throw new Error(`Keyword ${kwd} is already defined`);
15544	if (!KEYWORD_NAME.test(kwd)) throw new Error(`Keyword ${kwd} has invalid name`);
15545	});
15546	if (!def) return;
15547	if (def.$data && !("code" in def \|\| "validate" in def)) throw new Error("$data keyword must have \"code\" or \"validate\" function");
15548	}
15549	function addRule(keyword, definition, dataType) {
15550	var _a;
15551	const post = definition === null \|\| definition === void 0 ? void 0 : definition.post;
15552	if (dataType && post) throw new Error("keyword with \"post\" flag cannot have \"type\"");
15553	const { RULES } = this;
15554	let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
15555	if (!ruleGroup) {
15556	ruleGroup = {
15557	type: dataType,
15558	rules: []
15559	};
15560	RULES.rules.push(ruleGroup);
15561	}
15562	RULES.keywords[keyword] = true;
15563	if (!definition) return;
15564	const rule = {
15565	keyword,
15566	definition: {
15567	...definition,
15568	type: (0, dataType_1.getJSONTypes)(definition.type),
15569	schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType)
15570	}
15571	};
15572	if (definition.before) addBeforeRule.call(this, ruleGroup, rule, definition.before);
15573	else ruleGroup.rules.push(rule);
15574	RULES.all[keyword] = rule;
15575	(_a = definition.implements) === null \|\| _a === void 0 \|\| _a.forEach((kwd) => this.addKeyword(kwd));
15576	}
15577	function addBeforeRule(ruleGroup, rule, before) {
15578	const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
15579	if (i >= 0) ruleGroup.rules.splice(i, 0, rule);
15580	else {
15581	ruleGroup.rules.push(rule);
15582	this.logger.warn(`rule ${before} is not defined`);
15583	}
15584	}
15585	function keywordMetaschema(def) {
15586	let { metaSchema } = def;
15587	if (metaSchema === void 0) return;
15588	if (def.$data && this.opts.$data) metaSchema = schemaOrData(metaSchema);
15589	def.validateSchema = this.compile(metaSchema, true);
15590	}
15591	var $dataRef = { $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" };
15592	function schemaOrData(schema) {
15593	return { anyOf: [schema, $dataRef] };
15594	}
15595	}));
15596
15597	//#endregion
15598	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/core/id.js
15599	var require_id = /* @__PURE__ */ __commonJSMin(((exports) => {
15600	Object.defineProperty(exports, "__esModule", { value: true });
15601	var def = {
15602	keyword: "id",
15603	code() {
15604	throw new Error("NOT SUPPORTED: keyword \"id\", use \"$id\" for schema ID");
15605	}
15606	};
15607	exports.default = def;
15608	}));
15609
15610	//#endregion
15611	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/core/ref.js
15612	var require_ref = /* @__PURE__ */ __commonJSMin(((exports) => {
15613	Object.defineProperty(exports, "__esModule", { value: true });
15614	exports.callRef = exports.getValidate = void 0;
15615	var ref_error_1 = require_ref_error();
15616	var code_1 = require_code();
15617	var codegen_1 = require_codegen();
15618	var names_1 = require_names();
15619	var compile_1 = require_compile();
15620	var util_1 = require_util();
15621	var def = {
15622	keyword: "$ref",
15623	schemaType: "string",
15624	code(cxt) {
15625	const { gen, schema: $ref, it } = cxt;
15626	const { baseId, schemaEnv: env, validateName, opts, self } = it;
15627	const { root } = env;
15628	if (($ref === "#" \|\| $ref === "#/") && baseId === root.baseId) return callRootRef();
15629	const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
15630	if (schOrEnv === void 0) throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
15631	if (schOrEnv instanceof compile_1.SchemaEnv) return callValidate(schOrEnv);
15632	return inlineRefSchema(schOrEnv);
15633	function callRootRef() {
15634	if (env === root) return callRef(cxt, validateName, env, env.$async);
15635	const rootName = gen.scopeValue("root", { ref: root });
15636	return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async);
15637	}
15638	function callValidate(sch) {
15639	callRef(cxt, getValidate(cxt, sch), sch, sch.$async);
15640	}
15641	function inlineRefSchema(sch) {
15642	const schName = gen.scopeValue("schema", opts.code.source === true ? {
15643	ref: sch,
15644	code: (0, codegen_1.stringify)(sch)
15645	} : { ref: sch });
15646	const valid = gen.name("valid");
15647	const schCxt = cxt.subschema({
15648	schema: sch,
15649	dataTypes: [],
15650	schemaPath: codegen_1.nil,
15651	topSchemaRef: schName,
15652	errSchemaPath: $ref
15653	}, valid);
15654	cxt.mergeEvaluated(schCxt);
15655	cxt.ok(valid);
15656	}
15657	}
15658	};
15659	function getValidate(cxt, sch) {
15660	const { gen } = cxt;
15661	return sch.validate ? gen.scopeValue("validate", { ref: sch.validate }) : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
15662	}
15663	exports.getValidate = getValidate;
15664	function callRef(cxt, v, sch, $async) {
15665	const { gen, it } = cxt;
15666	const { allErrors, schemaEnv: env, opts } = it;
15667	const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
15668	if ($async) callAsyncRef();
15669	else callSyncRef();
15670	function callAsyncRef() {
15671	if (!env.$async) throw new Error("async schema referenced by sync schema");
15672	const valid = gen.let("valid");
15673	gen.try(() => {
15674	gen.code((0, codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);
15675	addEvaluatedFrom(v);
15676	if (!allErrors) gen.assign(valid, true);
15677	}, (e) => {
15678	gen.if((0, codegen_1._)`!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));
15679	addErrorsFrom(e);
15680	if (!allErrors) gen.assign(valid, false);
15681	});
15682	cxt.ok(valid);
15683	}
15684	function callSyncRef() {
15685	cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
15686	}
15687	function addErrorsFrom(source) {
15688	const errs = (0, codegen_1._)`${source}.errors`;
15689	gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`);
15690	gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
15691	}
15692	function addEvaluatedFrom(source) {
15693	var _a;
15694	if (!it.opts.unevaluated) return;
15695	const schEvaluated = (_a = sch === null \|\| sch === void 0 ? void 0 : sch.validate) === null \|\| _a === void 0 ? void 0 : _a.evaluated;
15696	if (it.props !== true) if (schEvaluated && !schEvaluated.dynamicProps) {
15697	if (schEvaluated.props !== void 0) it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
15698	} else {
15699	const props = gen.var("props", (0, codegen_1._)`${source}.evaluated.props`);
15700	it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
15701	}
15702	if (it.items !== true) if (schEvaluated && !schEvaluated.dynamicItems) {
15703	if (schEvaluated.items !== void 0) it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
15704	} else {
15705	const items = gen.var("items", (0, codegen_1._)`${source}.evaluated.items`);
15706	it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);
15707	}
15708	}
15709	}
15710	exports.callRef = callRef;
15711	exports.default = def;
15712	}));
15713
15714	//#endregion
15715	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/core/index.js
15716	var require_core = /* @__PURE__ */ __commonJSMin(((exports) => {
15717	Object.defineProperty(exports, "__esModule", { value: true });
15718	var id_1 = require_id();
15719	var ref_1 = require_ref();
15720	var core = [
15721	"$schema",
15722	"$id",
15723	"$defs",
15724	"$vocabulary",
15725	{ keyword: "$comment" },
15726	"definitions",
15727	id_1.default,
15728	ref_1.default
15729	];
15730	exports.default = core;
15731	}));
15732
15733	//#endregion
15734	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
15735	var require_limitNumber = /* @__PURE__ */ __commonJSMin(((exports) => {
15736	Object.defineProperty(exports, "__esModule", { value: true });
15737	var codegen_1 = require_codegen();
15738	var ops = codegen_1.operators;
15739	var KWDs = {
15740	maximum: {
15741	okStr: "<=",
15742	ok: ops.LTE,
15743	fail: ops.GT
15744	},
15745	minimum: {
15746	okStr: ">=",
15747	ok: ops.GTE,
15748	fail: ops.LT
15749	},
15750	exclusiveMaximum: {
15751	okStr: "<",
15752	ok: ops.LT,
15753	fail: ops.GTE
15754	},
15755	exclusiveMinimum: {
15756	okStr: ">",
15757	ok: ops.GT,
15758	fail: ops.LTE
15759	}
15760	};
15761	var def = {
15762	keyword: Object.keys(KWDs),
15763	type: "number",
15764	schemaType: "number",
15765	$data: true,
15766	error: {
15767	message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
15768	params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
15769	},
15770	code(cxt) {
15771	const { keyword, data, schemaCode } = cxt;
15772	cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} \|\| isNaN(${data})`);
15773	}
15774	};
15775	exports.default = def;
15776	}));
15777
15778	//#endregion
15779	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
15780	var require_multipleOf = /* @__PURE__ */ __commonJSMin(((exports) => {
15781	Object.defineProperty(exports, "__esModule", { value: true });
15782	var codegen_1 = require_codegen();
15783	var def = {
15784	keyword: "multipleOf",
15785	type: "number",
15786	schemaType: "number",
15787	$data: true,
15788	error: {
15789	message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`,
15790	params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`
15791	},
15792	code(cxt) {
15793	const { gen, data, schemaCode, it } = cxt;
15794	const prec = it.opts.multipleOfPrecision;
15795	const res = gen.let("res");
15796	const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
15797	cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 \|\| (${res} = ${data}/${schemaCode}, ${invalid}))`);
15798	}
15799	};
15800	exports.default = def;
15801	}));
15802
15803	//#endregion
15804	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/runtime/ucs2length.js
15805	var require_ucs2length = /* @__PURE__ */ __commonJSMin(((exports) => {
15806	Object.defineProperty(exports, "__esModule", { value: true });
15807	function ucs2length(str) {
15808	const len = str.length;
15809	let length = 0;
15810	let pos = 0;
15811	let value;
15812	while (pos < len) {
15813	length++;
15814	value = str.charCodeAt(pos++);
15815	if (value >= 55296 && value <= 56319 && pos < len) {
15816	value = str.charCodeAt(pos);
15817	if ((value & 64512) === 56320) pos++;
15818	}
15819	}
15820	return length;
15821	}
15822	exports.default = ucs2length;
15823	ucs2length.code = "require(\"ajv/dist/runtime/ucs2length\").default";
15824	}));
15825
15826	//#endregion
15827	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/limitLength.js
15828	var require_limitLength = /* @__PURE__ */ __commonJSMin(((exports) => {
15829	Object.defineProperty(exports, "__esModule", { value: true });
15830	var codegen_1 = require_codegen();
15831	var util_1 = require_util();
15832	var ucs2length_1 = require_ucs2length();
15833	var def = {
15834	keyword: ["maxLength", "minLength"],
15835	type: "string",
15836	schemaType: "number",
15837	$data: true,
15838	error: {
15839	message({ keyword, schemaCode }) {
15840	const comp = keyword === "maxLength" ? "more" : "fewer";
15841	return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
15842	},
15843	params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
15844	},
15845	code(cxt) {
15846	const { keyword, data, schemaCode, it } = cxt;
15847	const op = keyword === "maxLength" ? codegen_1.operators.GT : codegen_1.operators.LT;
15848	const len = it.opts.unicode === false ? (0, codegen_1._)`${data}.length` : (0, codegen_1._)`${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;
15849	cxt.fail$data((0, codegen_1._)`${len} ${op} ${schemaCode}`);
15850	}
15851	};
15852	exports.default = def;
15853	}));
15854
15855	//#endregion
15856	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/pattern.js
15857	var require_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
15858	Object.defineProperty(exports, "__esModule", { value: true });
15859	var code_1 = require_code();
15860	var util_1 = require_util();
15861	var codegen_1 = require_codegen();
15862	var def = {
15863	keyword: "pattern",
15864	type: "string",
15865	schemaType: "string",
15866	$data: true,
15867	error: {
15868	message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
15869	params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`
15870	},
15871	code(cxt) {
15872	const { gen, data, $data, schema, schemaCode, it } = cxt;
15873	const u = it.opts.unicodeRegExp ? "u" : "";
15874	if ($data) {
15875	const { regExp } = it.opts.code;
15876	const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
15877	const valid = gen.let("valid");
15878	gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
15879	cxt.fail$data((0, codegen_1._)`!${valid}`);
15880	} else {
15881	const regExp = (0, code_1.usePattern)(cxt, schema);
15882	cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
15883	}
15884	}
15885	};
15886	exports.default = def;
15887	}));
15888
15889	//#endregion
15890	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
15891	var require_limitProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
15892	Object.defineProperty(exports, "__esModule", { value: true });
15893	var codegen_1 = require_codegen();
15894	var def = {
15895	keyword: ["maxProperties", "minProperties"],
15896	type: "object",
15897	schemaType: "number",
15898	$data: true,
15899	error: {
15900	message({ keyword, schemaCode }) {
15901	const comp = keyword === "maxProperties" ? "more" : "fewer";
15902	return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
15903	},
15904	params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
15905	},
15906	code(cxt) {
15907	const { keyword, data, schemaCode } = cxt;
15908	const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT;
15909	cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`);
15910	}
15911	};
15912	exports.default = def;
15913	}));
15914
15915	//#endregion
15916	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/required.js
15917	var require_required = /* @__PURE__ */ __commonJSMin(((exports) => {
15918	Object.defineProperty(exports, "__esModule", { value: true });
15919	var code_1 = require_code();
15920	var codegen_1 = require_codegen();
15921	var util_1 = require_util();
15922	var def = {
15923	keyword: "required",
15924	type: "object",
15925	schemaType: "array",
15926	$data: true,
15927	error: {
15928	message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`,
15929	params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}`
15930	},
15931	code(cxt) {
15932	const { gen, schema, schemaCode, data, $data, it } = cxt;
15933	const { opts } = it;
15934	if (!$data && schema.length === 0) return;
15935	const useLoop = schema.length >= opts.loopRequired;
15936	if (it.allErrors) allErrorsMode();
15937	else exitOnErrorMode();
15938	if (opts.strictRequired) {
15939	const props = cxt.parentSchema.properties;
15940	const { definedProperties } = cxt.it;
15941	for (const requiredKey of schema) if ((props === null \|\| props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) {
15942	const msg = `required property "${requiredKey}" is not defined at "${it.schemaEnv.baseId + it.errSchemaPath}" (strictRequired)`;
15943	(0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
15944	}
15945	}
15946	function allErrorsMode() {
15947	if (useLoop \|\| $data) cxt.block$data(codegen_1.nil, loopAllRequired);
15948	else for (const prop of schema) (0, code_1.checkReportMissingProp)(cxt, prop);
15949	}
15950	function exitOnErrorMode() {
15951	const missing = gen.let("missing");
15952	if (useLoop \|\| $data) {
15953	const valid = gen.let("valid", true);
15954	cxt.block$data(valid, () => loopUntilMissing(missing, valid));
15955	cxt.ok(valid);
15956	} else {
15957	gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
15958	(0, code_1.reportMissingProp)(cxt, missing);
15959	gen.else();
15960	}
15961	}
15962	function loopAllRequired() {
15963	gen.forOf("prop", schemaCode, (prop) => {
15964	cxt.setParams({ missingProperty: prop });
15965	gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error());
15966	});
15967	}
15968	function loopUntilMissing(missing, valid) {
15969	cxt.setParams({ missingProperty: missing });
15970	gen.forOf(missing, schemaCode, () => {
15971	gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));
15972	gen.if((0, codegen_1.not)(valid), () => {
15973	cxt.error();
15974	gen.break();
15975	});
15976	}, codegen_1.nil);
15977	}
15978	}
15979	};
15980	exports.default = def;
15981	}));
15982
15983	//#endregion
15984	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/limitItems.js
15985	var require_limitItems = /* @__PURE__ */ __commonJSMin(((exports) => {
15986	Object.defineProperty(exports, "__esModule", { value: true });
15987	var codegen_1 = require_codegen();
15988	var def = {
15989	keyword: ["maxItems", "minItems"],
15990	type: "array",
15991	schemaType: "number",
15992	$data: true,
15993	error: {
15994	message({ keyword, schemaCode }) {
15995	const comp = keyword === "maxItems" ? "more" : "fewer";
15996	return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
15997	},
15998	params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
15999	},
16000	code(cxt) {
16001	const { keyword, data, schemaCode } = cxt;
16002	const op = keyword === "maxItems" ? codegen_1.operators.GT : codegen_1.operators.LT;
16003	cxt.fail$data((0, codegen_1._)`${data}.length ${op} ${schemaCode}`);
16004	}
16005	};
16006	exports.default = def;
16007	}));
16008
16009	//#endregion
16010	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/runtime/equal.js
16011	var require_equal = /* @__PURE__ */ __commonJSMin(((exports) => {
16012	Object.defineProperty(exports, "__esModule", { value: true });
16013	var equal = require_fast_deep_equal();
16014	equal.code = "require(\"ajv/dist/runtime/equal\").default";
16015	exports.default = equal;
16016	}));
16017
16018	//#endregion
16019	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
16020	var require_uniqueItems = /* @__PURE__ */ __commonJSMin(((exports) => {
16021	Object.defineProperty(exports, "__esModule", { value: true });
16022	var dataType_1 = require_dataType();
16023	var codegen_1 = require_codegen();
16024	var util_1 = require_util();
16025	var equal_1 = require_equal();
16026	var def = {
16027	keyword: "uniqueItems",
16028	type: "array",
16029	schemaType: "boolean",
16030	$data: true,
16031	error: {
16032	message: ({ params: { i, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
16033	params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}`
16034	},
16035	code(cxt) {
16036	const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
16037	if (!$data && !schema) return;
16038	const valid = gen.let("valid");
16039	const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
16040	cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`);
16041	cxt.ok(valid);
16042	function validateUniqueItems() {
16043	const i = gen.let("i", (0, codegen_1._)`${data}.length`);
16044	const j = gen.let("j");
16045	cxt.setParams({
16046	i,
16047	j
16048	});
16049	gen.assign(valid, true);
16050	gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
16051	}
16052	function canOptimize() {
16053	return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" \|\| t === "array");
16054	}
16055	function loopN(i, j) {
16056	const item = gen.name("item");
16057	const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);
16058	const indices = gen.const("indices", (0, codegen_1._)`{}`);
16059	gen.for((0, codegen_1._)`;${i}--;`, () => {
16060	gen.let(item, (0, codegen_1._)`${data}[${i}]`);
16061	gen.if(wrongType, (0, codegen_1._)`continue`);
16062	if (itemTypes.length > 1) gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`);
16063	gen.if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => {
16064	gen.assign(j, (0, codegen_1._)`${indices}[${item}]`);
16065	cxt.error();
16066	gen.assign(valid, false).break();
16067	}).code((0, codegen_1._)`${indices}[${item}] = ${i}`);
16068	});
16069	}
16070	function loopN2(i, j) {
16071	const eql = (0, util_1.useFunc)(gen, equal_1.default);
16072	const outer = gen.name("outer");
16073	gen.label(outer).for((0, codegen_1._)`;${i}--;`, () => gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`, () => {
16074	cxt.error();
16075	gen.assign(valid, false).break(outer);
16076	})));
16077	}
16078	}
16079	};
16080	exports.default = def;
16081	}));
16082
16083	//#endregion
16084	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/const.js
16085	var require_const = /* @__PURE__ */ __commonJSMin(((exports) => {
16086	Object.defineProperty(exports, "__esModule", { value: true });
16087	var codegen_1 = require_codegen();
16088	var util_1 = require_util();
16089	var equal_1 = require_equal();
16090	var def = {
16091	keyword: "const",
16092	$data: true,
16093	error: {
16094	message: "must be equal to constant",
16095	params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
16096	},
16097	code(cxt) {
16098	const { gen, data, $data, schemaCode, schema } = cxt;
16099	if ($data \|\| schema && typeof schema == "object") cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
16100	else cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
16101	}
16102	};
16103	exports.default = def;
16104	}));
16105
16106	//#endregion
16107	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/enum.js
16108	var require_enum = /* @__PURE__ */ __commonJSMin(((exports) => {
16109	Object.defineProperty(exports, "__esModule", { value: true });
16110	var codegen_1 = require_codegen();
16111	var util_1 = require_util();
16112	var equal_1 = require_equal();
16113	var def = {
16114	keyword: "enum",
16115	schemaType: "array",
16116	$data: true,
16117	error: {
16118	message: "must be equal to one of the allowed values",
16119	params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}`
16120	},
16121	code(cxt) {
16122	const { gen, data, $data, schema, schemaCode, it } = cxt;
16123	if (!$data && schema.length === 0) throw new Error("enum must have non-empty array");
16124	const useLoop = schema.length >= it.opts.loopEnum;
16125	let eql;
16126	const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
16127	let valid;
16128	if (useLoop \|\| $data) {
16129	valid = gen.let("valid");
16130	cxt.block$data(valid, loopEnum);
16131	} else {
16132	/* istanbul ignore if */
16133	if (!Array.isArray(schema)) throw new Error("ajv implementation error");
16134	const vSchema = gen.const("vSchema", schemaCode);
16135	valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
16136	}
16137	cxt.pass(valid);
16138	function loopEnum() {
16139	gen.assign(valid, false);
16140	gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));
16141	}
16142	function equalCode(vSchema, i) {
16143	const sch = schema[i];
16144	return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
16145	}
16146	}
16147	};
16148	exports.default = def;
16149	}));
16150
16151	//#endregion
16152	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/validation/index.js
16153	var require_validation = /* @__PURE__ */ __commonJSMin(((exports) => {
16154	Object.defineProperty(exports, "__esModule", { value: true });
16155	var limitNumber_1 = require_limitNumber();
16156	var multipleOf_1 = require_multipleOf();
16157	var limitLength_1 = require_limitLength();
16158	var pattern_1 = require_pattern();
16159	var limitProperties_1 = require_limitProperties();
16160	var required_1 = require_required();
16161	var limitItems_1 = require_limitItems();
16162	var uniqueItems_1 = require_uniqueItems();
16163	var const_1 = require_const();
16164	var enum_1 = require_enum();
16165	var validation = [
16166	limitNumber_1.default,
16167	multipleOf_1.default,
16168	limitLength_1.default,
16169	pattern_1.default,
16170	limitProperties_1.default,
16171	required_1.default,
16172	limitItems_1.default,
16173	uniqueItems_1.default,
16174	{
16175	keyword: "type",
16176	schemaType: ["string", "array"]
16177	},
16178	{
16179	keyword: "nullable",
16180	schemaType: "boolean"
16181	},
16182	const_1.default,
16183	enum_1.default
16184	];
16185	exports.default = validation;
16186	}));
16187
16188	//#endregion
16189	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
16190	var require_additionalItems = /* @__PURE__ */ __commonJSMin(((exports) => {
16191	Object.defineProperty(exports, "__esModule", { value: true });
16192	exports.validateAdditionalItems = void 0;
16193	var codegen_1 = require_codegen();
16194	var util_1 = require_util();
16195	var def = {
16196	keyword: "additionalItems",
16197	type: "array",
16198	schemaType: ["boolean", "object"],
16199	before: "uniqueItems",
16200	error: {
16201	message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
16202	params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
16203	},
16204	code(cxt) {
16205	const { parentSchema, it } = cxt;
16206	const { items } = parentSchema;
16207	if (!Array.isArray(items)) {
16208	(0, util_1.checkStrictMode)(it, "\"additionalItems\" is ignored when \"items\" is not an array of schemas");
16209	return;
16210	}
16211	validateAdditionalItems(cxt, items);
16212	}
16213	};
16214	function validateAdditionalItems(cxt, items) {
16215	const { gen, schema, data, keyword, it } = cxt;
16216	it.items = true;
16217	const len = gen.const("len", (0, codegen_1._)`${data}.length`);
16218	if (schema === false) {
16219	cxt.setParams({ len: items.length });
16220	cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
16221	} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
16222	const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
16223	gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
16224	cxt.ok(valid);
16225	}
16226	function validateItems(valid) {
16227	gen.forRange("i", items.length, len, (i) => {
16228	cxt.subschema({
16229	keyword,
16230	dataProp: i,
16231	dataPropType: util_1.Type.Num
16232	}, valid);
16233	if (!it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
16234	});
16235	}
16236	}
16237	exports.validateAdditionalItems = validateAdditionalItems;
16238	exports.default = def;
16239	}));
16240
16241	//#endregion
16242	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/items.js
16243	var require_items = /* @__PURE__ */ __commonJSMin(((exports) => {
16244	Object.defineProperty(exports, "__esModule", { value: true });
16245	exports.validateTuple = void 0;
16246	var codegen_1 = require_codegen();
16247	var util_1 = require_util();
16248	var code_1 = require_code();
16249	var def = {
16250	keyword: "items",
16251	type: "array",
16252	schemaType: [
16253	"object",
16254	"array",
16255	"boolean"
16256	],
16257	before: "uniqueItems",
16258	code(cxt) {
16259	const { schema, it } = cxt;
16260	if (Array.isArray(schema)) return validateTuple(cxt, "additionalItems", schema);
16261	it.items = true;
16262	if ((0, util_1.alwaysValidSchema)(it, schema)) return;
16263	cxt.ok((0, code_1.validateArray)(cxt));
16264	}
16265	};
16266	function validateTuple(cxt, extraItems, schArr = cxt.schema) {
16267	const { gen, parentSchema, data, keyword, it } = cxt;
16268	checkStrictTuple(parentSchema);
16269	if (it.opts.unevaluated && schArr.length && it.items !== true) it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
16270	const valid = gen.name("valid");
16271	const len = gen.const("len", (0, codegen_1._)`${data}.length`);
16272	schArr.forEach((sch, i) => {
16273	if ((0, util_1.alwaysValidSchema)(it, sch)) return;
16274	gen.if((0, codegen_1._)`${len} > ${i}`, () => cxt.subschema({
16275	keyword,
16276	schemaProp: i,
16277	dataProp: i
16278	}, valid));
16279	cxt.ok(valid);
16280	});
16281	function checkStrictTuple(sch) {
16282	const { opts, errSchemaPath } = it;
16283	const l = schArr.length;
16284	const fullTuple = l === sch.minItems && (l === sch.maxItems \|\| sch[extraItems] === false);
16285	if (opts.strictTuples && !fullTuple) {
16286	const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
16287	(0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
16288	}
16289	}
16290	}
16291	exports.validateTuple = validateTuple;
16292	exports.default = def;
16293	}));
16294
16295	//#endregion
16296	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
16297	var require_prefixItems = /* @__PURE__ */ __commonJSMin(((exports) => {
16298	Object.defineProperty(exports, "__esModule", { value: true });
16299	var items_1 = require_items();
16300	var def = {
16301	keyword: "prefixItems",
16302	type: "array",
16303	schemaType: ["array"],
16304	before: "uniqueItems",
16305	code: (cxt) => (0, items_1.validateTuple)(cxt, "items")
16306	};
16307	exports.default = def;
16308	}));
16309
16310	//#endregion
16311	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/items2020.js
16312	var require_items2020 = /* @__PURE__ */ __commonJSMin(((exports) => {
16313	Object.defineProperty(exports, "__esModule", { value: true });
16314	var codegen_1 = require_codegen();
16315	var util_1 = require_util();
16316	var code_1 = require_code();
16317	var additionalItems_1 = require_additionalItems();
16318	var def = {
16319	keyword: "items",
16320	type: "array",
16321	schemaType: ["object", "boolean"],
16322	before: "uniqueItems",
16323	error: {
16324	message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
16325	params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
16326	},
16327	code(cxt) {
16328	const { schema, parentSchema, it } = cxt;
16329	const { prefixItems } = parentSchema;
16330	it.items = true;
16331	if ((0, util_1.alwaysValidSchema)(it, schema)) return;
16332	if (prefixItems) (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
16333	else cxt.ok((0, code_1.validateArray)(cxt));
16334	}
16335	};
16336	exports.default = def;
16337	}));
16338
16339	//#endregion
16340	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/contains.js
16341	var require_contains = /* @__PURE__ */ __commonJSMin(((exports) => {
16342	Object.defineProperty(exports, "__esModule", { value: true });
16343	var codegen_1 = require_codegen();
16344	var util_1 = require_util();
16345	var def = {
16346	keyword: "contains",
16347	type: "array",
16348	schemaType: ["object", "boolean"],
16349	before: "uniqueItems",
16350	trackErrors: true,
16351	error: {
16352	message: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
16353	params: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`
16354	},
16355	code(cxt) {
16356	const { gen, schema, parentSchema, data, it } = cxt;
16357	let min;
16358	let max;
16359	const { minContains, maxContains } = parentSchema;
16360	if (it.opts.next) {
16361	min = minContains === void 0 ? 1 : minContains;
16362	max = maxContains;
16363	} else min = 1;
16364	const len = gen.const("len", (0, codegen_1._)`${data}.length`);
16365	cxt.setParams({
16366	min,
16367	max
16368	});
16369	if (max === void 0 && min === 0) {
16370	(0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
16371	return;
16372	}
16373	if (max !== void 0 && min > max) {
16374	(0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
16375	cxt.fail();
16376	return;
16377	}
16378	if ((0, util_1.alwaysValidSchema)(it, schema)) {
16379	let cond = (0, codegen_1._)`${len} >= ${min}`;
16380	if (max !== void 0) cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
16381	cxt.pass(cond);
16382	return;
16383	}
16384	it.items = true;
16385	const valid = gen.name("valid");
16386	if (max === void 0 && min === 1) validateItems(valid, () => gen.if(valid, () => gen.break()));
16387	else if (min === 0) {
16388	gen.let(valid, true);
16389	if (max !== void 0) gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
16390	} else {
16391	gen.let(valid, false);
16392	validateItemsWithCount();
16393	}
16394	cxt.result(valid, () => cxt.reset());
16395	function validateItemsWithCount() {
16396	const schValid = gen.name("_valid");
16397	const count = gen.let("count", 0);
16398	validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
16399	}
16400	function validateItems(_valid, block) {
16401	gen.forRange("i", 0, len, (i) => {
16402	cxt.subschema({
16403	keyword: "contains",
16404	dataProp: i,
16405	dataPropType: util_1.Type.Num,
16406	compositeRule: true
16407	}, _valid);
16408	block();
16409	});
16410	}
16411	function checkLimits(count) {
16412	gen.code((0, codegen_1._)`${count}++`);
16413	if (max === void 0) gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
16414	else {
16415	gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
16416	if (min === 1) gen.assign(valid, true);
16417	else gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
16418	}
16419	}
16420	}
16421	};
16422	exports.default = def;
16423	}));
16424
16425	//#endregion
16426	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
16427	var require_dependencies = /* @__PURE__ */ __commonJSMin(((exports) => {
16428	Object.defineProperty(exports, "__esModule", { value: true });
16429	exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
16430	var codegen_1 = require_codegen();
16431	var util_1 = require_util();
16432	var code_1 = require_code();
16433	exports.error = {
16434	message: ({ params: { property, depsCount, deps } }) => {
16435	const property_ies = depsCount === 1 ? "property" : "properties";
16436	return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`;
16437	},
16438	params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._)`{property: ${property},
16439	missingProperty: ${missingProperty},
16440	depsCount: ${depsCount},
16441	deps: ${deps}}`
16442	};
16443	var def = {
16444	keyword: "dependencies",
16445	type: "object",
16446	schemaType: "object",
16447	error: exports.error,
16448	code(cxt) {
16449	const [propDeps, schDeps] = splitDependencies(cxt);
16450	validatePropertyDeps(cxt, propDeps);
16451	validateSchemaDeps(cxt, schDeps);
16452	}
16453	};
16454	function splitDependencies({ schema }) {
16455	const propertyDeps = {};
16456	const schemaDeps = {};
16457	for (const key in schema) {
16458	if (key === "__proto__") continue;
16459	const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
16460	deps[key] = schema[key];
16461	}
16462	return [propertyDeps, schemaDeps];
16463	}
16464	function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
16465	const { gen, data, it } = cxt;
16466	if (Object.keys(propertyDeps).length === 0) return;
16467	const missing = gen.let("missing");
16468	for (const prop in propertyDeps) {
16469	const deps = propertyDeps[prop];
16470	if (deps.length === 0) continue;
16471	const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
16472	cxt.setParams({
16473	property: prop,
16474	depsCount: deps.length,
16475	deps: deps.join(", ")
16476	});
16477	if (it.allErrors) gen.if(hasProperty, () => {
16478	for (const depProp of deps) (0, code_1.checkReportMissingProp)(cxt, depProp);
16479	});
16480	else {
16481	gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
16482	(0, code_1.reportMissingProp)(cxt, missing);
16483	gen.else();
16484	}
16485	}
16486	}
16487	exports.validatePropertyDeps = validatePropertyDeps;
16488	function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
16489	const { gen, data, keyword, it } = cxt;
16490	const valid = gen.name("valid");
16491	for (const prop in schemaDeps) {
16492	if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop])) continue;
16493	gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties), () => {
16494	const schCxt = cxt.subschema({
16495	keyword,
16496	schemaProp: prop
16497	}, valid);
16498	cxt.mergeValidEvaluated(schCxt, valid);
16499	}, () => gen.var(valid, true));
16500	cxt.ok(valid);
16501	}
16502	}
16503	exports.validateSchemaDeps = validateSchemaDeps;
16504	exports.default = def;
16505	}));
16506
16507	//#endregion
16508	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
16509	var require_propertyNames = /* @__PURE__ */ __commonJSMin(((exports) => {
16510	Object.defineProperty(exports, "__esModule", { value: true });
16511	var codegen_1 = require_codegen();
16512	var util_1 = require_util();
16513	var def = {
16514	keyword: "propertyNames",
16515	type: "object",
16516	schemaType: ["object", "boolean"],
16517	error: {
16518	message: "property name must be valid",
16519	params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
16520	},
16521	code(cxt) {
16522	const { gen, schema, data, it } = cxt;
16523	if ((0, util_1.alwaysValidSchema)(it, schema)) return;
16524	const valid = gen.name("valid");
16525	gen.forIn("key", data, (key) => {
16526	cxt.setParams({ propertyName: key });
16527	cxt.subschema({
16528	keyword: "propertyNames",
16529	data: key,
16530	dataTypes: ["string"],
16531	propertyName: key,
16532	compositeRule: true
16533	}, valid);
16534	gen.if((0, codegen_1.not)(valid), () => {
16535	cxt.error(true);
16536	if (!it.allErrors) gen.break();
16537	});
16538	});
16539	cxt.ok(valid);
16540	}
16541	};
16542	exports.default = def;
16543	}));
16544
16545	//#endregion
16546	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
16547	var require_additionalProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
16548	Object.defineProperty(exports, "__esModule", { value: true });
16549	var code_1 = require_code();
16550	var codegen_1 = require_codegen();
16551	var names_1 = require_names();
16552	var util_1 = require_util();
16553	var def = {
16554	keyword: "additionalProperties",
16555	type: ["object"],
16556	schemaType: ["boolean", "object"],
16557	allowUndefined: true,
16558	trackErrors: true,
16559	error: {
16560	message: "must NOT have additional properties",
16561	params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`
16562	},
16563	code(cxt) {
16564	const { gen, schema, parentSchema, data, errsCount, it } = cxt;
16565	/* istanbul ignore if */
16566	if (!errsCount) throw new Error("ajv implementation error");
16567	const { allErrors, opts } = it;
16568	it.props = true;
16569	if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema)) return;
16570	const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
16571	const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
16572	checkAdditionalProperties();
16573	cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
16574	function checkAdditionalProperties() {
16575	gen.forIn("key", data, (key) => {
16576	if (!props.length && !patProps.length) additionalPropertyCode(key);
16577	else gen.if(isAdditional(key), () => additionalPropertyCode(key));
16578	});
16579	}
16580	function isAdditional(key) {
16581	let definedProp;
16582	if (props.length > 8) {
16583	const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
16584	definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
16585	} else if (props.length) definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`));
16586	else definedProp = codegen_1.nil;
16587	if (patProps.length) definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
16588	return (0, codegen_1.not)(definedProp);
16589	}
16590	function deleteAdditional(key) {
16591	gen.code((0, codegen_1._)`delete ${data}[${key}]`);
16592	}
16593	function additionalPropertyCode(key) {
16594	if (opts.removeAdditional === "all" \|\| opts.removeAdditional && schema === false) {
16595	deleteAdditional(key);
16596	return;
16597	}
16598	if (schema === false) {
16599	cxt.setParams({ additionalProperty: key });
16600	cxt.error();
16601	if (!allErrors) gen.break();
16602	return;
16603	}
16604	if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
16605	const valid = gen.name("valid");
16606	if (opts.removeAdditional === "failing") {
16607	applyAdditionalSchema(key, valid, false);
16608	gen.if((0, codegen_1.not)(valid), () => {
16609	cxt.reset();
16610	deleteAdditional(key);
16611	});
16612	} else {
16613	applyAdditionalSchema(key, valid);
16614	if (!allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
16615	}
16616	}
16617	}
16618	function applyAdditionalSchema(key, valid, errors) {
16619	const subschema = {
16620	keyword: "additionalProperties",
16621	dataProp: key,
16622	dataPropType: util_1.Type.Str
16623	};
16624	if (errors === false) Object.assign(subschema, {
16625	compositeRule: true,
16626	createErrors: false,
16627	allErrors: false
16628	});
16629	cxt.subschema(subschema, valid);
16630	}
16631	}
16632	};
16633	exports.default = def;
16634	}));
16635
16636	//#endregion
16637	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/properties.js
16638	var require_properties = /* @__PURE__ */ __commonJSMin(((exports) => {
16639	Object.defineProperty(exports, "__esModule", { value: true });
16640	var validate_1 = require_validate();
16641	var code_1 = require_code();
16642	var util_1 = require_util();
16643	var additionalProperties_1 = require_additionalProperties();
16644	var def = {
16645	keyword: "properties",
16646	type: "object",
16647	schemaType: "object",
16648	code(cxt) {
16649	const { gen, schema, parentSchema, data, it } = cxt;
16650	if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
16651	const allProps = (0, code_1.allSchemaProperties)(schema);
16652	for (const prop of allProps) it.definedProperties.add(prop);
16653	if (it.opts.unevaluated && allProps.length && it.props !== true) it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
16654	const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
16655	if (properties.length === 0) return;
16656	const valid = gen.name("valid");
16657	for (const prop of properties) {
16658	if (hasDefault(prop)) applyPropertySchema(prop);
16659	else {
16660	gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties));
16661	applyPropertySchema(prop);
16662	if (!it.allErrors) gen.else().var(valid, true);
16663	gen.endIf();
16664	}
16665	cxt.it.definedProperties.add(prop);
16666	cxt.ok(valid);
16667	}
16668	function hasDefault(prop) {
16669	return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== void 0;
16670	}
16671	function applyPropertySchema(prop) {
16672	cxt.subschema({
16673	keyword: "properties",
16674	schemaProp: prop,
16675	dataProp: prop
16676	}, valid);
16677	}
16678	}
16679	};
16680	exports.default = def;
16681	}));
16682
16683	//#endregion
16684	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
16685	var require_patternProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
16686	Object.defineProperty(exports, "__esModule", { value: true });
16687	var code_1 = require_code();
16688	var codegen_1 = require_codegen();
16689	var util_1 = require_util();
16690	var util_2 = require_util();
16691	var def = {
16692	keyword: "patternProperties",
16693	type: "object",
16694	schemaType: "object",
16695	code(cxt) {
16696	const { gen, schema, data, parentSchema, it } = cxt;
16697	const { opts } = it;
16698	const patterns = (0, code_1.allSchemaProperties)(schema);
16699	const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));
16700	if (patterns.length === 0 \|\| alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated \|\| it.props === true)) return;
16701	const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties;
16702	const valid = gen.name("valid");
16703	if (it.props !== true && !(it.props instanceof codegen_1.Name)) it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);
16704	const { props } = it;
16705	validatePatternProperties();
16706	function validatePatternProperties() {
16707	for (const pat of patterns) {
16708	if (checkProperties) checkMatchingProperties(pat);
16709	if (it.allErrors) validateProperties(pat);
16710	else {
16711	gen.var(valid, true);
16712	validateProperties(pat);
16713	gen.if(valid);
16714	}
16715	}
16716	}
16717	function checkMatchingProperties(pat) {
16718	for (const prop in checkProperties) if (new RegExp(pat).test(prop)) (0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`);
16719	}
16720	function validateProperties(pat) {
16721	gen.forIn("key", data, (key) => {
16722	gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {
16723	const alwaysValid = alwaysValidPatterns.includes(pat);
16724	if (!alwaysValid) cxt.subschema({
16725	keyword: "patternProperties",
16726	schemaProp: pat,
16727	dataProp: key,
16728	dataPropType: util_2.Type.Str
16729	}, valid);
16730	if (it.opts.unevaluated && props !== true) gen.assign((0, codegen_1._)`${props}[${key}]`, true);
16731	else if (!alwaysValid && !it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
16732	});
16733	});
16734	}
16735	}
16736	};
16737	exports.default = def;
16738	}));
16739
16740	//#endregion
16741	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/not.js
16742	var require_not = /* @__PURE__ */ __commonJSMin(((exports) => {
16743	Object.defineProperty(exports, "__esModule", { value: true });
16744	var util_1 = require_util();
16745	var def = {
16746	keyword: "not",
16747	schemaType: ["object", "boolean"],
16748	trackErrors: true,
16749	code(cxt) {
16750	const { gen, schema, it } = cxt;
16751	if ((0, util_1.alwaysValidSchema)(it, schema)) {
16752	cxt.fail();
16753	return;
16754	}
16755	const valid = gen.name("valid");
16756	cxt.subschema({
16757	keyword: "not",
16758	compositeRule: true,
16759	createErrors: false,
16760	allErrors: false
16761	}, valid);
16762	cxt.failResult(valid, () => cxt.reset(), () => cxt.error());
16763	},
16764	error: { message: "must NOT be valid" }
16765	};
16766	exports.default = def;
16767	}));
16768
16769	//#endregion
16770	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
16771	var require_anyOf = /* @__PURE__ */ __commonJSMin(((exports) => {
16772	Object.defineProperty(exports, "__esModule", { value: true });
16773	var def = {
16774	keyword: "anyOf",
16775	schemaType: "array",
16776	trackErrors: true,
16777	code: require_code().validateUnion,
16778	error: { message: "must match a schema in anyOf" }
16779	};
16780	exports.default = def;
16781	}));
16782
16783	//#endregion
16784	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
16785	var require_oneOf = /* @__PURE__ */ __commonJSMin(((exports) => {
16786	Object.defineProperty(exports, "__esModule", { value: true });
16787	var codegen_1 = require_codegen();
16788	var util_1 = require_util();
16789	var def = {
16790	keyword: "oneOf",
16791	schemaType: "array",
16792	trackErrors: true,
16793	error: {
16794	message: "must match exactly one schema in oneOf",
16795	params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}`
16796	},
16797	code(cxt) {
16798	const { gen, schema, parentSchema, it } = cxt;
16799	/* istanbul ignore if */
16800	if (!Array.isArray(schema)) throw new Error("ajv implementation error");
16801	if (it.opts.discriminator && parentSchema.discriminator) return;
16802	const schArr = schema;
16803	const valid = gen.let("valid", false);
16804	const passing = gen.let("passing", null);
16805	const schValid = gen.name("_valid");
16806	cxt.setParams({ passing });
16807	gen.block(validateOneOf);
16808	cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
16809	function validateOneOf() {
16810	schArr.forEach((sch, i) => {
16811	let schCxt;
16812	if ((0, util_1.alwaysValidSchema)(it, sch)) gen.var(schValid, true);
16813	else schCxt = cxt.subschema({
16814	keyword: "oneOf",
16815	schemaProp: i,
16816	compositeRule: true
16817	}, schValid);
16818	if (i > 0) gen.if((0, codegen_1._)`${schValid} && ${valid}`).assign(valid, false).assign(passing, (0, codegen_1._)`[${passing}, ${i}]`).else();
16819	gen.if(schValid, () => {
16820	gen.assign(valid, true);
16821	gen.assign(passing, i);
16822	if (schCxt) cxt.mergeEvaluated(schCxt, codegen_1.Name);
16823	});
16824	});
16825	}
16826	}
16827	};
16828	exports.default = def;
16829	}));
16830
16831	//#endregion
16832	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/allOf.js
16833	var require_allOf = /* @__PURE__ */ __commonJSMin(((exports) => {
16834	Object.defineProperty(exports, "__esModule", { value: true });
16835	var util_1 = require_util();
16836	var def = {
16837	keyword: "allOf",
16838	schemaType: "array",
16839	code(cxt) {
16840	const { gen, schema, it } = cxt;
16841	/* istanbul ignore if */
16842	if (!Array.isArray(schema)) throw new Error("ajv implementation error");
16843	const valid = gen.name("valid");
16844	schema.forEach((sch, i) => {
16845	if ((0, util_1.alwaysValidSchema)(it, sch)) return;
16846	const schCxt = cxt.subschema({
16847	keyword: "allOf",
16848	schemaProp: i
16849	}, valid);
16850	cxt.ok(valid);
16851	cxt.mergeEvaluated(schCxt);
16852	});
16853	}
16854	};
16855	exports.default = def;
16856	}));
16857
16858	//#endregion
16859	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/if.js
16860	var require_if = /* @__PURE__ */ __commonJSMin(((exports) => {
16861	Object.defineProperty(exports, "__esModule", { value: true });
16862	var codegen_1 = require_codegen();
16863	var util_1 = require_util();
16864	var def = {
16865	keyword: "if",
16866	schemaType: ["object", "boolean"],
16867	trackErrors: true,
16868	error: {
16869	message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
16870	params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`
16871	},
16872	code(cxt) {
16873	const { gen, parentSchema, it } = cxt;
16874	if (parentSchema.then === void 0 && parentSchema.else === void 0) (0, util_1.checkStrictMode)(it, "\"if\" without \"then\" and \"else\" is ignored");
16875	const hasThen = hasSchema(it, "then");
16876	const hasElse = hasSchema(it, "else");
16877	if (!hasThen && !hasElse) return;
16878	const valid = gen.let("valid", true);
16879	const schValid = gen.name("_valid");
16880	validateIf();
16881	cxt.reset();
16882	if (hasThen && hasElse) {
16883	const ifClause = gen.let("ifClause");
16884	cxt.setParams({ ifClause });
16885	gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
16886	} else if (hasThen) gen.if(schValid, validateClause("then"));
16887	else gen.if((0, codegen_1.not)(schValid), validateClause("else"));
16888	cxt.pass(valid, () => cxt.error(true));
16889	function validateIf() {
16890	const schCxt = cxt.subschema({
16891	keyword: "if",
16892	compositeRule: true,
16893	createErrors: false,
16894	allErrors: false
16895	}, schValid);
16896	cxt.mergeEvaluated(schCxt);
16897	}
16898	function validateClause(keyword, ifClause) {
16899	return () => {
16900	const schCxt = cxt.subschema({ keyword }, schValid);
16901	gen.assign(valid, schValid);
16902	cxt.mergeValidEvaluated(schCxt, valid);
16903	if (ifClause) gen.assign(ifClause, (0, codegen_1._)`${keyword}`);
16904	else cxt.setParams({ ifClause: keyword });
16905	};
16906	}
16907	}
16908	};
16909	function hasSchema(it, keyword) {
16910	const schema = it.schema[keyword];
16911	return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema);
16912	}
16913	exports.default = def;
16914	}));
16915
16916	//#endregion
16917	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
16918	var require_thenElse = /* @__PURE__ */ __commonJSMin(((exports) => {
16919	Object.defineProperty(exports, "__esModule", { value: true });
16920	var util_1 = require_util();
16921	var def = {
16922	keyword: ["then", "else"],
16923	schemaType: ["object", "boolean"],
16924	code({ keyword, parentSchema, it }) {
16925	if (parentSchema.if === void 0) (0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`);
16926	}
16927	};
16928	exports.default = def;
16929	}));
16930
16931	//#endregion
16932	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/applicator/index.js
16933	var require_applicator = /* @__PURE__ */ __commonJSMin(((exports) => {
16934	Object.defineProperty(exports, "__esModule", { value: true });
16935	var additionalItems_1 = require_additionalItems();
16936	var prefixItems_1 = require_prefixItems();
16937	var items_1 = require_items();
16938	var items2020_1 = require_items2020();
16939	var contains_1 = require_contains();
16940	var dependencies_1 = require_dependencies();
16941	var propertyNames_1 = require_propertyNames();
16942	var additionalProperties_1 = require_additionalProperties();
16943	var properties_1 = require_properties();
16944	var patternProperties_1 = require_patternProperties();
16945	var not_1 = require_not();
16946	var anyOf_1 = require_anyOf();
16947	var oneOf_1 = require_oneOf();
16948	var allOf_1 = require_allOf();
16949	var if_1 = require_if();
16950	var thenElse_1 = require_thenElse();
16951	function getApplicator(draft2020 = false) {
16952	const applicator = [
16953	not_1.default,
16954	anyOf_1.default,
16955	oneOf_1.default,
16956	allOf_1.default,
16957	if_1.default,
16958	thenElse_1.default,
16959	propertyNames_1.default,
16960	additionalProperties_1.default,
16961	dependencies_1.default,
16962	properties_1.default,
16963	patternProperties_1.default
16964	];
16965	if (draft2020) applicator.push(prefixItems_1.default, items2020_1.default);
16966	else applicator.push(additionalItems_1.default, items_1.default);
16967	applicator.push(contains_1.default);
16968	return applicator;
16969	}
16970	exports.default = getApplicator;
16971	}));
16972
16973	//#endregion
16974	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/format/format.js
16975	var require_format$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
16976	Object.defineProperty(exports, "__esModule", { value: true });
16977	var codegen_1 = require_codegen();
16978	var def = {
16979	keyword: "format",
16980	type: ["number", "string"],
16981	schemaType: "string",
16982	$data: true,
16983	error: {
16984	message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`,
16985	params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}`
16986	},
16987	code(cxt, ruleType) {
16988	const { gen, data, $data, schema, schemaCode, it } = cxt;
16989	const { opts, errSchemaPath, schemaEnv, self } = it;
16990	if (!opts.validateFormats) return;
16991	if ($data) validate$DataFormat();
16992	else validateFormat();
16993	function validate$DataFormat() {
16994	const fmts = gen.scopeValue("formats", {
16995	ref: self.formats,
16996	code: opts.code.formats
16997	});
16998	const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
16999	const fType = gen.let("fType");
17000	const format = gen.let("format");
17001	gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type \|\| "string"`).assign(format, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, fDef));
17002	cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
17003	function unknownFmt() {
17004	if (opts.strictSchema === false) return codegen_1.nil;
17005	return (0, codegen_1._)`${schemaCode} && !${format}`;
17006	}
17007	function invalidFmt() {
17008	const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))` : (0, codegen_1._)`${format}(${data})`;
17009	const validData = (0, codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
17010	return (0, codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
17011	}
17012	}
17013	function validateFormat() {
17014	const formatDef = self.formats[schema];
17015	if (!formatDef) {
17016	unknownFormat();
17017	return;
17018	}
17019	if (formatDef === true) return;
17020	const [fmtType, format, fmtRef] = getFormat(formatDef);
17021	if (fmtType === ruleType) cxt.pass(validCondition());
17022	function unknownFormat() {
17023	if (opts.strictSchema === false) {
17024	self.logger.warn(unknownMsg());
17025	return;
17026	}
17027	throw new Error(unknownMsg());
17028	function unknownMsg() {
17029	return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
17030	}
17031	}
17032	function getFormat(fmtDef) {
17033	const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : void 0;
17034	const fmt = gen.scopeValue("formats", {
17035	key: schema,
17036	ref: fmtDef,
17037	code
17038	});
17039	if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) return [
17040	fmtDef.type \|\| "string",
17041	fmtDef.validate,
17042	(0, codegen_1._)`${fmt}.validate`
17043	];
17044	return [
17045	"string",
17046	fmtDef,
17047	fmt
17048	];
17049	}
17050	function validCondition() {
17051	if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
17052	if (!schemaEnv.$async) throw new Error("async format in sync schema");
17053	return (0, codegen_1._)`await ${fmtRef}(${data})`;
17054	}
17055	return typeof format == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
17056	}
17057	}
17058	}
17059	};
17060	exports.default = def;
17061	}));
17062
17063	//#endregion
17064	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/format/index.js
17065	var require_format = /* @__PURE__ */ __commonJSMin(((exports) => {
17066	Object.defineProperty(exports, "__esModule", { value: true });
17067	var format = [require_format$1().default];
17068	exports.default = format;
17069	}));
17070
17071	//#endregion
17072	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/metadata.js
17073	var require_metadata = /* @__PURE__ */ __commonJSMin(((exports) => {
17074	Object.defineProperty(exports, "__esModule", { value: true });
17075	exports.contentVocabulary = exports.metadataVocabulary = void 0;
17076	exports.metadataVocabulary = [
17077	"title",
17078	"description",
17079	"default",
17080	"deprecated",
17081	"readOnly",
17082	"writeOnly",
17083	"examples"
17084	];
17085	exports.contentVocabulary = [
17086	"contentMediaType",
17087	"contentEncoding",
17088	"contentSchema"
17089	];
17090	}));
17091
17092	//#endregion
17093	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/draft7.js
17094	var require_draft7 = /* @__PURE__ */ __commonJSMin(((exports) => {
17095	Object.defineProperty(exports, "__esModule", { value: true });
17096	var core_1 = require_core();
17097	var validation_1 = require_validation();
17098	var applicator_1 = require_applicator();
17099	var format_1 = require_format();
17100	var metadata_1 = require_metadata();
17101	var draft7Vocabularies = [
17102	core_1.default,
17103	validation_1.default,
17104	(0, applicator_1.default)(),
17105	format_1.default,
17106	metadata_1.metadataVocabulary,
17107	metadata_1.contentVocabulary
17108	];
17109	exports.default = draft7Vocabularies;
17110	}));
17111
17112	//#endregion
17113	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/discriminator/types.js
17114	var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
17115	Object.defineProperty(exports, "__esModule", { value: true });
17116	exports.DiscrError = void 0;
17117	var DiscrError;
17118	(function(DiscrError) {
17119	DiscrError["Tag"] = "tag";
17120	DiscrError["Mapping"] = "mapping";
17121	})(DiscrError \|\| (exports.DiscrError = DiscrError = {}));
17122	}));
17123
17124	//#endregion
17125	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/vocabularies/discriminator/index.js
17126	var require_discriminator = /* @__PURE__ */ __commonJSMin(((exports) => {
17127	Object.defineProperty(exports, "__esModule", { value: true });
17128	var codegen_1 = require_codegen();
17129	var types_1 = require_types();
17130	var compile_1 = require_compile();
17131	var ref_error_1 = require_ref_error();
17132	var util_1 = require_util();
17133	var def = {
17134	keyword: "discriminator",
17135	type: "object",
17136	schemaType: "object",
17137	error: {
17138	message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`,
17139	params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`
17140	},
17141	code(cxt) {
17142	const { gen, data, schema, parentSchema, it } = cxt;
17143	const { oneOf } = parentSchema;
17144	if (!it.opts.discriminator) throw new Error("discriminator: requires discriminator option");
17145	const tagName = schema.propertyName;
17146	if (typeof tagName != "string") throw new Error("discriminator: requires propertyName");
17147	if (schema.mapping) throw new Error("discriminator: mapping is not supported");
17148	if (!oneOf) throw new Error("discriminator: requires oneOf keyword");
17149	const valid = gen.let("valid", false);
17150	const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
17151	gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, {
17152	discrError: types_1.DiscrError.Tag,
17153	tag,
17154	tagName
17155	}));
17156	cxt.ok(valid);
17157	function validateMapping() {
17158	const mapping = getMapping();
17159	gen.if(false);
17160	for (const tagValue in mapping) {
17161	gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`);
17162	gen.assign(valid, applyTagSchema(mapping[tagValue]));
17163	}
17164	gen.else();
17165	cxt.error(false, {
17166	discrError: types_1.DiscrError.Mapping,
17167	tag,
17168	tagName
17169	});
17170	gen.endIf();
17171	}
17172	function applyTagSchema(schemaProp) {
17173	const _valid = gen.name("valid");
17174	const schCxt = cxt.subschema({
17175	keyword: "oneOf",
17176	schemaProp
17177	}, _valid);
17178	cxt.mergeEvaluated(schCxt, codegen_1.Name);
17179	return _valid;
17180	}
17181	function getMapping() {
17182	var _a;
17183	const oneOfMapping = {};
17184	const topRequired = hasRequired(parentSchema);
17185	let tagRequired = true;
17186	for (let i = 0; i < oneOf.length; i++) {
17187	let sch = oneOf[i];
17188	if ((sch === null \|\| sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
17189	const ref = sch.$ref;
17190	sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
17191	if (sch instanceof compile_1.SchemaEnv) sch = sch.schema;
17192	if (sch === void 0) throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
17193	}
17194	const propSch = (_a = sch === null \|\| sch === void 0 ? void 0 : sch.properties) === null \|\| _a === void 0 ? void 0 : _a[tagName];
17195	if (typeof propSch != "object") throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`);
17196	tagRequired = tagRequired && (topRequired \|\| hasRequired(sch));
17197	addMappings(propSch, i);
17198	}
17199	if (!tagRequired) throw new Error(`discriminator: "${tagName}" must be required`);
17200	return oneOfMapping;
17201	function hasRequired({ required }) {
17202	return Array.isArray(required) && required.includes(tagName);
17203	}
17204	function addMappings(sch, i) {
17205	if (sch.const) addMapping(sch.const, i);
17206	else if (sch.enum) for (const tagValue of sch.enum) addMapping(tagValue, i);
17207	else throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`);
17208	}
17209	function addMapping(tagValue, i) {
17210	if (typeof tagValue != "string" \|\| tagValue in oneOfMapping) throw new Error(`discriminator: "${tagName}" values must be unique strings`);
17211	oneOfMapping[tagValue] = i;
17212	}
17213	}
17214	}
17215	};
17216	exports.default = def;
17217	}));
17218
17219	//#endregion
17220	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/refs/json-schema-draft-07.json
17221	var json_schema_draft_07_exports = /* @__PURE__ */ __exportAll({
17222	$id: () => $id,
17223	$schema: () => $schema,
17224	default: () => json_schema_draft_07_default,
17225	definitions: () => definitions,
17226	properties: () => properties,
17227	title: () => title,
17228	type: () => type
17229	});
17230	var $schema, $id, title, definitions, type, properties, json_schema_draft_07_default;
17231	var init_json_schema_draft_07 = __esmMin((() => {
17232	$schema = "http://json-schema.org/draft-07/schema#";
17233	$id = "http://json-schema.org/draft-07/schema#";
17234	title = "Core schema meta-schema";
17235	definitions = {
17236	"schemaArray": {
17237	"type": "array",
17238	"minItems": 1,
17239	"items": { "$ref": "#" }
17240	},
17241	"nonNegativeInteger": {
17242	"type": "integer",
17243	"minimum": 0
17244	},
17245	"nonNegativeIntegerDefault0": { "allOf": [{ "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 }] },
17246	"simpleTypes": { "enum": [
17247	"array",
17248	"boolean",
17249	"integer",
17250	"null",
17251	"number",
17252	"object",
17253	"string"
17254	] },
17255	"stringArray": {
17256	"type": "array",
17257	"items": { "type": "string" },
17258	"uniqueItems": true,
17259	"default": []
17260	}
17261	};
17262	type = ["object", "boolean"];
17263	properties = {
17264	"$id": {
17265	"type": "string",
17266	"format": "uri-reference"
17267	},
17268	"$schema": {
17269	"type": "string",
17270	"format": "uri"
17271	},
17272	"$ref": {
17273	"type": "string",
17274	"format": "uri-reference"
17275	},
17276	"$comment": { "type": "string" },
17277	"title": { "type": "string" },
17278	"description": { "type": "string" },
17279	"default": true,
17280	"readOnly": {
17281	"type": "boolean",
17282	"default": false
17283	},
17284	"examples": {
17285	"type": "array",
17286	"items": true
17287	},
17288	"multipleOf": {
17289	"type": "number",
17290	"exclusiveMinimum": 0
17291	},
17292	"maximum": { "type": "number" },
17293	"exclusiveMaximum": { "type": "number" },
17294	"minimum": { "type": "number" },
17295	"exclusiveMinimum": { "type": "number" },
17296	"maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
17297	"minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
17298	"pattern": {
17299	"type": "string",
17300	"format": "regex"
17301	},
17302	"additionalItems": { "$ref": "#" },
17303	"items": {
17304	"anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/schemaArray" }],
17305	"default": true
17306	},
17307	"maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
17308	"minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
17309	"uniqueItems": {
17310	"type": "boolean",
17311	"default": false
17312	},
17313	"contains": { "$ref": "#" },
17314	"maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
17315	"minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
17316	"required": { "$ref": "#/definitions/stringArray" },
17317	"additionalProperties": { "$ref": "#" },
17318	"definitions": {
17319	"type": "object",
17320	"additionalProperties": { "$ref": "#" },
17321	"default": {}
17322	},
17323	"properties": {
17324	"type": "object",
17325	"additionalProperties": { "$ref": "#" },
17326	"default": {}
17327	},
17328	"patternProperties": {
17329	"type": "object",
17330	"additionalProperties": { "$ref": "#" },
17331	"propertyNames": { "format": "regex" },
17332	"default": {}
17333	},
17334	"dependencies": {
17335	"type": "object",
17336	"additionalProperties": { "anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/stringArray" }] }
17337	},
17338	"propertyNames": { "$ref": "#" },
17339	"const": true,
17340	"enum": {
17341	"type": "array",
17342	"items": true,
17343	"minItems": 1,
17344	"uniqueItems": true
17345	},
17346	"type": { "anyOf": [{ "$ref": "#/definitions/simpleTypes" }, {
17347	"type": "array",
17348	"items": { "$ref": "#/definitions/simpleTypes" },
17349	"minItems": 1,
17350	"uniqueItems": true
17351	}] },
17352	"format": { "type": "string" },
17353	"contentMediaType": { "type": "string" },
17354	"contentEncoding": { "type": "string" },
17355	"if": { "$ref": "#" },
17356	"then": { "$ref": "#" },
17357	"else": { "$ref": "#" },
17358	"allOf": { "$ref": "#/definitions/schemaArray" },
17359	"anyOf": { "$ref": "#/definitions/schemaArray" },
17360	"oneOf": { "$ref": "#/definitions/schemaArray" },
17361	"not": { "$ref": "#" }
17362	};
17363	json_schema_draft_07_default = {
17364	$schema,
17365	$id,
17366	title,
17367	definitions,
17368	type,
17369	properties,
17370	"default": true
17371	};
17372	}));
17373
17374	//#endregion
17375	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/ajv.js
17376	var require_ajv = /* @__PURE__ */ __commonJSMin(((exports, module) => {
17377	Object.defineProperty(exports, "__esModule", { value: true });
17378	exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0;
17379	var core_1 = require_core$1();
17380	var draft7_1 = require_draft7();
17381	var discriminator_1 = require_discriminator();
17382	var draft7MetaSchema = (init_json_schema_draft_07(), __toCommonJS(json_schema_draft_07_exports).default);
17383	var META_SUPPORT_DATA = ["/properties"];
17384	var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
17385	var Ajv = class extends core_1.default {
17386	_addVocabularies() {
17387	super._addVocabularies();
17388	draft7_1.default.forEach((v) => this.addVocabulary(v));
17389	if (this.opts.discriminator) this.addKeyword(discriminator_1.default);
17390	}
17391	_addDefaultMetaSchema() {
17392	super._addDefaultMetaSchema();
17393	if (!this.opts.meta) return;
17394	const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema;
17395	this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
17396	this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
17397	}
17398	defaultMeta() {
17399	return this.opts.defaultMeta = super.defaultMeta() \|\| (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
17400	}
17401	};
17402	exports.Ajv = Ajv;
17403	module.exports = exports = Ajv;
17404	module.exports.Ajv = Ajv;
17405	Object.defineProperty(exports, "__esModule", { value: true });
17406	exports.default = Ajv;
17407	var validate_1 = require_validate();
17408	Object.defineProperty(exports, "KeywordCxt", {
17409	enumerable: true,
17410	get: function() {
17411	return validate_1.KeywordCxt;
17412	}
17413	});
17414	var codegen_1 = require_codegen();
17415	Object.defineProperty(exports, "_", {
17416	enumerable: true,
17417	get: function() {
17418	return codegen_1._;
17419	}
17420	});
17421	Object.defineProperty(exports, "str", {
17422	enumerable: true,
17423	get: function() {
17424	return codegen_1.str;
17425	}
17426	});
17427	Object.defineProperty(exports, "stringify", {
17428	enumerable: true,
17429	get: function() {
17430	return codegen_1.stringify;
17431	}
17432	});
17433	Object.defineProperty(exports, "nil", {
17434	enumerable: true,
17435	get: function() {
17436	return codegen_1.nil;
17437	}
17438	});
17439	Object.defineProperty(exports, "Name", {
17440	enumerable: true,
17441	get: function() {
17442	return codegen_1.Name;
17443	}
17444	});
17445	Object.defineProperty(exports, "CodeGen", {
17446	enumerable: true,
17447	get: function() {
17448	return codegen_1.CodeGen;
17449	}
17450	});
17451	var validation_error_1 = require_validation_error();
17452	Object.defineProperty(exports, "ValidationError", {
17453	enumerable: true,
17454	get: function() {
17455	return validation_error_1.default;
17456	}
17457	});
17458	var ref_error_1 = require_ref_error();
17459	Object.defineProperty(exports, "MissingRefError", {
17460	enumerable: true,
17461	get: function() {
17462	return ref_error_1.default;
17463	}
17464	});
17465	}));
17466
17467	//#endregion
17468	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv-formats/dist/formats.js
17469	var require_formats = /* @__PURE__ */ __commonJSMin(((exports) => {
17470	Object.defineProperty(exports, "__esModule", { value: true });
17471	exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
17472	function fmtDef(validate, compare) {
17473	return {
17474	validate,
17475	compare
17476	};
17477	}
17478	exports.fullFormats = {
17479	date: fmtDef(date, compareDate),
17480	time: fmtDef(getTime(true), compareTime),
17481	"date-time": fmtDef(getDateTime(true), compareDateTime),
17482	"iso-time": fmtDef(getTime(), compareIsoTime),
17483	"iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
17484	duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?\|(\d+W)?)$/,
17485	uri,
17486	"uri-reference": /^(?:[a-z][a-z0-9+\-.]:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()+,;=:]\|%[0-9a-f]{2})@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}\|::(?:[0-9a-f]{1,4}:){5}\|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}\|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}\|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}\|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:\|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}\|(?:(?:25[0-5]\|2[0-4]\d\|[01]?\d\d?)\.){3}(?:25[0-5]\|2[0-4]\d\|[01]?\d\d?))\|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}\|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)\|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()+,;=:]+)\]\|(?:(?:25[0-5]\|2[0-4]\d\|[01]?\d\d?)\.){3}(?:25[0-5]\|2[0-4]\d\|[01]?\d\d?)\|(?:[a-z0-9\-._~!$&'"()+,;=]\|%[0-9a-f]{2}))(?::\d)?(?:\/(?:[a-z0-9\-._~!$&'"()+,;=:@]\|%[0-9a-f]{2}))\|\/(?:(?:[a-z0-9\-._~!$&'"()+,;=:@]\|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()+,;=:@]\|%[0-9a-f]{2})))?\|(?:[a-z0-9\-._~!$&'"()+,;=:@]\|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()+,;=:@]\|%[0-9a-f]{2})))?(?:\?(?:[a-z0-9\-._~!$&'"()+,;=:@/?]\|%[0-9a-f]{2}))?(?:#(?:[a-z0-9\-._~!$&'"()+,;=:@/?]\|%[0-9a-f]{2}))?$/i,
17487	"uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{\|}]\|%[0-9a-f]{2})\|\{[+#./;?&=,!@\|]?(?:[a-z0-9_]\|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}\|\)?(?:,(?:[a-z0-9_]\|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}\|\)?)\})$/i,
17488	url: /^(?:https?\|ftp):\/\/(?:\S+(?::\S)?@)?(?:(?!(?:10\|127)(?:\.\d{1,3}){3})(?!(?:169\.254\|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]\|2\d\|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?\|1\d\d\|2[01]\d\|22[0-3])(?:\.(?:1?\d{1,2}\|2[0-4]\d\|25[0-5])){2}(?:\.(?:[1-9]\d?\|1\d\d\|2[0-4]\d\|25[0-4]))\|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
17489	email: /^[a-z0-9!#$%&'+/=?^_`{\|}~-]+(?:\.[a-z0-9!#$%&'+/=?^_`{\|}~-]+)@(?:[a-z0-9](?:[a-z0-9-][a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
17490	hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
17491	ipv4: /^(?:(?:25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)\.){3}(?:25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)$/,
17492	ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}\|:))\|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}\|((25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)(\.(25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)){3})\|:))\|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})\|:((25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)(\.(25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)){3})\|:))\|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})\|((:[0-9a-f]{1,4})?:((25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)(\.(25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)){3}))\|:))\|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})\|((:[0-9a-f]{1,4}){0,2}:((25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)(\.(25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)){3}))\|:))\|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})\|((:[0-9a-f]{1,4}){0,3}:((25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)(\.(25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)){3}))\|:))\|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})\|((:[0-9a-f]{1,4}){0,4}:((25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)(\.(25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)){3}))\|:))\|(:(((:[0-9a-f]{1,4}){1,7})\|((:[0-9a-f]{1,4}){0,5}:((25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)(\.(25[0-5]\|2[0-4]\d\|1\d\d\|[1-9]?\d)){3}))\|:)))$/i,
17493	regex,
17494	uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
17495	"json-pointer": /^(?:\/(?:[^~/]\|~0\|~1))$/,
17496	"json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()+,;:=@]\|%[0-9a-f]{2}\|~0\|~1))*$/i,
17497	"relative-json-pointer": /^(?:0\|[1-9][0-9])(?:#\|(?:\/(?:[^~/]\|~0\|~1))*)$/,
17498	byte,
17499	int32: {
17500	type: "number",
17501	validate: validateInt32
17502	},
17503	int64: {
17504	type: "number",
17505	validate: validateInt64
17506	},
17507	float: {
17508	type: "number",
17509	validate: validateNumber
17510	},
17511	double: {
17512	type: "number",
17513	validate: validateNumber
17514	},
17515	password: true,
17516	binary: true
17517	};
17518	exports.fastFormats = {
17519	...exports.fullFormats,
17520	date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
17521	time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d\|23:59:60)(?:\.\d+)?(?:z\|[+-]\d\d(?::?\d\d)?)$/i, compareTime),
17522	"date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d\|23:59:60)(?:\.\d+)?(?:z\|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime),
17523	"iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d\|23:59:60)(?:\.\d+)?(?:z\|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime),
17524	"iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d\|23:59:60)(?:\.\d+)?(?:z\|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime),
17525	uri: /^(?:[a-z][a-z0-9+\-.]:)(?:\/?\/)?[^\s]$/i,
17526	"uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]:)?\/?\/)?(?:[^\\\s#][^\s#])?(?:#[^\\\s]*)?$/i,
17527	email: /^[a-z0-9.!#$%&'+/=?^_`{\|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)$/i
17528	};
17529	exports.formatNames = Object.keys(exports.fullFormats);
17530	function isLeapYear(year) {
17531	return year % 4 === 0 && (year % 100 !== 0 \|\| year % 400 === 0);
17532	}
17533	var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
17534	var DAYS = [
17535	0,
17536	31,
17537	28,
17538	31,
17539	30,
17540	31,
17541	30,
17542	31,
17543	31,
17544	30,
17545	31,
17546	30,
17547	31
17548	];
17549	function date(str) {
17550	const matches = DATE.exec(str);
17551	if (!matches) return false;
17552	const year = +matches[1];
17553	const month = +matches[2];
17554	const day = +matches[3];
17555	return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
17556	}
17557	function compareDate(d1, d2) {
17558	if (!(d1 && d2)) return void 0;
17559	if (d1 > d2) return 1;
17560	if (d1 < d2) return -1;
17561	return 0;
17562	}
17563	var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z\|([+-])(\d\d)(?::?(\d\d))?)?$/i;
17564	function getTime(strictTimeZone) {
17565	return function time(str) {
17566	const matches = TIME.exec(str);
17567	if (!matches) return false;
17568	const hr = +matches[1];
17569	const min = +matches[2];
17570	const sec = +matches[3];
17571	const tz = matches[4];
17572	const tzSign = matches[5] === "-" ? -1 : 1;
17573	const tzH = +(matches[6] \|\| 0);
17574	const tzM = +(matches[7] \|\| 0);
17575	if (tzH > 23 \|\| tzM > 59 \|\| strictTimeZone && !tz) return false;
17576	if (hr <= 23 && min <= 59 && sec < 60) return true;
17577	const utcMin = min - tzM * tzSign;
17578	const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
17579	return (utcHr === 23 \|\| utcHr === -1) && (utcMin === 59 \|\| utcMin === -1) && sec < 61;
17580	};
17581	}
17582	function compareTime(s1, s2) {
17583	if (!(s1 && s2)) return void 0;
17584	const t1 = (/* @__PURE__ */ new Date("2020-01-01T" + s1)).valueOf();
17585	const t2 = (/* @__PURE__ */ new Date("2020-01-01T" + s2)).valueOf();
17586	if (!(t1 && t2)) return void 0;
17587	return t1 - t2;
17588	}
17589	function compareIsoTime(t1, t2) {
17590	if (!(t1 && t2)) return void 0;
17591	const a1 = TIME.exec(t1);
17592	const a2 = TIME.exec(t2);
17593	if (!(a1 && a2)) return void 0;
17594	t1 = a1[1] + a1[2] + a1[3];
17595	t2 = a2[1] + a2[2] + a2[3];
17596	if (t1 > t2) return 1;
17597	if (t1 < t2) return -1;
17598	return 0;
17599	}
17600	var DATE_TIME_SEPARATOR = /t\|\s/i;
17601	function getDateTime(strictTimeZone) {
17602	const time = getTime(strictTimeZone);
17603	return function date_time(str) {
17604	const dateTime = str.split(DATE_TIME_SEPARATOR);
17605	return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1]);
17606	};
17607	}
17608	function compareDateTime(dt1, dt2) {
17609	if (!(dt1 && dt2)) return void 0;
17610	const d1 = new Date(dt1).valueOf();
17611	const d2 = new Date(dt2).valueOf();
17612	if (!(d1 && d2)) return void 0;
17613	return d1 - d2;
17614	}
17615	function compareIsoDateTime(dt1, dt2) {
17616	if (!(dt1 && dt2)) return void 0;
17617	const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
17618	const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
17619	const res = compareDate(d1, d2);
17620	if (res === void 0) return void 0;
17621	return res \|\| compareTime(t1, t2);
17622	}
17623	var NOT_URI_FRAGMENT = /\/\|:/;
17624	var URI = /^(?:[a-z][a-z0-9+\-.]:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()+,;=:]\|%[0-9a-f]{2})@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}\|::(?:[0-9a-f]{1,4}:){5}\|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}\|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}\|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}\|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:\|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}\|(?:(?:25[0-5]\|2[0-4]\d\|[01]?\d\d?)\.){3}(?:25[0-5]\|2[0-4]\d\|[01]?\d\d?))\|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}\|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)\|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()+,;=:]+)\]\|(?:(?:25[0-5]\|2[0-4]\d\|[01]?\d\d?)\.){3}(?:25[0-5]\|2[0-4]\d\|[01]?\d\d?)\|(?:[a-z0-9\-._~!$&'()+,;=]\|%[0-9a-f]{2}))(?::\d)?(?:\/(?:[a-z0-9\-._~!$&'()+,;=:@]\|%[0-9a-f]{2}))\|\/(?:(?:[a-z0-9\-._~!$&'()+,;=:@]\|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()+,;=:@]\|%[0-9a-f]{2})))?\|(?:[a-z0-9\-._~!$&'()+,;=:@]\|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()+,;=:@]\|%[0-9a-f]{2})))(?:\?(?:[a-z0-9\-._~!$&'()+,;=:@/?]\|%[0-9a-f]{2}))?(?:#(?:[a-z0-9\-._~!$&'()+,;=:@/?]\|%[0-9a-f]{2}))?$/i;
17625	function uri(str) {
17626	return NOT_URI_FRAGMENT.test(str) && URI.test(str);
17627	}
17628	var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==\|[A-Za-z0-9+/]{3}=)?$/gm;
17629	function byte(str) {
17630	BYTE.lastIndex = 0;
17631	return BYTE.test(str);
17632	}
17633	var MIN_INT32 = -(2 ** 31);
17634	var MAX_INT32 = 2 ** 31 - 1;
17635	function validateInt32(value) {
17636	return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
17637	}
17638	function validateInt64(value) {
17639	return Number.isInteger(value);
17640	}
17641	function validateNumber() {
17642	return true;
17643	}
17644	var Z_ANCHOR = /[^\\]\\Z/;
17645	function regex(str) {
17646	if (Z_ANCHOR.test(str)) return false;
17647	try {
17648	new RegExp(str);
17649	return true;
17650	} catch (e) {
17651	return false;
17652	}
17653	}
17654	}));
17655
17656	//#endregion
17657	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv-formats/dist/limit.js
17658	var require_limit = /* @__PURE__ */ __commonJSMin(((exports) => {
17659	Object.defineProperty(exports, "__esModule", { value: true });
17660	exports.formatLimitDefinition = void 0;
17661	var ajv_1 = require_ajv();
17662	var codegen_1 = require_codegen();
17663	var ops = codegen_1.operators;
17664	var KWDs = {
17665	formatMaximum: {
17666	okStr: "<=",
17667	ok: ops.LTE,
17668	fail: ops.GT
17669	},
17670	formatMinimum: {
17671	okStr: ">=",
17672	ok: ops.GTE,
17673	fail: ops.LT
17674	},
17675	formatExclusiveMaximum: {
17676	okStr: "<",
17677	ok: ops.LT,
17678	fail: ops.GTE
17679	},
17680	formatExclusiveMinimum: {
17681	okStr: ">",
17682	ok: ops.GT,
17683	fail: ops.LTE
17684	}
17685	};
17686	var error = {
17687	message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
17688	params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
17689	};
17690	exports.formatLimitDefinition = {
17691	keyword: Object.keys(KWDs),
17692	type: "string",
17693	schemaType: "string",
17694	$data: true,
17695	error,
17696	code(cxt) {
17697	const { gen, data, schemaCode, keyword, it } = cxt;
17698	const { opts, self } = it;
17699	if (!opts.validateFormats) return;
17700	const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
17701	if (fCxt.$data) validate$DataFormat();
17702	else validateFormat();
17703	function validate$DataFormat() {
17704	const fmts = gen.scopeValue("formats", {
17705	ref: self.formats,
17706	code: opts.code.formats
17707	});
17708	const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`);
17709	cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
17710	}
17711	function validateFormat() {
17712	const format = fCxt.schema;
17713	const fmtDef = self.formats[format];
17714	if (!fmtDef \|\| fmtDef === true) return;
17715	if (typeof fmtDef != "object" \|\| fmtDef instanceof RegExp \|\| typeof fmtDef.compare != "function") throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
17716	const fmt = gen.scopeValue("formats", {
17717	key: format,
17718	ref: fmtDef,
17719	code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : void 0
17720	});
17721	cxt.fail$data(compareCode(fmt));
17722	}
17723	function compareCode(fmt) {
17724	return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
17725	}
17726	},
17727	dependencies: ["format"]
17728	};
17729	var formatLimitPlugin = (ajv) => {
17730	ajv.addKeyword(exports.formatLimitDefinition);
17731	return ajv;
17732	};
17733	exports.default = formatLimitPlugin;
17734	}));
17735
17736	//#endregion
17737	//#region node_modules/@modelcontextprotocol/sdk/node_modules/ajv-formats/dist/index.js
17738	var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
17739	Object.defineProperty(exports, "__esModule", { value: true });
17740	var formats_1 = require_formats();
17741	var limit_1 = require_limit();
17742	var codegen_1 = require_codegen();
17743	var fullName = new codegen_1.Name("fullFormats");
17744	var fastName = new codegen_1.Name("fastFormats");
17745	var formatsPlugin = (ajv, opts = { keywords: true }) => {
17746	if (Array.isArray(opts)) {
17747	addFormats(ajv, opts, formats_1.fullFormats, fullName);
17748	return ajv;
17749	}
17750	const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
17751	addFormats(ajv, opts.formats \|\| formats_1.formatNames, formats, exportName);
17752	if (opts.keywords) (0, limit_1.default)(ajv);
17753	return ajv;
17754	};
17755	formatsPlugin.get = (name, mode = "full") => {
17756	const f = (mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats)[name];
17757	if (!f) throw new Error(`Unknown format "${name}"`);
17758	return f;
17759	};
17760	function addFormats(ajv, list, fs, exportName) {
17761	var _a;
17762	var _b;
17763	(_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 \|\| (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
17764	for (const f of list) ajv.addFormat(f, fs[f]);
17765	}
17766	module.exports = exports = formatsPlugin;
17767	Object.defineProperty(exports, "__esModule", { value: true });
17768	exports.default = formatsPlugin;
17769	}));
17770
17771	//#endregion
17772	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
17773	var import_ajv = /* @__PURE__ */ __toESM(require_ajv(), 1);
17774	var import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
17775	function createDefaultAjvInstance() {
17776	const ajv = new import_ajv.default({
17777	strict: false,
17778	validateFormats: true,
17779	validateSchema: false,
17780	allErrors: true
17781	});
17782	(0, import_dist.default)(ajv);
17783	return ajv;
17784	}
17785	/**
17786	* @example
17787	* ```typescript
17788	* // Use with default AJV instance (recommended)
17789	* import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
17790	* const validator = new AjvJsonSchemaValidator();
17791	*
17792	* // Use with custom AJV instance
17793	* import { Ajv } from 'ajv';
17794	* const ajv = new Ajv({ strict: true, allErrors: true });
17795	* const validator = new AjvJsonSchemaValidator(ajv);
17796	* ```
17797	*/
17798	var AjvJsonSchemaValidator = class {
17799	/**
17800	* Create an AJV validator
17801	*
17802	* @param ajv - Optional pre-configured AJV instance. If not provided, a default instance will be created.
17803	*
17804	* @example
17805	* ```typescript
17806	* // Use default configuration (recommended for most cases)
17807	* import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
17808	* const validator = new AjvJsonSchemaValidator();
17809	*
17810	* // Or provide custom AJV instance for advanced configuration
17811	* import { Ajv } from 'ajv';
17812	* import addFormats from 'ajv-formats';
17813	*
17814	* const ajv = new Ajv({ validateFormats: true });
17815	* addFormats(ajv);
17816	* const validator = new AjvJsonSchemaValidator(ajv);
17817	* ```
17818	*/
17819	constructor(ajv) {
17820	this._ajv = ajv ?? createDefaultAjvInstance();
17821	}
17822	/**
17823	* Create a validator for the given JSON Schema
17824	*
17825	* The validator is compiled once and can be reused multiple times.
17826	* If the schema has an $id, it will be cached by AJV automatically.
17827	*
17828	* @param schema - Standard JSON Schema object
17829	* @returns A validator function that validates input data
17830	*/
17831	getValidator(schema) {
17832	const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
17833	return (input) => {
17834	if (ajvValidator(input)) return {
17835	valid: true,
17836	data: input,
17837	errorMessage: void 0
17838	};
17839	else return {
17840	valid: false,
17841	data: void 0,
17842	errorMessage: this._ajv.errorsText(ajvValidator.errors)
17843	};
17844	};
17845	}
17846	};
17847
17848	//#endregion
17849	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
17850	/**
17851	* Experimental server task features for MCP SDK.
17852	* WARNING: These APIs are experimental and may change without notice.
17853	*
17854	* @experimental
17855	*/
17856	/**
17857	* Experimental task features for low-level MCP servers.
17858	*
17859	* Access via `server.experimental.tasks`:
17860	* ```typescript
17861	* const stream = server.experimental.tasks.requestStream(request, schema, options);
17862	* ```
17863	*
17864	* For high-level server usage with task-based tools, use `McpServer.experimental.tasks` instead.
17865	*
17866	* @experimental
17867	*/
17868	var ExperimentalServerTasks = class {
17869	constructor(_server) {
17870	this._server = _server;
17871	}
17872	/**
17873	* Sends a request and returns an AsyncGenerator that yields response messages.
17874	* The generator is guaranteed to end with either a 'result' or 'error' message.
17875	*
17876	* This method provides streaming access to request processing, allowing you to
17877	* observe intermediate task status updates for task-augmented requests.
17878	*
17879	* @param request - The request to send
17880	* @param resultSchema - Zod schema for validating the result
17881	* @param options - Optional request options (timeout, signal, task creation params, etc.)
17882	* @returns AsyncGenerator that yields ResponseMessage objects
17883	*
17884	* @experimental
17885	*/
17886	requestStream(request, resultSchema, options) {
17887	return this._server.requestStream(request, resultSchema, options);
17888	}
17889	/**
17890	* Sends a sampling request and returns an AsyncGenerator that yields response messages.
17891	* The generator is guaranteed to end with either a 'result' or 'error' message.
17892	*
17893	* For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
17894	* before the final result.
17895	*
17896	* @example
17897	* ```typescript
17898	* const stream = server.experimental.tasks.createMessageStream({
17899	* messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
17900	* maxTokens: 100
17901	* }, {
17902	* onprogress: (progress) => {
17903	* // Handle streaming tokens via progress notifications
17904	* console.log('Progress:', progress.message);
17905	* }
17906	* });
17907	*
17908	* for await (const message of stream) {
17909	* switch (message.type) {
17910	* case 'taskCreated':
17911	* console.log('Task created:', message.task.taskId);
17912	* break;
17913	* case 'taskStatus':
17914	* console.log('Task status:', message.task.status);
17915	* break;
17916	* case 'result':
17917	* console.log('Final result:', message.result);
17918	* break;
17919	* case 'error':
17920	* console.error('Error:', message.error);
17921	* break;
17922	* }
17923	* }
17924	* ```
17925	*
17926	* @param params - The sampling request parameters
17927	* @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
17928	* @returns AsyncGenerator that yields ResponseMessage objects
17929	*
17930	* @experimental
17931	*/
17932	createMessageStream(params, options) {
17933	const clientCapabilities = this._server.getClientCapabilities();
17934	if ((params.tools \|\| params.toolChoice) && !clientCapabilities?.sampling?.tools) throw new Error("Client does not support sampling tools capability.");
17935	if (params.messages.length > 0) {
17936	const lastMessage = params.messages[params.messages.length - 1];
17937	const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
17938	const hasToolResults = lastContent.some((c) => c.type === "tool_result");
17939	const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
17940	const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
17941	const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
17942	if (hasToolResults) {
17943	if (lastContent.some((c) => c.type !== "tool_result")) throw new Error("The last message must contain only tool_result content if any is present");
17944	if (!hasPreviousToolUse) throw new Error("tool_result blocks are not matching any tool_use from the previous message");
17945	}
17946	if (hasPreviousToolUse) {
17947	const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
17948	const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
17949	if (toolUseIds.size !== toolResultIds.size \|\| ![...toolUseIds].every((id) => toolResultIds.has(id))) throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
17950	}
17951	}
17952	return this.requestStream({
17953	method: "sampling/createMessage",
17954	params
17955	}, CreateMessageResultSchema, options);
17956	}
17957	/**
17958	* Sends an elicitation request and returns an AsyncGenerator that yields response messages.
17959	* The generator is guaranteed to end with either a 'result' or 'error' message.
17960	*
17961	* For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
17962	* and 'taskStatus' messages before the final result.
17963	*
17964	* @example
17965	* ```typescript
17966	* const stream = server.experimental.tasks.elicitInputStream({
17967	* mode: 'url',
17968	* message: 'Please authenticate',
17969	* elicitationId: 'auth-123',
17970	* url: 'https://example.com/auth'
17971	* }, {
17972	* task: { ttl: 300000 } // Task-augmented for long-running auth flow
17973	* });
17974	*
17975	* for await (const message of stream) {
17976	* switch (message.type) {
17977	* case 'taskCreated':
17978	* console.log('Task created:', message.task.taskId);
17979	* break;
17980	* case 'taskStatus':
17981	* console.log('Task status:', message.task.status);
17982	* break;
17983	* case 'result':
17984	* console.log('User action:', message.result.action);
17985	* break;
17986	* case 'error':
17987	* console.error('Error:', message.error);
17988	* break;
17989	* }
17990	* }
17991	* ```
17992	*
17993	* @param params - The elicitation request parameters
17994	* @param options - Optional request options (timeout, signal, task creation params, etc.)
17995	* @returns AsyncGenerator that yields ResponseMessage objects
17996	*
17997	* @experimental
17998	*/
17999	elicitInputStream(params, options) {
18000	const clientCapabilities = this._server.getClientCapabilities();
18001	const mode = params.mode ?? "form";
18002	switch (mode) {
18003	case "url":
18004	if (!clientCapabilities?.elicitation?.url) throw new Error("Client does not support url elicitation.");
18005	break;
18006	case "form":
18007	if (!clientCapabilities?.elicitation?.form) throw new Error("Client does not support form elicitation.");
18008	break;
18009	}
18010	const normalizedParams = mode === "form" && params.mode === void 0 ? {
18011	...params,
18012	mode: "form"
18013	} : params;
18014	return this.requestStream({
18015	method: "elicitation/create",
18016	params: normalizedParams
18017	}, ElicitResultSchema, options);
18018	}
18019	/**
18020	* Gets the current status of a task.
18021	*
18022	* @param taskId - The task identifier
18023	* @param options - Optional request options
18024	* @returns The task status
18025	*
18026	* @experimental
18027	*/
18028	async getTask(taskId, options) {
18029	return this._server.getTask({ taskId }, options);
18030	}
18031	/**
18032	* Retrieves the result of a completed task.
18033	*
18034	* @param taskId - The task identifier
18035	* @param resultSchema - Zod schema for validating the result
18036	* @param options - Optional request options
18037	* @returns The task result
18038	*
18039	* @experimental
18040	*/
18041	async getTaskResult(taskId, resultSchema, options) {
18042	return this._server.getTaskResult({ taskId }, resultSchema, options);
18043	}
18044	/**
18045	* Lists tasks with optional pagination.
18046	*
18047	* @param cursor - Optional pagination cursor
18048	* @param options - Optional request options
18049	* @returns List of tasks with optional next cursor
18050	*
18051	* @experimental
18052	*/
18053	async listTasks(cursor, options) {
18054	return this._server.listTasks(cursor ? { cursor } : void 0, options);
18055	}
18056	/**
18057	* Cancels a running task.
18058	*
18059	* @param taskId - The task identifier
18060	* @param options - Optional request options
18061	*
18062	* @experimental
18063	*/
18064	async cancelTask(taskId, options) {
18065	return this._server.cancelTask({ taskId }, options);
18066	}
18067	};
18068
18069	//#endregion
18070	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
18071	/**
18072	* Experimental task capability assertion helpers.
18073	* WARNING: These APIs are experimental and may change without notice.
18074	*
18075	* @experimental
18076	*/
18077	/**
18078	* Asserts that task creation is supported for tools/call.
18079	* Used by Client.assertTaskCapability and Server.assertTaskHandlerCapability.
18080	*
18081	* @param requests - The task requests capability object
18082	* @param method - The method being checked
18083	* @param entityName - 'Server' or 'Client' for error messages
18084	* @throws Error if the capability is not supported
18085	*
18086	* @experimental
18087	*/
18088	function assertToolsCallTaskCapability(requests, method, entityName) {
18089	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
18090	switch (method) {
18091	case "tools/call":
18092	if (!requests.tools?.call) throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
18093	break;
18094	default: break;
18095	}
18096	}
18097	/**
18098	* Asserts that task creation is supported for sampling/createMessage or elicitation/create.
18099	* Used by Server.assertTaskCapability and Client.assertTaskHandlerCapability.
18100	*
18101	* @param requests - The task requests capability object
18102	* @param method - The method being checked
18103	* @param entityName - 'Server' or 'Client' for error messages
18104	* @throws Error if the capability is not supported
18105	*
18106	* @experimental
18107	*/
18108	function assertClientRequestTaskCapability(requests, method, entityName) {
18109	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
18110	switch (method) {
18111	case "sampling/createMessage":
18112	if (!requests.sampling?.createMessage) throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
18113	break;
18114	case "elicitation/create":
18115	if (!requests.elicitation?.create) throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
18116	break;
18117	default: break;
18118	}
18119	}
18120
18121	//#endregion
18122	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
18123	/**
18124	* An MCP server on top of a pluggable transport.
18125	*
18126	* This server will automatically respond to the initialization flow as initiated from the client.
18127	*
18128	* To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
18129	*
18130	* ```typescript
18131	* // Custom schemas
18132	* const CustomRequestSchema = RequestSchema.extend({...})
18133	* const CustomNotificationSchema = NotificationSchema.extend({...})
18134	* const CustomResultSchema = ResultSchema.extend({...})
18135	*
18136	* // Type aliases
18137	* type CustomRequest = z.infer<typeof CustomRequestSchema>
18138	* type CustomNotification = z.infer<typeof CustomNotificationSchema>
18139	* type CustomResult = z.infer<typeof CustomResultSchema>
18140	*
18141	* // Create typed server
18142	* const server = new Server<CustomRequest, CustomNotification, CustomResult>({
18143	* name: "CustomServer",
18144	* version: "1.0.0"
18145	* })
18146	* ```
18147	* @deprecated Use `McpServer` instead for the high-level API. Only use `Server` for advanced use cases.
18148	*/
18149	var Server = class extends Protocol {
18150	/**
18151	* Initializes this server with the given name and version information.
18152	*/
18153	constructor(_serverInfo, options) {
18154	super(options);
18155	this._serverInfo = _serverInfo;
18156	this._loggingLevels = /* @__PURE__ */ new Map();
18157	this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
18158	this.isMessageIgnored = (level, sessionId) => {
18159	const currentLevel = this._loggingLevels.get(sessionId);
18160	return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
18161	};
18162	this._capabilities = options?.capabilities ?? {};
18163	this._instructions = options?.instructions;
18164	this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
18165	this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
18166	this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
18167	if (this._capabilities.logging) this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
18168	const transportSessionId = extra.sessionId \|\| extra.requestInfo?.headers["mcp-session-id"] \|\| void 0;
18169	const { level } = request.params;
18170	const parseResult = LoggingLevelSchema.safeParse(level);
18171	if (parseResult.success) this._loggingLevels.set(transportSessionId, parseResult.data);
18172	return {};
18173	});
18174	}
18175	/**
18176	* Access experimental features.
18177	*
18178	* WARNING: These APIs are experimental and may change without notice.
18179	*
18180	* @experimental
18181	*/
18182	get experimental() {
18183	if (!this._experimental) this._experimental = { tasks: new ExperimentalServerTasks(this) };
18184	return this._experimental;
18185	}
18186	/**
18187	* Registers new capabilities. This can only be called before connecting to a transport.
18188	*
18189	* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
18190	*/
18191	registerCapabilities(capabilities) {
18192	if (this.transport) throw new Error("Cannot register capabilities after connecting to transport");
18193	this._capabilities = mergeCapabilities(this._capabilities, capabilities);
18194	}
18195	/**
18196	* Override request handler registration to enforce server-side validation for tools/call.
18197	*/
18198	setRequestHandler(requestSchema, handler) {
18199	const methodSchema = getObjectShape(requestSchema)?.method;
18200	if (!methodSchema) throw new Error("Schema is missing a method literal");
18201	let methodValue;
18202	if (isZ4Schema(methodSchema)) {
18203	const v4Schema = methodSchema;
18204	methodValue = (v4Schema._zod?.def)?.value ?? v4Schema.value;
18205	} else {
18206	const v3Schema = methodSchema;
18207	methodValue = v3Schema._def?.value ?? v3Schema.value;
18208	}
18209	if (typeof methodValue !== "string") throw new Error("Schema method literal must be a string");
18210	if (methodValue === "tools/call") {
18211	const wrappedHandler = async (request, extra) => {
18212	const validatedRequest = safeParse$1(CallToolRequestSchema, request);
18213	if (!validatedRequest.success) {
18214	const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
18215	throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
18216	}
18217	const { params } = validatedRequest.data;
18218	const result = await Promise.resolve(handler(request, extra));
18219	if (params.task) {
18220	const taskValidationResult = safeParse$1(CreateTaskResultSchema, result);
18221	if (!taskValidationResult.success) {
18222	const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
18223	throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
18224	}
18225	return taskValidationResult.data;
18226	}
18227	const validationResult = safeParse$1(CallToolResultSchema, result);
18228	if (!validationResult.success) {
18229	const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
18230	throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
18231	}
18232	return validationResult.data;
18233	};
18234	return super.setRequestHandler(requestSchema, wrappedHandler);
18235	}
18236	return super.setRequestHandler(requestSchema, handler);
18237	}
18238	assertCapabilityForMethod(method) {
18239	switch (method) {
18240	case "sampling/createMessage":
18241	if (!this._clientCapabilities?.sampling) throw new Error(`Client does not support sampling (required for ${method})`);
18242	break;
18243	case "elicitation/create":
18244	if (!this._clientCapabilities?.elicitation) throw new Error(`Client does not support elicitation (required for ${method})`);
18245	break;
18246	case "roots/list":
18247	if (!this._clientCapabilities?.roots) throw new Error(`Client does not support listing roots (required for ${method})`);
18248	break;
18249	case "ping": break;
18250	}
18251	}
18252	assertNotificationCapability(method) {
18253	switch (method) {
18254	case "notifications/message":
18255	if (!this._capabilities.logging) throw new Error(`Server does not support logging (required for ${method})`);
18256	break;
18257	case "notifications/resources/updated":
18258	case "notifications/resources/list_changed":
18259	if (!this._capabilities.resources) throw new Error(`Server does not support notifying about resources (required for ${method})`);
18260	break;
18261	case "notifications/tools/list_changed":
18262	if (!this._capabilities.tools) throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
18263	break;
18264	case "notifications/prompts/list_changed":
18265	if (!this._capabilities.prompts) throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
18266	break;
18267	case "notifications/elicitation/complete":
18268	if (!this._clientCapabilities?.elicitation?.url) throw new Error(`Client does not support URL elicitation (required for ${method})`);
18269	break;
18270	case "notifications/cancelled": break;
18271	case "notifications/progress": break;
18272	}
18273	}
18274	assertRequestHandlerCapability(method) {
18275	if (!this._capabilities) return;
18276	switch (method) {
18277	case "completion/complete":
18278	if (!this._capabilities.completions) throw new Error(`Server does not support completions (required for ${method})`);
18279	break;
18280	case "logging/setLevel":
18281	if (!this._capabilities.logging) throw new Error(`Server does not support logging (required for ${method})`);
18282	break;
18283	case "prompts/get":
18284	case "prompts/list":
18285	if (!this._capabilities.prompts) throw new Error(`Server does not support prompts (required for ${method})`);
18286	break;
18287	case "resources/list":
18288	case "resources/templates/list":
18289	case "resources/read":
18290	if (!this._capabilities.resources) throw new Error(`Server does not support resources (required for ${method})`);
18291	break;
18292	case "tools/call":
18293	case "tools/list":
18294	if (!this._capabilities.tools) throw new Error(`Server does not support tools (required for ${method})`);
18295	break;
18296	case "tasks/get":
18297	case "tasks/list":
18298	case "tasks/result":
18299	case "tasks/cancel":
18300	if (!this._capabilities.tasks) throw new Error(`Server does not support tasks capability (required for ${method})`);
18301	break;
18302	case "ping":
18303	case "initialize": break;
18304	}
18305	}
18306	assertTaskCapability(method) {
18307	assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
18308	}
18309	assertTaskHandlerCapability(method) {
18310	if (!this._capabilities) return;
18311	assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
18312	}
18313	async _oninitialize(request) {
18314	const requestedVersion = request.params.protocolVersion;
18315	this._clientCapabilities = request.params.capabilities;
18316	this._clientVersion = request.params.clientInfo;
18317	return {
18318	protocolVersion: SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION,
18319	capabilities: this.getCapabilities(),
18320	serverInfo: this._serverInfo,
18321	...this._instructions && { instructions: this._instructions }
18322	};
18323	}
18324	/**
18325	* After initialization has completed, this will be populated with the client's reported capabilities.
18326	*/
18327	getClientCapabilities() {
18328	return this._clientCapabilities;
18329	}
18330	/**
18331	* After initialization has completed, this will be populated with information about the client's name and version.
18332	*/
18333	getClientVersion() {
18334	return this._clientVersion;
18335	}
18336	getCapabilities() {
18337	return this._capabilities;
18338	}
18339	async ping() {
18340	return this.request({ method: "ping" }, EmptyResultSchema);
18341	}
18342	async createMessage(params, options) {
18343	if (params.tools \|\| params.toolChoice) {
18344	if (!this._clientCapabilities?.sampling?.tools) throw new Error("Client does not support sampling tools capability.");
18345	}
18346	if (params.messages.length > 0) {
18347	const lastMessage = params.messages[params.messages.length - 1];
18348	const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
18349	const hasToolResults = lastContent.some((c) => c.type === "tool_result");
18350	const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
18351	const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
18352	const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
18353	if (hasToolResults) {
18354	if (lastContent.some((c) => c.type !== "tool_result")) throw new Error("The last message must contain only tool_result content if any is present");
18355	if (!hasPreviousToolUse) throw new Error("tool_result blocks are not matching any tool_use from the previous message");
18356	}
18357	if (hasPreviousToolUse) {
18358	const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
18359	const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
18360	if (toolUseIds.size !== toolResultIds.size \|\| ![...toolUseIds].every((id) => toolResultIds.has(id))) throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
18361	}
18362	}
18363	if (params.tools) return this.request({
18364	method: "sampling/createMessage",
18365	params
18366	}, CreateMessageResultWithToolsSchema, options);
18367	return this.request({
18368	method: "sampling/createMessage",
18369	params
18370	}, CreateMessageResultSchema, options);
18371	}
18372	/**
18373	* Creates an elicitation request for the given parameters.
18374	* For backwards compatibility, `mode` may be omitted for form requests and will default to `'form'`.
18375	* @param params The parameters for the elicitation request.
18376	* @param options Optional request options.
18377	* @returns The result of the elicitation request.
18378	*/
18379	async elicitInput(params, options) {
18380	switch (params.mode ?? "form") {
18381	case "url": {
18382	if (!this._clientCapabilities?.elicitation?.url) throw new Error("Client does not support url elicitation.");
18383	const urlParams = params;
18384	return this.request({
18385	method: "elicitation/create",
18386	params: urlParams
18387	}, ElicitResultSchema, options);
18388	}
18389	case "form": {
18390	if (!this._clientCapabilities?.elicitation?.form) throw new Error("Client does not support form elicitation.");
18391	const formParams = params.mode === "form" ? params : {
18392	...params,
18393	mode: "form"
18394	};
18395	const result = await this.request({
18396	method: "elicitation/create",
18397	params: formParams
18398	}, ElicitResultSchema, options);
18399	if (result.action === "accept" && result.content && formParams.requestedSchema) try {
18400	const validationResult = this._jsonSchemaValidator.getValidator(formParams.requestedSchema)(result.content);
18401	if (!validationResult.valid) throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
18402	} catch (error) {
18403	if (error instanceof McpError) throw error;
18404	throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error instanceof Error ? error.message : String(error)}`);
18405	}
18406	return result;
18407	}
18408	}
18409	}
18410	/**
18411	* Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete`
18412	* notification for the specified elicitation ID.
18413	*
18414	* @param elicitationId The ID of the elicitation to mark as complete.
18415	* @param options Optional notification options. Useful when the completion notification should be related to a prior request.
18416	* @returns A function that emits the completion notification when awaited.
18417	*/
18418	createElicitationCompletionNotifier(elicitationId, options) {
18419	if (!this._clientCapabilities?.elicitation?.url) throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
18420	return () => this.notification({
18421	method: "notifications/elicitation/complete",
18422	params: { elicitationId }
18423	}, options);
18424	}
18425	async listRoots(params, options) {
18426	return this.request({
18427	method: "roots/list",
18428	params
18429	}, ListRootsResultSchema, options);
18430	}
18431	/**
18432	* Sends a logging message to the client, if connected.
18433	* Note: You only need to send the parameters object, not the entire JSON RPC message
18434	* @see LoggingMessageNotification
18435	* @param params
18436	* @param sessionId optional for stateless and backward compatibility
18437	*/
18438	async sendLoggingMessage(params, sessionId) {
18439	if (this._capabilities.logging) {
18440	if (!this.isMessageIgnored(params.level, sessionId)) return this.notification({
18441	method: "notifications/message",
18442	params
18443	});
18444	}
18445	}
18446	async sendResourceUpdated(params) {
18447	return this.notification({
18448	method: "notifications/resources/updated",
18449	params
18450	});
18451	}
18452	async sendResourceListChanged() {
18453	return this.notification({ method: "notifications/resources/list_changed" });
18454	}
18455	async sendToolListChanged() {
18456	return this.notification({ method: "notifications/tools/list_changed" });
18457	}
18458	async sendPromptListChanged() {
18459	return this.notification({ method: "notifications/prompts/list_changed" });
18460	}
18461	};
18462
18463	//#endregion
18464	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
18465	var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
18466	/**
18467	* Checks if a schema is completable (has completion metadata).
18468	*/
18469	function isCompletable(schema) {
18470	return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
18471	}
18472	/**
18473	* Gets the completer callback from a completable schema, if it exists.
18474	*/
18475	function getCompleter(schema) {
18476	return schema[COMPLETABLE_SYMBOL]?.complete;
18477	}
18478	var McpZodTypeKind;
18479	(function(McpZodTypeKind) {
18480	McpZodTypeKind["Completable"] = "McpCompletable";
18481	})(McpZodTypeKind \|\| (McpZodTypeKind = {}));
18482
18483	//#endregion
18484	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/shared/uriTemplate.js
18485	var MAX_TEMPLATE_LENGTH = 1e6;
18486	var MAX_VARIABLE_LENGTH = 1e6;
18487	var MAX_TEMPLATE_EXPRESSIONS = 1e4;
18488	var MAX_REGEX_LENGTH = 1e6;
18489	var UriTemplate = class UriTemplate {
18490	/**
18491	* Returns true if the given string contains any URI template expressions.
18492	* A template expression is a sequence of characters enclosed in curly braces,
18493	* like {foo} or {?bar}.
18494	*/
18495	static isTemplate(str) {
18496	return /\{[^}\s]+\}/.test(str);
18497	}
18498	static validateLength(str, max, context) {
18499	if (str.length > max) throw new Error(`${context} exceeds maximum length of ${max} characters (got ${str.length})`);
18500	}
18501	get variableNames() {
18502	return this.parts.flatMap((part) => typeof part === "string" ? [] : part.names);
18503	}
18504	constructor(template) {
18505	UriTemplate.validateLength(template, MAX_TEMPLATE_LENGTH, "Template");
18506	this.template = template;
18507	this.parts = this.parse(template);
18508	}
18509	toString() {
18510	return this.template;
18511	}
18512	parse(template) {
18513	const parts = [];
18514	let currentText = "";
18515	let i = 0;
18516	let expressionCount = 0;
18517	while (i < template.length) if (template[i] === "{") {
18518	if (currentText) {
18519	parts.push(currentText);
18520	currentText = "";
18521	}
18522	const end = template.indexOf("}", i);
18523	if (end === -1) throw new Error("Unclosed template expression");
18524	expressionCount++;
18525	if (expressionCount > MAX_TEMPLATE_EXPRESSIONS) throw new Error(`Template contains too many expressions (max ${MAX_TEMPLATE_EXPRESSIONS})`);
18526	const expr = template.slice(i + 1, end);
18527	const operator = this.getOperator(expr);
18528	const exploded = expr.includes("*");
18529	const names = this.getNames(expr);
18530	const name = names[0];
18531	for (const name of names) UriTemplate.validateLength(name, MAX_VARIABLE_LENGTH, "Variable name");
18532	parts.push({
18533	name,
18534	operator,
18535	names,
18536	exploded
18537	});
18538	i = end + 1;
18539	} else {
18540	currentText += template[i];
18541	i++;
18542	}
18543	if (currentText) parts.push(currentText);
18544	return parts;
18545	}
18546	getOperator(expr) {
18547	return [
18548	"+",
18549	"#",
18550	".",
18551	"/",
18552	"?",
18553	"&"
18554	].find((op) => expr.startsWith(op)) \|\| "";
18555	}
18556	getNames(expr) {
18557	const operator = this.getOperator(expr);
18558	return expr.slice(operator.length).split(",").map((name) => name.replace("*", "").trim()).filter((name) => name.length > 0);
18559	}
18560	encodeValue(value, operator) {
18561	UriTemplate.validateLength(value, MAX_VARIABLE_LENGTH, "Variable value");
18562	if (operator === "+" \|\| operator === "#") return encodeURI(value);
18563	return encodeURIComponent(value);
18564	}
18565	expandPart(part, variables) {
18566	if (part.operator === "?" \|\| part.operator === "&") {
18567	const pairs = part.names.map((name) => {
18568	const value = variables[name];
18569	if (value === void 0) return "";
18570	return `${name}=${Array.isArray(value) ? value.map((v) => this.encodeValue(v, part.operator)).join(",") : this.encodeValue(value.toString(), part.operator)}`;
18571	}).filter((pair) => pair.length > 0);
18572	if (pairs.length === 0) return "";
18573	return (part.operator === "?" ? "?" : "&") + pairs.join("&");
18574	}
18575	if (part.names.length > 1) {
18576	const values = part.names.map((name) => variables[name]).filter((v) => v !== void 0);
18577	if (values.length === 0) return "";
18578	return values.map((v) => Array.isArray(v) ? v[0] : v).join(",");
18579	}
18580	const value = variables[part.name];
18581	if (value === void 0) return "";
18582	const encoded = (Array.isArray(value) ? value : [value]).map((v) => this.encodeValue(v, part.operator));
18583	switch (part.operator) {
18584	case "": return encoded.join(",");
18585	case "+": return encoded.join(",");
18586	case "#": return "#" + encoded.join(",");
18587	case ".": return "." + encoded.join(".");
18588	case "/": return "/" + encoded.join("/");
18589	default: return encoded.join(",");
18590	}
18591	}
18592	expand(variables) {
18593	let result = "";
18594	let hasQueryParam = false;
18595	for (const part of this.parts) {
18596	if (typeof part === "string") {
18597	result += part;
18598	continue;
18599	}
18600	const expanded = this.expandPart(part, variables);
18601	if (!expanded) continue;
18602	if ((part.operator === "?" \|\| part.operator === "&") && hasQueryParam) result += expanded.replace("?", "&");
18603	else result += expanded;
18604	if (part.operator === "?" \|\| part.operator === "&") hasQueryParam = true;
18605	}
18606	return result;
18607	}
18608	escapeRegExp(str) {
18609	return str.replace(/[.*+?^${}()\|[\]\\]/g, "\\$&");
18610	}
18611	partToRegExp(part) {
18612	const patterns = [];
18613	for (const name of part.names) UriTemplate.validateLength(name, MAX_VARIABLE_LENGTH, "Variable name");
18614	if (part.operator === "?" \|\| part.operator === "&") {
18615	for (let i = 0; i < part.names.length; i++) {
18616	const name = part.names[i];
18617	const prefix = i === 0 ? "\\" + part.operator : "&";
18618	patterns.push({
18619	pattern: prefix + this.escapeRegExp(name) + "=([^&]+)",
18620	name
18621	});
18622	}
18623	return patterns;
18624	}
18625	let pattern;
18626	const name = part.name;
18627	switch (part.operator) {
18628	case "":
18629	pattern = part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)";
18630	break;
18631	case "+":
18632	case "#":
18633	pattern = "(.+)";
18634	break;
18635	case ".":
18636	pattern = "\\.([^/,]+)";
18637	break;
18638	case "/":
18639	pattern = "/" + (part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)");
18640	break;
18641	default: pattern = "([^/]+)";
18642	}
18643	patterns.push({
18644	pattern,
18645	name
18646	});
18647	return patterns;
18648	}
18649	match(uri) {
18650	UriTemplate.validateLength(uri, MAX_TEMPLATE_LENGTH, "URI");
18651	let pattern = "^";
18652	const names = [];
18653	for (const part of this.parts) if (typeof part === "string") pattern += this.escapeRegExp(part);
18654	else {
18655	const patterns = this.partToRegExp(part);
18656	for (const { pattern: partPattern, name } of patterns) {
18657	pattern += partPattern;
18658	names.push({
18659	name,
18660	exploded: part.exploded
18661	});
18662	}
18663	}
18664	pattern += "$";
18665	UriTemplate.validateLength(pattern, MAX_REGEX_LENGTH, "Generated regex pattern");
18666	const regex = new RegExp(pattern);
18667	const match = uri.match(regex);
18668	if (!match) return null;
18669	const result = {};
18670	for (let i = 0; i < names.length; i++) {
18671	const { name, exploded } = names[i];
18672	const value = match[i + 1];
18673	const cleanName = name.replace("*", "");
18674	if (exploded && value.includes(",")) result[cleanName] = value.split(",");
18675	else result[cleanName] = value;
18676	}
18677	return result;
18678	}
18679	};
18680
18681	//#endregion
18682	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
18683	/**
18684	* Tool name validation utilities according to SEP: Specify Format for Tool Names
18685	*
18686	* Tool names SHOULD be between 1 and 128 characters in length (inclusive).
18687	* Tool names are case-sensitive.
18688	* Allowed characters: uppercase and lowercase ASCII letters (A-Z, a-z), digits
18689	* (0-9), underscore (_), dash (-), and dot (.).
18690	* Tool names SHOULD NOT contain spaces, commas, or other special characters.
18691	*/
18692	/**
18693	* Regular expression for valid tool names according to SEP-986 specification
18694	*/
18695	var TOOL_NAME_REGEX = /^[A-Za-z0-9._-]{1,128}$/;
18696	/**
18697	* Validates a tool name according to the SEP specification
18698	* @param name - The tool name to validate
18699	* @returns An object containing validation result and any warnings
18700	*/
18701	function validateToolName(name) {
18702	const warnings = [];
18703	if (name.length === 0) return {
18704	isValid: false,
18705	warnings: ["Tool name cannot be empty"]
18706	};
18707	if (name.length > 128) return {
18708	isValid: false,
18709	warnings: [`Tool name exceeds maximum length of 128 characters (current: ${name.length})`]
18710	};
18711	if (name.includes(" ")) warnings.push("Tool name contains spaces, which may cause parsing issues");
18712	if (name.includes(",")) warnings.push("Tool name contains commas, which may cause parsing issues");
18713	if (name.startsWith("-") \|\| name.endsWith("-")) warnings.push("Tool name starts or ends with a dash, which may cause parsing issues in some contexts");
18714	if (name.startsWith(".") \|\| name.endsWith(".")) warnings.push("Tool name starts or ends with a dot, which may cause parsing issues in some contexts");
18715	if (!TOOL_NAME_REGEX.test(name)) {
18716	const invalidChars = name.split("").filter((char) => !/[A-Za-z0-9._-]/.test(char)).filter((char, index, arr) => arr.indexOf(char) === index);
18717	warnings.push(`Tool name contains invalid characters: ${invalidChars.map((c) => `"${c}"`).join(", ")}`, "Allowed characters are: A-Z, a-z, 0-9, underscore (_), dash (-), and dot (.)");
18718	return {
18719	isValid: false,
18720	warnings
18721	};
18722	}
18723	return {
18724	isValid: true,
18725	warnings
18726	};
18727	}
18728	/**
18729	* Issues warnings for non-conforming tool names
18730	* @param name - The tool name that triggered the warnings
18731	* @param warnings - Array of warning messages
18732	*/
18733	function issueToolNameWarning(name, warnings) {
18734	if (warnings.length > 0) {
18735	console.warn(`Tool name validation warning for "${name}":`);
18736	for (const warning of warnings) console.warn(` - ${warning}`);
18737	console.warn("Tool registration will proceed, but this may cause compatibility issues.");
18738	console.warn("Consider updating the tool name to conform to the MCP tool naming standard.");
18739	console.warn("See SEP: Specify Format for Tool Names (https://github.com/modelcontextprotocol/modelcontextprotocol/issues/986) for more details.");
18740	}
18741	}
18742	/**
18743	* Validates a tool name and issues warnings for non-conforming names
18744	* @param name - The tool name to validate
18745	* @returns true if the name is valid, false otherwise
18746	*/
18747	function validateAndWarnToolName(name) {
18748	const result = validateToolName(name);
18749	issueToolNameWarning(name, result.warnings);
18750	return result.isValid;
18751	}
18752
18753	//#endregion
18754	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js
18755	/**
18756	* Experimental McpServer task features for MCP SDK.
18757	* WARNING: These APIs are experimental and may change without notice.
18758	*
18759	* @experimental
18760	*/
18761	/**
18762	* Experimental task features for McpServer.
18763	*
18764	* Access via `server.experimental.tasks`:
18765	* ```typescript
18766	* server.experimental.tasks.registerToolTask('long-running', config, handler);
18767	* ```
18768	*
18769	* @experimental
18770	*/
18771	var ExperimentalMcpServerTasks = class {
18772	constructor(_mcpServer) {
18773	this._mcpServer = _mcpServer;
18774	}
18775	registerToolTask(name, config, handler) {
18776	const execution = {
18777	taskSupport: "required",
18778	...config.execution
18779	};
18780	if (execution.taskSupport === "forbidden") throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
18781	return this._mcpServer._createRegisteredTool(name, config.title, config.description, config.inputSchema, config.outputSchema, config.annotations, execution, config._meta, handler);
18782	}
18783	};
18784
18785	//#endregion
18786	//#region node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
18787	/**
18788	* High-level MCP server that provides a simpler API for working with resources, tools, and prompts.
18789	* For advanced usage (like sending notifications or setting custom request handlers), use the underlying
18790	* Server instance available via the `server` property.
18791	*/
18792	var McpServer = class {
18793	constructor(serverInfo, options) {
18794	this._registeredResources = {};
18795	this._registeredResourceTemplates = {};
18796	this._registeredTools = {};
18797	this._registeredPrompts = {};
18798	this._toolHandlersInitialized = false;
18799	this._completionHandlerInitialized = false;
18800	this._resourceHandlersInitialized = false;
18801	this._promptHandlersInitialized = false;
18802	this.server = new Server(serverInfo, options);
18803	}
18804	/**
18805	* Access experimental features.
18806	*
18807	* WARNING: These APIs are experimental and may change without notice.
18808	*
18809	* @experimental
18810	*/
18811	get experimental() {
18812	if (!this._experimental) this._experimental = { tasks: new ExperimentalMcpServerTasks(this) };
18813	return this._experimental;
18814	}
18815	/**
18816	* Attaches to the given transport, starts it, and starts listening for messages.
18817	*
18818	* The `server` object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
18819	*/
18820	async connect(transport) {
18821	return await this.server.connect(transport);
18822	}
18823	/**
18824	* Closes the connection.
18825	*/
18826	async close() {
18827	await this.server.close();
18828	}
18829	setToolRequestHandlers() {
18830	if (this._toolHandlersInitialized) return;
18831	this.server.assertCanSetRequestHandler(getMethodValue(ListToolsRequestSchema));
18832	this.server.assertCanSetRequestHandler(getMethodValue(CallToolRequestSchema));
18833	this.server.registerCapabilities({ tools: { listChanged: true } });
18834	this.server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: Object.entries(this._registeredTools).filter(([, tool]) => tool.enabled).map(([name, tool]) => {
18835	const toolDefinition = {
18836	name,
18837	title: tool.title,
18838	description: tool.description,
18839	inputSchema: (() => {
18840	const obj = normalizeObjectSchema(tool.inputSchema);
18841	return obj ? toJsonSchemaCompat(obj, {
18842	strictUnions: true,
18843	pipeStrategy: "input"
18844	}) : EMPTY_OBJECT_JSON_SCHEMA;
18845	})(),
18846	annotations: tool.annotations,
18847	execution: tool.execution,
18848	_meta: tool._meta
18849	};
18850	if (tool.outputSchema) {
18851	const obj = normalizeObjectSchema(tool.outputSchema);
18852	if (obj) toolDefinition.outputSchema = toJsonSchemaCompat(obj, {
18853	strictUnions: true,
18854	pipeStrategy: "output"
18855	});
18856	}
18857	return toolDefinition;
18858	}) }));
18859	this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
18860	try {
18861	const tool = this._registeredTools[request.params.name];
18862	if (!tool) throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
18863	if (!tool.enabled) throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
18864	const isTaskRequest = !!request.params.task;
18865	const taskSupport = tool.execution?.taskSupport;
18866	const isTaskHandler = "createTask" in tool.handler;
18867	if ((taskSupport === "required" \|\| taskSupport === "optional") && !isTaskHandler) throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
18868	if (taskSupport === "required" && !isTaskRequest) throw new McpError(ErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
18869	if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) return await this.handleAutomaticTaskPolling(tool, request, extra);
18870	const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
18871	const result = await this.executeToolHandler(tool, args, extra);
18872	if (isTaskRequest) return result;
18873	await this.validateToolOutput(tool, result, request.params.name);
18874	return result;
18875	} catch (error) {
18876	if (error instanceof McpError) {
18877	if (error.code === ErrorCode.UrlElicitationRequired) throw error;
18878	}
18879	return this.createToolError(error instanceof Error ? error.message : String(error));
18880	}
18881	});
18882	this._toolHandlersInitialized = true;
18883	}
18884	/**
18885	* Creates a tool error result.
18886	*
18887	* @param errorMessage - The error message.
18888	* @returns The tool error result.
18889	*/
18890	createToolError(errorMessage) {
18891	return {
18892	content: [{
18893	type: "text",
18894	text: errorMessage
18895	}],
18896	isError: true
18897	};
18898	}
18899	/**
18900	* Validates tool input arguments against the tool's input schema.
18901	*/
18902	async validateToolInput(tool, args, toolName) {
18903	if (!tool.inputSchema) return;
18904	const parseResult = await safeParseAsync$1(normalizeObjectSchema(tool.inputSchema) ?? tool.inputSchema, args);
18905	if (!parseResult.success) {
18906	const errorMessage = getParseErrorMessage("error" in parseResult ? parseResult.error : "Unknown error");
18907	throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
18908	}
18909	return parseResult.data;
18910	}
18911	/**
18912	* Validates tool output against the tool's output schema.
18913	*/
18914	async validateToolOutput(tool, result, toolName) {
18915	if (!tool.outputSchema) return;
18916	if (!("content" in result)) return;
18917	if (result.isError) return;
18918	if (!result.structuredContent) throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
18919	const parseResult = await safeParseAsync$1(normalizeObjectSchema(tool.outputSchema), result.structuredContent);
18920	if (!parseResult.success) {
18921	const errorMessage = getParseErrorMessage("error" in parseResult ? parseResult.error : "Unknown error");
18922	throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
18923	}
18924	}
18925	/**
18926	* Executes a tool handler (either regular or task-based).
18927	*/
18928	async executeToolHandler(tool, args, extra) {
18929	const handler = tool.handler;
18930	if ("createTask" in handler) {
18931	if (!extra.taskStore) throw new Error("No task store provided.");
18932	const taskExtra = {
18933	...extra,
18934	taskStore: extra.taskStore
18935	};
18936	if (tool.inputSchema) {
18937	const typedHandler = handler;
18938	return await Promise.resolve(typedHandler.createTask(args, taskExtra));
18939	} else {
18940	const typedHandler = handler;
18941	return await Promise.resolve(typedHandler.createTask(taskExtra));
18942	}
18943	}
18944	if (tool.inputSchema) {
18945	const typedHandler = handler;
18946	return await Promise.resolve(typedHandler(args, extra));
18947	} else {
18948	const typedHandler = handler;
18949	return await Promise.resolve(typedHandler(extra));
18950	}
18951	}
18952	/**
18953	* Handles automatic task polling for tools with taskSupport 'optional'.
18954	*/
18955	async handleAutomaticTaskPolling(tool, request, extra) {
18956	if (!extra.taskStore) throw new Error("No task store provided for task-capable tool.");
18957	const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
18958	const handler = tool.handler;
18959	const taskExtra = {
18960	...extra,
18961	taskStore: extra.taskStore
18962	};
18963	const createTaskResult = args ? await Promise.resolve(handler.createTask(args, taskExtra)) : await Promise.resolve(handler.createTask(taskExtra));
18964	const taskId = createTaskResult.task.taskId;
18965	let task = createTaskResult.task;
18966	const pollInterval = task.pollInterval ?? 5e3;
18967	while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
18968	await new Promise((resolve) => setTimeout(resolve, pollInterval));
18969	const updatedTask = await extra.taskStore.getTask(taskId);
18970	if (!updatedTask) throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
18971	task = updatedTask;
18972	}
18973	return await extra.taskStore.getTaskResult(taskId);
18974	}
18975	setCompletionRequestHandler() {
18976	if (this._completionHandlerInitialized) return;
18977	this.server.assertCanSetRequestHandler(getMethodValue(CompleteRequestSchema));
18978	this.server.registerCapabilities({ completions: {} });
18979	this.server.setRequestHandler(CompleteRequestSchema, async (request) => {
18980	switch (request.params.ref.type) {
18981	case "ref/prompt":
18982	assertCompleteRequestPrompt(request);
18983	return this.handlePromptCompletion(request, request.params.ref);
18984	case "ref/resource":
18985	assertCompleteRequestResourceTemplate(request);
18986	return this.handleResourceCompletion(request, request.params.ref);
18987	default: throw new McpError(ErrorCode.InvalidParams, `Invalid completion reference: ${request.params.ref}`);
18988	}
18989	});
18990	this._completionHandlerInitialized = true;
18991	}
18992	async handlePromptCompletion(request, ref) {
18993	const prompt = this._registeredPrompts[ref.name];
18994	if (!prompt) throw new McpError(ErrorCode.InvalidParams, `Prompt ${ref.name} not found`);
18995	if (!prompt.enabled) throw new McpError(ErrorCode.InvalidParams, `Prompt ${ref.name} disabled`);
18996	if (!prompt.argsSchema) return EMPTY_COMPLETION_RESULT;
18997	const field = getObjectShape(prompt.argsSchema)?.[request.params.argument.name];
18998	if (!isCompletable(field)) return EMPTY_COMPLETION_RESULT;
18999	const completer = getCompleter(field);
19000	if (!completer) return EMPTY_COMPLETION_RESULT;
19001	return createCompletionResult(await completer(request.params.argument.value, request.params.context));
19002	}
19003	async handleResourceCompletion(request, ref) {
19004	const template = Object.values(this._registeredResourceTemplates).find((t) => t.resourceTemplate.uriTemplate.toString() === ref.uri);
19005	if (!template) {
19006	if (this._registeredResources[ref.uri]) return EMPTY_COMPLETION_RESULT;
19007	throw new McpError(ErrorCode.InvalidParams, `Resource template ${request.params.ref.uri} not found`);
19008	}
19009	const completer = template.resourceTemplate.completeCallback(request.params.argument.name);
19010	if (!completer) return EMPTY_COMPLETION_RESULT;
19011	return createCompletionResult(await completer(request.params.argument.value, request.params.context));
19012	}
19013	setResourceRequestHandlers() {
19014	if (this._resourceHandlersInitialized) return;
19015	this.server.assertCanSetRequestHandler(getMethodValue(ListResourcesRequestSchema));
19016	this.server.assertCanSetRequestHandler(getMethodValue(ListResourceTemplatesRequestSchema));
19017	this.server.assertCanSetRequestHandler(getMethodValue(ReadResourceRequestSchema));
19018	this.server.registerCapabilities({ resources: { listChanged: true } });
19019	this.server.setRequestHandler(ListResourcesRequestSchema, async (request, extra) => {
19020	const resources = Object.entries(this._registeredResources).filter(([_, resource]) => resource.enabled).map(([uri, resource]) => ({
19021	uri,
19022	name: resource.name,
19023	...resource.metadata
19024	}));
19025	const templateResources = [];
19026	for (const template of Object.values(this._registeredResourceTemplates)) {
19027	if (!template.resourceTemplate.listCallback) continue;
19028	const result = await template.resourceTemplate.listCallback(extra);
19029	for (const resource of result.resources) templateResources.push({
19030	...template.metadata,
19031	...resource
19032	});
19033	}
19034	return { resources: [...resources, ...templateResources] };
19035	});
19036	this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
19037	return { resourceTemplates: Object.entries(this._registeredResourceTemplates).map(([name, template]) => ({
19038	name,
19039	uriTemplate: template.resourceTemplate.uriTemplate.toString(),
19040	...template.metadata
19041	})) };
19042	});
19043	this.server.setRequestHandler(ReadResourceRequestSchema, async (request, extra) => {
19044	const uri = new URL(request.params.uri);
19045	const resource = this._registeredResources[uri.toString()];
19046	if (resource) {
19047	if (!resource.enabled) throw new McpError(ErrorCode.InvalidParams, `Resource ${uri} disabled`);
19048	return resource.readCallback(uri, extra);
19049	}
19050	for (const template of Object.values(this._registeredResourceTemplates)) {
19051	const variables = template.resourceTemplate.uriTemplate.match(uri.toString());
19052	if (variables) return template.readCallback(uri, variables, extra);
19053	}
19054	throw new McpError(ErrorCode.InvalidParams, `Resource ${uri} not found`);
19055	});
19056	this._resourceHandlersInitialized = true;
19057	}
19058	setPromptRequestHandlers() {
19059	if (this._promptHandlersInitialized) return;
19060	this.server.assertCanSetRequestHandler(getMethodValue(ListPromptsRequestSchema));
19061	this.server.assertCanSetRequestHandler(getMethodValue(GetPromptRequestSchema));
19062	this.server.registerCapabilities({ prompts: { listChanged: true } });
19063	this.server.setRequestHandler(ListPromptsRequestSchema, () => ({ prompts: Object.entries(this._registeredPrompts).filter(([, prompt]) => prompt.enabled).map(([name, prompt]) => {
19064	return {
19065	name,
19066	title: prompt.title,
19067	description: prompt.description,
19068	arguments: prompt.argsSchema ? promptArgumentsFromSchema(prompt.argsSchema) : void 0
19069	};
19070	}) }));
19071	this.server.setRequestHandler(GetPromptRequestSchema, async (request, extra) => {
19072	const prompt = this._registeredPrompts[request.params.name];
19073	if (!prompt) throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} not found`);
19074	if (!prompt.enabled) throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} disabled`);
19075	if (prompt.argsSchema) {
19076	const parseResult = await safeParseAsync$1(normalizeObjectSchema(prompt.argsSchema), request.params.arguments);
19077	if (!parseResult.success) {
19078	const errorMessage = getParseErrorMessage("error" in parseResult ? parseResult.error : "Unknown error");
19079	throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
19080	}
19081	const args = parseResult.data;
19082	const cb = prompt.callback;
19083	return await Promise.resolve(cb(args, extra));
19084	} else {
19085	const cb = prompt.callback;
19086	return await Promise.resolve(cb(extra));
19087	}
19088	});
19089	this._promptHandlersInitialized = true;
19090	}
19091	resource(name, uriOrTemplate, ...rest) {
19092	let metadata;
19093	if (typeof rest[0] === "object") metadata = rest.shift();
19094	const readCallback = rest[0];
19095	if (typeof uriOrTemplate === "string") {
19096	if (this._registeredResources[uriOrTemplate]) throw new Error(`Resource ${uriOrTemplate} is already registered`);
19097	const registeredResource = this._createRegisteredResource(name, void 0, uriOrTemplate, metadata, readCallback);
19098	this.setResourceRequestHandlers();
19099	this.sendResourceListChanged();
19100	return registeredResource;
19101	} else {
19102	if (this._registeredResourceTemplates[name]) throw new Error(`Resource template ${name} is already registered`);
19103	const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, void 0, uriOrTemplate, metadata, readCallback);
19104	this.setResourceRequestHandlers();
19105	this.sendResourceListChanged();
19106	return registeredResourceTemplate;
19107	}
19108	}
19109	registerResource(name, uriOrTemplate, config, readCallback) {
19110	if (typeof uriOrTemplate === "string") {
19111	if (this._registeredResources[uriOrTemplate]) throw new Error(`Resource ${uriOrTemplate} is already registered`);
19112	const registeredResource = this._createRegisteredResource(name, config.title, uriOrTemplate, config, readCallback);
19113	this.setResourceRequestHandlers();
19114	this.sendResourceListChanged();
19115	return registeredResource;
19116	} else {
19117	if (this._registeredResourceTemplates[name]) throw new Error(`Resource template ${name} is already registered`);
19118	const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config.title, uriOrTemplate, config, readCallback);
19119	this.setResourceRequestHandlers();
19120	this.sendResourceListChanged();
19121	return registeredResourceTemplate;
19122	}
19123	}
19124	_createRegisteredResource(name, title, uri, metadata, readCallback) {
19125	const registeredResource = {
19126	name,
19127	title,
19128	metadata,
19129	readCallback,
19130	enabled: true,
19131	disable: () => registeredResource.update({ enabled: false }),
19132	enable: () => registeredResource.update({ enabled: true }),
19133	remove: () => registeredResource.update({ uri: null }),
19134	update: (updates) => {
19135	if (typeof updates.uri !== "undefined" && updates.uri !== uri) {
19136	delete this._registeredResources[uri];
19137	if (updates.uri) this._registeredResources[updates.uri] = registeredResource;
19138	}
19139	if (typeof updates.name !== "undefined") registeredResource.name = updates.name;
19140	if (typeof updates.title !== "undefined") registeredResource.title = updates.title;
19141	if (typeof updates.metadata !== "undefined") registeredResource.metadata = updates.metadata;
19142	if (typeof updates.callback !== "undefined") registeredResource.readCallback = updates.callback;
19143	if (typeof updates.enabled !== "undefined") registeredResource.enabled = updates.enabled;
19144	this.sendResourceListChanged();
19145	}
19146	};
19147	this._registeredResources[uri] = registeredResource;
19148	return registeredResource;
19149	}
19150	_createRegisteredResourceTemplate(name, title, template, metadata, readCallback) {
19151	const registeredResourceTemplate = {
19152	resourceTemplate: template,
19153	title,
19154	metadata,
19155	readCallback,
19156	enabled: true,
19157	disable: () => registeredResourceTemplate.update({ enabled: false }),
19158	enable: () => registeredResourceTemplate.update({ enabled: true }),
19159	remove: () => registeredResourceTemplate.update({ name: null }),
19160	update: (updates) => {
19161	if (typeof updates.name !== "undefined" && updates.name !== name) {
19162	delete this._registeredResourceTemplates[name];
19163	if (updates.name) this._registeredResourceTemplates[updates.name] = registeredResourceTemplate;
19164	}
19165	if (typeof updates.title !== "undefined") registeredResourceTemplate.title = updates.title;
19166	if (typeof updates.template !== "undefined") registeredResourceTemplate.resourceTemplate = updates.template;
19167	if (typeof updates.metadata !== "undefined") registeredResourceTemplate.metadata = updates.metadata;
19168	if (typeof updates.callback !== "undefined") registeredResourceTemplate.readCallback = updates.callback;
19169	if (typeof updates.enabled !== "undefined") registeredResourceTemplate.enabled = updates.enabled;
19170	this.sendResourceListChanged();
19171	}
19172	};
19173	this._registeredResourceTemplates[name] = registeredResourceTemplate;
19174	const variableNames = template.uriTemplate.variableNames;
19175	if (Array.isArray(variableNames) && variableNames.some((v) => !!template.completeCallback(v))) this.setCompletionRequestHandler();
19176	return registeredResourceTemplate;
19177	}
19178	_createRegisteredPrompt(name, title, description, argsSchema, callback) {
19179	const registeredPrompt = {
19180	title,
19181	description,
19182	argsSchema: argsSchema === void 0 ? void 0 : objectFromShape(argsSchema),
19183	callback,
19184	enabled: true,
19185	disable: () => registeredPrompt.update({ enabled: false }),
19186	enable: () => registeredPrompt.update({ enabled: true }),
19187	remove: () => registeredPrompt.update({ name: null }),
19188	update: (updates) => {
19189	if (typeof updates.name !== "undefined" && updates.name !== name) {
19190	delete this._registeredPrompts[name];
19191	if (updates.name) this._registeredPrompts[updates.name] = registeredPrompt;
19192	}
19193	if (typeof updates.title !== "undefined") registeredPrompt.title = updates.title;
19194	if (typeof updates.description !== "undefined") registeredPrompt.description = updates.description;
19195	if (typeof updates.argsSchema !== "undefined") registeredPrompt.argsSchema = objectFromShape(updates.argsSchema);
19196	if (typeof updates.callback !== "undefined") registeredPrompt.callback = updates.callback;
19197	if (typeof updates.enabled !== "undefined") registeredPrompt.enabled = updates.enabled;
19198	this.sendPromptListChanged();
19199	}
19200	};
19201	this._registeredPrompts[name] = registeredPrompt;
19202	if (argsSchema) {
19203	if (Object.values(argsSchema).some((field) => {
19204	return isCompletable(field instanceof ZodOptional$1 ? field._def?.innerType : field);
19205	})) this.setCompletionRequestHandler();
19206	}
19207	return registeredPrompt;
19208	}
19209	_createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) {
19210	validateAndWarnToolName(name);
19211	const registeredTool = {
19212	title,
19213	description,
19214	inputSchema: getZodSchemaObject(inputSchema),
19215	outputSchema: getZodSchemaObject(outputSchema),
19216	annotations,
19217	execution,
19218	_meta,
19219	handler,
19220	enabled: true,
19221	disable: () => registeredTool.update({ enabled: false }),
19222	enable: () => registeredTool.update({ enabled: true }),
19223	remove: () => registeredTool.update({ name: null }),
19224	update: (updates) => {
19225	if (typeof updates.name !== "undefined" && updates.name !== name) {
19226	if (typeof updates.name === "string") validateAndWarnToolName(updates.name);
19227	delete this._registeredTools[name];
19228	if (updates.name) this._registeredTools[updates.name] = registeredTool;
19229	}
19230	if (typeof updates.title !== "undefined") registeredTool.title = updates.title;
19231	if (typeof updates.description !== "undefined") registeredTool.description = updates.description;
19232	if (typeof updates.paramsSchema !== "undefined") registeredTool.inputSchema = objectFromShape(updates.paramsSchema);
19233	if (typeof updates.outputSchema !== "undefined") registeredTool.outputSchema = objectFromShape(updates.outputSchema);
19234	if (typeof updates.callback !== "undefined") registeredTool.handler = updates.callback;
19235	if (typeof updates.annotations !== "undefined") registeredTool.annotations = updates.annotations;
19236	if (typeof updates._meta !== "undefined") registeredTool._meta = updates._meta;
19237	if (typeof updates.enabled !== "undefined") registeredTool.enabled = updates.enabled;
19238	this.sendToolListChanged();
19239	}
19240	};
19241	this._registeredTools[name] = registeredTool;
19242	this.setToolRequestHandlers();
19243	this.sendToolListChanged();
19244	return registeredTool;
19245	}
19246	/**
19247	* tool() implementation. Parses arguments passed to overrides defined above.
19248	*/
19249	tool(name, ...rest) {
19250	if (this._registeredTools[name]) throw new Error(`Tool ${name} is already registered`);
19251	let description;
19252	let inputSchema;
19253	let outputSchema;
19254	let annotations;
19255	if (typeof rest[0] === "string") description = rest.shift();
19256	if (rest.length > 1) {
19257	const firstArg = rest[0];
19258	if (isZodRawShapeCompat(firstArg)) {
19259	inputSchema = rest.shift();
19260	if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShapeCompat(rest[0])) annotations = rest.shift();
19261	} else if (typeof firstArg === "object" && firstArg !== null) annotations = rest.shift();
19262	}
19263	const callback = rest[0];
19264	return this._createRegisteredTool(name, void 0, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, void 0, callback);
19265	}
19266	/**
19267	* Registers a tool with a config object and callback.
19268	*/
19269	registerTool(name, config, cb) {
19270	if (this._registeredTools[name]) throw new Error(`Tool ${name} is already registered`);
19271	const { title, description, inputSchema, outputSchema, annotations, _meta } = config;
19272	return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
19273	}
19274	prompt(name, ...rest) {
19275	if (this._registeredPrompts[name]) throw new Error(`Prompt ${name} is already registered`);
19276	let description;
19277	if (typeof rest[0] === "string") description = rest.shift();
19278	let argsSchema;
19279	if (rest.length > 1) argsSchema = rest.shift();
19280	const cb = rest[0];
19281	const registeredPrompt = this._createRegisteredPrompt(name, void 0, description, argsSchema, cb);
19282	this.setPromptRequestHandlers();
19283	this.sendPromptListChanged();
19284	return registeredPrompt;
19285	}
19286	/**
19287	* Registers a prompt with a config object and callback.
19288	*/
19289	registerPrompt(name, config, cb) {
19290	if (this._registeredPrompts[name]) throw new Error(`Prompt ${name} is already registered`);
19291	const { title, description, argsSchema } = config;
19292	const registeredPrompt = this._createRegisteredPrompt(name, title, description, argsSchema, cb);
19293	this.setPromptRequestHandlers();
19294	this.sendPromptListChanged();
19295	return registeredPrompt;
19296	}
19297	/**
19298	* Checks if the server is connected to a transport.
19299	* @returns True if the server is connected
19300	*/
19301	isConnected() {
19302	return this.server.transport !== void 0;
19303	}
19304	/**
19305	* Sends a logging message to the client, if connected.
19306	* Note: You only need to send the parameters object, not the entire JSON RPC message
19307	* @see LoggingMessageNotification
19308	* @param params
19309	* @param sessionId optional for stateless and backward compatibility
19310	*/
19311	async sendLoggingMessage(params, sessionId) {
19312	return this.server.sendLoggingMessage(params, sessionId);
19313	}
19314	/**
19315	* Sends a resource list changed event to the client, if connected.
19316	*/
19317	sendResourceListChanged() {
19318	if (this.isConnected()) this.server.sendResourceListChanged();
19319	}
19320	/**
19321	* Sends a tool list changed event to the client, if connected.
19322	*/
19323	sendToolListChanged() {
19324	if (this.isConnected()) this.server.sendToolListChanged();
19325	}
19326	/**
19327	* Sends a prompt list changed event to the client, if connected.
19328	*/
19329	sendPromptListChanged() {
19330	if (this.isConnected()) this.server.sendPromptListChanged();
19331	}
19332	};
19333	/**
19334	* A resource template combines a URI pattern with optional functionality to enumerate
19335	* all resources matching that pattern.
19336	*/
19337	var ResourceTemplate = class {
19338	constructor(uriTemplate, _callbacks) {
19339	this._callbacks = _callbacks;
19340	this._uriTemplate = typeof uriTemplate === "string" ? new UriTemplate(uriTemplate) : uriTemplate;
19341	}
19342	/**
19343	* Gets the URI template pattern.
19344	*/
19345	get uriTemplate() {
19346	return this._uriTemplate;
19347	}
19348	/**
19349	* Gets the list callback, if one was provided.
19350	*/
19351	get listCallback() {
19352	return this._callbacks.list;
19353	}
19354	/**
19355	* Gets the callback for completing a specific URI template variable, if one was provided.
19356	*/
19357	completeCallback(variable) {
19358	return this._callbacks.complete?.[variable];
19359	}
19360	};
19361	var EMPTY_OBJECT_JSON_SCHEMA = {
19362	type: "object",
19363	properties: {}
19364	};
19365	/**
19366	* Checks if a value looks like a Zod schema by checking for parse/safeParse methods.
19367	*/
19368	function isZodTypeLike(value) {
19369	return value !== null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
19370	}
19371	/**
19372	* Checks if an object is a Zod schema instance (v3 or v4).
19373	*
19374	* Zod schemas have internal markers:
19375	* - v3: `_def` property
19376	* - v4: `_zod` property
19377	*
19378	* This includes transformed schemas like z.preprocess(), z.transform(), z.pipe().
19379	*/
19380	function isZodSchemaInstance(obj) {
19381	return "_def" in obj \|\| "_zod" in obj \|\| isZodTypeLike(obj);
19382	}
19383	/**
19384	* Checks if an object is a "raw shape" - a plain object where values are Zod schemas.
19385	*
19386	* Raw shapes are used as shorthand: `{ name: z.string() }` instead of `z.object({ name: z.string() })`.
19387	*
19388	* IMPORTANT: This must NOT match actual Zod schema instances (like z.preprocess, z.pipe),
19389	* which have internal properties that could be mistaken for schema values.
19390	*/
19391	function isZodRawShapeCompat(obj) {
19392	if (typeof obj !== "object" \|\| obj === null) return false;
19393	if (isZodSchemaInstance(obj)) return false;
19394	if (Object.keys(obj).length === 0) return true;
19395	return Object.values(obj).some(isZodTypeLike);
19396	}
19397	/**
19398	* Converts a provided Zod schema to a Zod object if it is a ZodRawShapeCompat,
19399	* otherwise returns the schema as is.
19400	*/
19401	function getZodSchemaObject(schema) {
19402	if (!schema) return;
19403	if (isZodRawShapeCompat(schema)) return objectFromShape(schema);
19404	return schema;
19405	}
19406	function promptArgumentsFromSchema(schema) {
19407	const shape = getObjectShape(schema);
19408	if (!shape) return [];
19409	return Object.entries(shape).map(([name, field]) => {
19410	return {
19411	name,
19412	description: getSchemaDescription(field),
19413	required: !isSchemaOptional(field)
19414	};
19415	});
19416	}
19417	function getMethodValue(schema) {
19418	const methodSchema = getObjectShape(schema)?.method;
19419	if (!methodSchema) throw new Error("Schema is missing a method literal");
19420	const value = getLiteralValue(methodSchema);
19421	if (typeof value === "string") return value;
19422	throw new Error("Schema method literal must be a string");
19423	}
19424	function createCompletionResult(suggestions) {
19425	return { completion: {
19426	values: suggestions.slice(0, 100),
19427	total: suggestions.length,
19428	hasMore: suggestions.length > 100
19429	} };
19430	}
19431	var EMPTY_COMPLETION_RESULT = { completion: {
19432	values: [],
19433	hasMore: false
19434	} };
19435
19436	//#endregion
19437	//#region packages/packages/libs/elementor-mcp-common/src/utils.ts
19438	var getElementor = () => window.elementor;
19439	var getElementorFrontend = () => window.elementorFrontend;
19440	var get$e = () => window.$e;
19441	var getElementorCommon = () => window.elementorCommon;
19442	var getWpApiSettings = () => window.wpApiSettings;
19443	var getAjaxUrl = () => window.ajaxurl;
19444	var getWp = () => window.wp;
19445	var getJQuery = () => window.jQuery;
19446	var getElementorAiConfig = () => window.ElementorAiConfig;
19447
19448	//#endregion
19449	//#region packages/packages/libs/elementor-mcp-common/src/editor-detection.ts
19450	var ELEMENTOR_LOAD_TIMEOUT_MS = 5e3;
19451	var ELEMENTOR_CHECK_INTERVAL_MS = 100;
19452	var DEFAULT_WAIT_FOR_ELEMENTOR_OPTIONS = {
19453	maxRetries: ELEMENTOR_LOAD_TIMEOUT_MS / ELEMENTOR_CHECK_INTERVAL_MS,
19454	retryInterval: ELEMENTOR_CHECK_INTERVAL_MS,
19455	checkFn: () => !!(getElementor() && get$e())
19456	};
19457	function isGutenbergEditor() {
19458	return getWp()?.data?.select("core/editor") !== void 0;
19459	}
19460	function isElementorEditor() {
19461	const params = new URLSearchParams(window.location.search);
19462	for (const [, value] of params.entries()) if (value.includes("elementor")) return true;
19463	return false;
19464	}
19465	function isElementorAIActive() {
19466	return !!getElementorAiConfig();
19467	}
19468	function hasGutenbergUI() {
19469	return !!document.querySelector(".edit-post-header-toolbar");
19470	}
19471	function ensureElementorFrontend() {
19472	if (!getElementorFrontend()?.elements?.$body) throw new Error("elementorFrontend or its required components not available");
19473	}
19474	function isElementorEditorReady() {
19475	return !!get$e()?.components.get("panel");
19476	}
19477	function waitForElementorEditor() {
19478	return new Promise((resolve) => {
19479	if (isElementorEditorReady()) {
19480	resolve();
19481	return;
19482	}
19483	const checkReady = () => {
19484	if (isElementorEditorReady()) resolve();
19485	else setTimeout(checkReady, 100);
19486	};
19487	if (document.readyState === "loading") window.addEventListener("DOMContentLoaded", checkReady, { once: true });
19488	else checkReady();
19489	});
19490	}
19491	function waitForElementor(options = DEFAULT_WAIT_FOR_ELEMENTOR_OPTIONS) {
19492	const { maxRetries, retryInterval, checkFn } = options;
19493	return new Promise((resolve, reject) => {
19494	let attempts = 0;
19495	const check = () => {
19496	if (checkFn()) {
19497	resolve();
19498	return;
19499	}
19500	attempts++;
19501	if (attempts >= maxRetries) {
19502	reject(/* @__PURE__ */ new Error(`Elementor not loaded after ${maxRetries} attempts`));
19503	return;
19504	}
19505	setTimeout(check, retryInterval);
19506	};
19507	check();
19508	});
19509	}
19510	async function whenElementorReady(fn, options = DEFAULT_WAIT_FOR_ELEMENTOR_OPTIONS) {
19511	await waitForElementor(options);
19512	await waitForElementorEditor();
19513	return await fn();
19514	}
19515
19516	//#endregion
19517	//#region packages/packages/libs/elementor-mcp-common/src/elements.ts
19518	function injectElementCSS(elementId, css) {
19519	const style = document.createElement("style");
19520	style.id = elementId;
19521	style.appendChild(document.createTextNode(css));
19522	ensureElementorFrontend();
19523	const frontend = getElementorFrontend();
19524	if (frontend) frontend.elements.$body[0].appendChild(style);
19525	}
19526	function removeElementCSS(elementId) {
19527	ensureElementorFrontend();
19528	const frontend = getElementorFrontend();
19529	if (!frontend) return;
19530	const bodyElement = frontend.elements.$body[0];
19531	const styleTags = bodyElement.querySelectorAll(`#${CSS.escape(elementId)}`);
19532	if (styleTags?.length > 0) styleTags.forEach((tag) => {
19533	bodyElement.removeChild(tag);
19534	});
19535	}
19536	async function updateElementSettings({ id, settings }) {
19537	const containerToUpdateSettings = getElementor()?.getContainer(id);
19538	if (!containerToUpdateSettings) throw new Error(`Element with ID "${id}" not found.`);
19539	const updateResult = await get$e()?.run("document/elements/settings", {
19540	container: containerToUpdateSettings,
19541	settings,
19542	options: {
19543	external: true,
19544	render: true
19545	}
19546	});
19547	getElementorFrontend()?.elements.$body.resize();
19548	return updateResult;
19549	}
19550	function getElementSettings(id) {
19551	const container = getElementor()?.getContainer(id);
19552	if (!container) throw new Error(`Element with ID "${id}" not found.`);
19553	return container.settings;
19554	}
19555	function getGutenbergBlockEditorApis() {
19556	const wp = getWp();
19557	if (!isGutenbergEditor() \|\| !wp) throw new Error("WordPress editor API is not available");
19558	const blockEditorDispatch = wp.data.dispatch("core/block-editor");
19559	const blockEditorSelect = wp.data.select("core/block-editor");
19560	if (!blockEditorDispatch \|\| !blockEditorSelect) throw new Error("Block editor API is not available");
19561	return {
19562	blockEditorDispatch,
19563	blockEditorSelect
19564	};
19565	}
19566	function validateAndGetGutenbergBlock(blockEditorSelect, blockId) {
19567	const block = blockEditorSelect.getBlock(blockId);
19568	if (!block) throw new Error(`Block with ID "${blockId}" not found`);
19569	return block;
19570	}
19571	function updateGutenbergBlockAttributes(blockId, attributes) {
19572	const { blockEditorDispatch, blockEditorSelect } = getGutenbergBlockEditorApis();
19573	const block = validateAndGetGutenbergBlock(blockEditorSelect, blockId);
19574	blockEditorDispatch.updateBlockAttributes(blockId, attributes);
19575	return {
19576	blockId,
19577	blockName: block.name,
19578	updatedAttributes: Object.keys(attributes)
19579	};
19580	}
19581	function extractElementImageData(targetElementId, fallbackImageId = "", fallbackImageUrl = "") {
19582	let extractedImageId = fallbackImageId;
19583	let extractedImageUrl = fallbackImageUrl;
19584	if (targetElementId && (!extractedImageId \|\| !extractedImageUrl)) {
19585	const targetContainer = getElementor()?.getContainer?.(targetElementId);
19586	if (targetContainer) {
19587	const imageData = targetContainer.settings.get("image");
19588	if (imageData && typeof imageData === "object") {
19589	const imageObj = imageData;
19590	extractedImageId = extractedImageId \|\| imageObj.id?.toString() \|\| "";
19591	extractedImageUrl = extractedImageUrl \|\| imageObj.url \|\| "";
19592	}
19593	}
19594	}
19595	return {
19596	imageId: extractedImageId,
19597	imageUrl: extractedImageUrl
19598	};
19599	}
19600	function isSelectAllCheckbox(input) {
19601	if (input.id && input.id.includes("select-all") \|\| input.name && input.name.includes("select-all")) return true;
19602	return false;
19603	}
19604
19605	//#endregion
19606	//#region packages/packages/libs/elementor-mcp-common/src/nonce-refresh.ts
19607	var isNonceRefreshInitialized = false;
19608	var nonceRefreshPromise = null;
19609	function initNonceRefresh() {
19610	const jQuery = getJQuery();
19611	const wpApiSettings = getWpApiSettings();
19612	if (isNonceRefreshInitialized \|\| typeof jQuery === "undefined" \|\| !wpApiSettings) return;
19613	isNonceRefreshInitialized = true;
19614	jQuery?.(document).on("heartbeat-tick.angieNonceRefresh", (_event, data) => {
19615	try {
19616	const tickData = data;
19617	const currentSettings = getWpApiSettings();
19618	if (tickData.angie_nonce && currentSettings && currentSettings.nonce !== tickData.angie_nonce) currentSettings.nonce = tickData.angie_nonce;
19619	} catch (error) {
19620	console.error("Failed to refresh nonce:", error);
19621	}
19622	});
19623	}
19624	async function refreshNonce() {
19625	if (nonceRefreshPromise) return nonceRefreshPromise;
19626	nonceRefreshPromise = fetchFreshNonce();
19627	try {
19628	return await nonceRefreshPromise;
19629	} finally {
19630	nonceRefreshPromise = null;
19631	}
19632	}
19633	async function fetchFreshNonce() {
19634	const ajaxUrl = new URL(getAjaxUrl() \|\| "/wp-admin/admin-ajax.php", window.location.origin);
19635	ajaxUrl.searchParams.set("action", "rest-nonce");
19636	const response = await fetch(ajaxUrl.toString(), { credentials: "same-origin" });
19637	if (!response.ok) throw new Error(`Failed to refresh nonce: HTTP ${response.status}`);
19638	const nonce = await response.text();
19639	if (!nonce \|\| nonce === "0") throw new Error("Session expired — received invalid nonce");
19640	const wpApiSettings = getWpApiSettings();
19641	if (!wpApiSettings) throw new Error("wpApiSettings not available — cannot refresh nonce");
19642	wpApiSettings.nonce = nonce;
19643	return nonce;
19644	}
19645	function isNonceError(status, responseText) {
19646	return status === 403 && responseText.includes("rest_cookie_invalid_nonce");
19647	}
19648
19649	//#endregion
19650	//#region packages/packages/libs/elementor-mcp-common/src/rest-client.ts
19651	async function callWpApi(endpoint, method, data, options) {
19652	return executeWpApiCall(endpoint, method, data, options, true);
19653	}
19654	async function executeWpApiCall(endpoint, method, data, options, allowNonceRetry = false) {
19655	const wpApiSettings = getWpApiSettings();
19656	if (!wpApiSettings?.nonce \|\| !wpApiSettings.root) throw new Error("wpApiSettings not available");
19657	const baseUrl = wpApiSettings.root;
19658	const urlObject = new URL(baseUrl);
19659	const endpointUrl = new URL(endpoint, baseUrl);
19660	urlObject.searchParams.set("rest_route", endpointUrl.pathname);
19661	for (const [key, value] of endpointUrl.searchParams.entries()) urlObject.searchParams.append(key, value);
19662	const url = urlObject.toString();
19663	const headers = {
19664	"X-WP-Nonce": wpApiSettings.nonce,
19665	...options?.customHeaders \|\| {}
19666	};
19667	if (!options?.binaryData && !options?.customHeaders?.["Content-Type"]) headers["Content-Type"] = "application/json";
19668	const requestOptions = {
19669	method,
19670	headers,
19671	credentials: "same-origin"
19672	};
19673	if (options?.binaryData) requestOptions.body = options.binaryData;
19674	else if (data && (method === "POST" \|\| method === "PUT" \|\| method === "PATCH")) requestOptions.body = JSON.stringify(data);
19675	const response = await fetch(url, requestOptions);
19676	if (!response.ok) {
19677	const responseText2 = await response.text();
19678	if (allowNonceRetry && isNonceError(response.status, responseText2)) {
19679	await refreshNonce();
19680	return executeWpApiCall(endpoint, method, data, options, false);
19681	}
19682	throw new Error(`HTTP error ${response.status}: ${responseText2}`);
19683	}
19684	const responseText = await response.text();
19685	const json = extractJSONFromResponse(responseText);
19686	if (json === null) throw new Error(`Invalid response: no JSON found in: ${responseText.substring(0, 200)}`);
19687	const jsonObj = json;
19688	if (jsonObj?.success !== void 0 && !jsonObj.success) throw new Error(`API errors: ${JSON.stringify(json)}`);
19689	const totalItemsHeader = response.headers.get("X-WP-Total");
19690	const totalPagesHeader = response.headers.get("X-WP-TotalPages");
19691	return {
19692	data: json,
19693	totalItems: totalItemsHeader ? parseInt(totalItemsHeader, 10) : void 0,
19694	totalPages: totalPagesHeader ? parseInt(totalPagesHeader, 10) : void 0
19695	};
19696	}
19697	function extractJSONFromResponse(responseText) {
19698	const objectStart = responseText.indexOf("{");
19699	const arrayStart = responseText.indexOf("[");
19700	let startIndex = -1;
19701	let isArray = false;
19702	if (objectStart === -1 && arrayStart === -1) return null;
19703	if (objectStart === -1) {
19704	startIndex = arrayStart;
19705	isArray = true;
19706	} else if (arrayStart === -1) {
19707	startIndex = objectStart;
19708	isArray = false;
19709	} else if (arrayStart < objectStart) {
19710	startIndex = arrayStart;
19711	isArray = true;
19712	} else {
19713	startIndex = objectStart;
19714	isArray = false;
19715	}
19716	let delimiterCount = 0;
19717	let endIndex = -1;
19718	const openChar = isArray ? "[" : "{";
19719	const closeChar = isArray ? "]" : "}";
19720	for (let i = startIndex; i < responseText.length; i++) if (responseText[i] === openChar) delimiterCount++;
19721	else if (responseText[i] === closeChar) {
19722	delimiterCount--;
19723	if (delimiterCount === 0) {
19724	endIndex = i;
19725	break;
19726	}
19727	}
19728	if (endIndex === -1) return null;
19729	const jsonString = responseText.substring(startIndex, endIndex + 1);
19730	try {
19731	return JSON.parse(jsonString);
19732	} catch {
19733	return null;
19734	}
19735	}
19736
19737	//#endregion
19738	//#region packages/packages/libs/elementor-mcp-common/src/validation-utils.ts
19739	function requireConfirmationMessage(confirmationMessage, context) {
19740	if (!confirmationMessage \|\| confirmationMessage.trim() === "") throw new Error(`LLM Instructions: ${context} changes require user confirmation. You MUST provide a confirmationMessage parameter explaining what will be changed and its impact.`);
19741	}
19742
19743	//#endregion
19744	//#region packages/packages/libs/elementor-mcp-common/src/index.ts
19745	var src_exports = /* @__PURE__ */ __exportAll({
19746	McpServer: () => McpServer,
19747	ResourceTemplate: () => ResourceTemplate,
19748	SamplingMessageSchema: () => SamplingMessageSchema,
19749	callWpApi: () => callWpApi,
19750	ensureElementorFrontend: () => ensureElementorFrontend,
19751	extractElementImageData: () => extractElementImageData,
19752	extractJSONFromResponse: () => extractJSONFromResponse,
19753	get$e: () => get$e,
19754	getAjaxUrl: () => getAjaxUrl,
19755	getElementSettings: () => getElementSettings,
19756	getElementor: () => getElementor,
19757	getElementorAiConfig: () => getElementorAiConfig,
19758	getElementorCommon: () => getElementorCommon,
19759	getElementorFrontend: () => getElementorFrontend,
19760	getGutenbergBlockEditorApis: () => getGutenbergBlockEditorApis,
19761	getJQuery: () => getJQuery,
19762	getWp: () => getWp,
19763	getWpApiSettings: () => getWpApiSettings,
19764	hasGutenbergUI: () => hasGutenbergUI,
19765	initNonceRefresh: () => initNonceRefresh,
19766	injectElementCSS: () => injectElementCSS,
19767	isElementorAIActive: () => isElementorAIActive,
19768	isElementorEditor: () => isElementorEditor,
19769	isElementorEditorReady: () => isElementorEditorReady,
19770	isGutenbergEditor: () => isGutenbergEditor,
19771	isNonceError: () => isNonceError,
19772	isSelectAllCheckbox: () => isSelectAllCheckbox,
19773	refreshNonce: () => refreshNonce,
19774	removeElementCSS: () => removeElementCSS,
19775	requireConfirmationMessage: () => requireConfirmationMessage,
19776	updateElementSettings: () => updateElementSettings,
19777	updateGutenbergBlockAttributes: () => updateGutenbergBlockAttributes,
19778	validateAndGetGutenbergBlock: () => validateAndGetGutenbergBlock,
19779	waitForElementor: () => waitForElementor,
19780	waitForElementorEditor: () => waitForElementorEditor,
19781	whenElementorReady: () => whenElementorReady
19782	});
19783
19784	//#endregion
19785	//#region \0elementor-package-library-entry
19786	(window.elementorV2 = window.elementorV2 \|\| {}).elementorMcpCommon = src_exports;
19787
19788	//#endregion
19789	})();
19790	window.elementorV2.elementorMcpCommon?.init?.();
19791	//# sourceMappingURL=elementor-mcp-common.js.map