@modelcontextprotocol/server 2.0.0-alpha.3 → 2.0.0-alpha.4

package/dist/{ajvProvider-Birb50r-.mjs → ajvProvider-BQMcjynJ.mjs}

@@ -3448,7 +3448,7 @@ var require_uri = /* @__PURE__ */ __commonJSMin(((exports) => {
 
 //#endregion
 //#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/core.js
-var require_core$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+var require_core$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
 	var validate_1 = require_validate();
@@ -4135,7 +4135,7 @@ var require_ref = /* @__PURE__ */ __commonJSMin(((exports) => {
 
 //#endregion
 //#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/core/index.js
-var require_core = /* @__PURE__ */ __commonJSMin(((exports) => {
+var require_core$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const id_1 = require_id();
 	const ref_1 = require_ref();
@@ -4572,7 +4572,7 @@ var require_enum = /* @__PURE__ */ __commonJSMin(((exports) => {
 
 //#endregion
 //#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/index.js
-var require_validation = /* @__PURE__ */ __commonJSMin(((exports) => {
+var require_validation$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const limitNumber_1 = require_limitNumber();
 	const multipleOf_1 = require_multipleOf();
@@ -5352,7 +5352,7 @@ var require_thenElse = /* @__PURE__ */ __commonJSMin(((exports) => {
 
 //#endregion
 //#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/index.js
-var require_applicator = /* @__PURE__ */ __commonJSMin(((exports) => {
+var require_applicator$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	const additionalItems_1 = require_additionalItems();
 	const prefixItems_1 = require_prefixItems();
@@ -5392,6 +5392,301 @@ var require_applicator = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.default = getApplicator;
 }));
 
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js
+var require_dynamicAnchor = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.dynamicAnchor = void 0;
+	const codegen_1 = require_codegen();
+	const names_1 = require_names();
+	const compile_1 = require_compile();
+	const ref_1 = require_ref();
+	const def = {
+		keyword: "$dynamicAnchor",
+		schemaType: "string",
+		code: (cxt) => dynamicAnchor(cxt, cxt.schema)
+	};
+	function dynamicAnchor(cxt, anchor) {
+		const { gen, it } = cxt;
+		it.schemaEnv.root.dynamicAnchors[anchor] = true;
+		const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`;
+		const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
+		gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate));
+	}
+	exports.dynamicAnchor = dynamicAnchor;
+	function _getValidate(cxt) {
+		const { schemaEnv, schema, self } = cxt.it;
+		const { root, baseId, localRefs, meta } = schemaEnv.root;
+		const { schemaId } = self.opts;
+		const sch = new compile_1.SchemaEnv({
+			schema,
+			schemaId,
+			root,
+			baseId,
+			localRefs,
+			meta
+		});
+		compile_1.compileSchema.call(self, sch);
+		return (0, ref_1.getValidate)(cxt, sch);
+	}
+	exports.default = def;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js
+var require_dynamicRef = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.dynamicRef = void 0;
+	const codegen_1 = require_codegen();
+	const names_1 = require_names();
+	const ref_1 = require_ref();
+	const def = {
+		keyword: "$dynamicRef",
+		schemaType: "string",
+		code: (cxt) => dynamicRef(cxt, cxt.schema)
+	};
+	function dynamicRef(cxt, ref) {
+		const { gen, keyword, it } = cxt;
+		if (ref[0] !== "#") throw new Error(`"${keyword}" only supports hash fragment reference`);
+		const anchor = ref.slice(1);
+		if (it.allErrors) _dynamicRef();
+		else {
+			const valid = gen.let("valid", false);
+			_dynamicRef(valid);
+			cxt.ok(valid);
+		}
+		function _dynamicRef(valid) {
+			if (it.schemaEnv.root.dynamicAnchors[anchor]) {
+				const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`);
+				gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
+			} else _callRef(it.validateName, valid)();
+		}
+		function _callRef(validate, valid) {
+			return valid ? () => gen.block(() => {
+				(0, ref_1.callRef)(cxt, validate);
+				gen.let(valid, true);
+			}) : () => (0, ref_1.callRef)(cxt, validate);
+		}
+	}
+	exports.dynamicRef = dynamicRef;
+	exports.default = def;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js
+var require_recursiveAnchor = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dynamicAnchor_1 = require_dynamicAnchor();
+	const util_1 = require_util();
+	const def = {
+		keyword: "$recursiveAnchor",
+		schemaType: "boolean",
+		code(cxt) {
+			if (cxt.schema) (0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
+			else (0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
+		}
+	};
+	exports.default = def;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js
+var require_recursiveRef = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dynamicRef_1 = require_dynamicRef();
+	const def = {
+		keyword: "$recursiveRef",
+		schemaType: "string",
+		code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
+	};
+	exports.default = def;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/dynamic/index.js
+var require_dynamic = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dynamicAnchor_1 = require_dynamicAnchor();
+	const dynamicRef_1 = require_dynamicRef();
+	const recursiveAnchor_1 = require_recursiveAnchor();
+	const recursiveRef_1 = require_recursiveRef();
+	const dynamic = [
+		dynamicAnchor_1.default,
+		dynamicRef_1.default,
+		recursiveAnchor_1.default,
+		recursiveRef_1.default
+	];
+	exports.default = dynamic;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/dependentRequired.js
+var require_dependentRequired = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dependencies_1 = require_dependencies();
+	const def = {
+		keyword: "dependentRequired",
+		type: "object",
+		schemaType: "object",
+		error: dependencies_1.error,
+		code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt)
+	};
+	exports.default = def;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js
+var require_dependentSchemas = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dependencies_1 = require_dependencies();
+	const def = {
+		keyword: "dependentSchemas",
+		type: "object",
+		schemaType: "object",
+		code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
+	};
+	exports.default = def;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitContains.js
+var require_limitContains = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const util_1 = require_util();
+	const def = {
+		keyword: ["maxContains", "minContains"],
+		type: "array",
+		schemaType: "number",
+		code({ keyword, parentSchema, it }) {
+			if (parentSchema.contains === void 0) (0, util_1.checkStrictMode)(it, `"${keyword}" without "contains" is ignored`);
+		}
+	};
+	exports.default = def;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/next.js
+var require_next = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dependentRequired_1 = require_dependentRequired();
+	const dependentSchemas_1 = require_dependentSchemas();
+	const limitContains_1 = require_limitContains();
+	const next = [
+		dependentRequired_1.default,
+		dependentSchemas_1.default,
+		limitContains_1.default
+	];
+	exports.default = next;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js
+var require_unevaluatedProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const names_1 = require_names();
+	const def = {
+		keyword: "unevaluatedProperties",
+		type: "object",
+		schemaType: ["boolean", "object"],
+		trackErrors: true,
+		error: {
+			message: "must NOT have unevaluated properties",
+			params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
+		},
+		code(cxt) {
+			const { gen, schema, data, errsCount, it } = cxt;
+			/* istanbul ignore if */
+			if (!errsCount) throw new Error("ajv implementation error");
+			const { allErrors, props } = it;
+			if (props instanceof codegen_1.Name) gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
+			else if (props !== true) gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
+			it.props = true;
+			cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+			function unevaluatedPropCode(key) {
+				if (schema === false) {
+					cxt.setParams({ unevaluatedProperty: key });
+					cxt.error();
+					if (!allErrors) gen.break();
+					return;
+				}
+				if (!(0, util_1.alwaysValidSchema)(it, schema)) {
+					const valid = gen.name("valid");
+					cxt.subschema({
+						keyword: "unevaluatedProperties",
+						dataProp: key,
+						dataPropType: util_1.Type.Str
+					}, valid);
+					if (!allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
+				}
+			}
+			function unevaluatedDynamic(evaluatedProps, key) {
+				return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
+			}
+			function unevaluatedStatic(evaluatedProps, key) {
+				const ps = [];
+				for (const p in evaluatedProps) if (evaluatedProps[p] === true) ps.push((0, codegen_1._)`${key} !== ${p}`);
+				return (0, codegen_1.and)(...ps);
+			}
+		}
+	};
+	exports.default = def;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js
+var require_unevaluatedItems = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const def = {
+		keyword: "unevaluatedItems",
+		type: "array",
+		schemaType: ["boolean", "object"],
+		error: {
+			message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
+			params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
+		},
+		code(cxt) {
+			const { gen, schema, data, it } = cxt;
+			const items = it.items || 0;
+			if (items === true) return;
+			const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+			if (schema === false) {
+				cxt.setParams({ len: items });
+				cxt.fail((0, codegen_1._)`${len} > ${items}`);
+			} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+				const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items}`);
+				gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
+				cxt.ok(valid);
+			}
+			it.items = true;
+			function validateItems(valid, from) {
+				gen.forRange("i", from, len, (i) => {
+					cxt.subschema({
+						keyword: "unevaluatedItems",
+						dataProp: i,
+						dataPropType: util_1.Type.Num
+					}, valid);
+					if (!it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
+				});
+			}
+		}
+	};
+	exports.default = def;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/unevaluated/index.js
+var require_unevaluated$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const unevaluatedProperties_1 = require_unevaluatedProperties();
+	const unevaluatedItems_1 = require_unevaluatedItems();
+	const unevaluated = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
+	exports.default = unevaluated;
+}));
+
 //#endregion
 //#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/format/format.js
 var require_format$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -5512,23 +5807,29 @@ var require_metadata = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/draft7.js
-var require_draft7 = /* @__PURE__ */ __commonJSMin(((exports) => {
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/draft2020.js
+var require_draft2020 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
-	const core_1 = require_core();
-	const validation_1 = require_validation();
-	const applicator_1 = require_applicator();
+	const core_1 = require_core$1();
+	const validation_1 = require_validation$1();
+	const applicator_1 = require_applicator$1();
+	const dynamic_1 = require_dynamic();
+	const next_1 = require_next();
+	const unevaluated_1 = require_unevaluated$1();
 	const format_1 = require_format();
 	const metadata_1 = require_metadata();
-	const draft7Vocabularies = [
+	const draft2020Vocabularies = [
+		dynamic_1.default,
 		core_1.default,
 		validation_1.default,
-		(0, applicator_1.default)(),
+		(0, applicator_1.default)(true),
 		format_1.default,
 		metadata_1.metadataVocabulary,
-		metadata_1.contentVocabulary
+		metadata_1.contentVocabulary,
+		next_1.default,
+		unevaluated_1.default
 	];
-	exports.default = draft7Vocabularies;
+	exports.default = draft2020Vocabularies;
 }));
 
 //#endregion
@@ -5639,177 +5940,397 @@ var require_discriminator = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-draft-07.json
-var require_json_schema_draft_07 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-2020-12/schema.json
+var require_schema = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
-		"$schema": "http://json-schema.org/draft-07/schema#",
-		"$id": "http://json-schema.org/draft-07/schema#",
-		"title": "Core schema meta-schema",
-		"definitions": {
-			"schemaArray": {
-				"type": "array",
-				"minItems": 1,
-				"items": { "$ref": "#" }
-			},
-			"nonNegativeInteger": {
-				"type": "integer",
-				"minimum": 0
-			},
-			"nonNegativeIntegerDefault0": { "allOf": [{ "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 }] },
-			"simpleTypes": { "enum": [
-				"array",
-				"boolean",
-				"integer",
-				"null",
-				"number",
-				"object",
-				"string"
-			] },
-			"stringArray": {
-				"type": "array",
-				"items": { "type": "string" },
-				"uniqueItems": true,
-				"default": []
-			}
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/schema",
+		"$vocabulary": {
+			"https://json-schema.org/draft/2020-12/vocab/core": true,
+			"https://json-schema.org/draft/2020-12/vocab/applicator": true,
+			"https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+			"https://json-schema.org/draft/2020-12/vocab/validation": true,
+			"https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+			"https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+			"https://json-schema.org/draft/2020-12/vocab/content": true
 		},
+		"$dynamicAnchor": "meta",
+		"title": "Core and Validation specifications meta-schema",
+		"allOf": [
+			{ "$ref": "meta/core" },
+			{ "$ref": "meta/applicator" },
+			{ "$ref": "meta/unevaluated" },
+			{ "$ref": "meta/validation" },
+			{ "$ref": "meta/meta-data" },
+			{ "$ref": "meta/format-annotation" },
+			{ "$ref": "meta/content" }
+		],
 		"type": ["object", "boolean"],
+		"$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
 		"properties": {
-			"$id": {
-				"type": "string",
-				"format": "uri-reference"
+			"definitions": {
+				"$comment": "\"definitions\" has been replaced by \"$defs\".",
+				"type": "object",
+				"additionalProperties": { "$dynamicRef": "#meta" },
+				"deprecated": true,
+				"default": {}
 			},
-			"$schema": {
-				"type": "string",
-				"format": "uri"
+			"dependencies": {
+				"$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+				"type": "object",
+				"additionalProperties": { "anyOf": [{ "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" }] },
+				"deprecated": true,
+				"default": {}
 			},
-			"$ref": {
-				"type": "string",
-				"format": "uri-reference"
+			"$recursiveAnchor": {
+				"$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+				"$ref": "meta/core#/$defs/anchorString",
+				"deprecated": true
 			},
-			"$comment": { "type": "string" },
-			"title": { "type": "string" },
-			"description": { "type": "string" },
-			"default": true,
-			"readOnly": {
-				"type": "boolean",
-				"default": false
+			"$recursiveRef": {
+				"$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+				"$ref": "meta/core#/$defs/uriReferenceString",
+				"deprecated": true
+			}
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json
+var require_applicator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/applicator",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/applicator": true },
+		"$dynamicAnchor": "meta",
+		"title": "Applicator vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"prefixItems": { "$ref": "#/$defs/schemaArray" },
+			"items": { "$dynamicRef": "#meta" },
+			"contains": { "$dynamicRef": "#meta" },
+			"additionalProperties": { "$dynamicRef": "#meta" },
+			"properties": {
+				"type": "object",
+				"additionalProperties": { "$dynamicRef": "#meta" },
+				"default": {}
 			},
-			"examples": {
-				"type": "array",
-				"items": true
+			"patternProperties": {
+				"type": "object",
+				"additionalProperties": { "$dynamicRef": "#meta" },
+				"propertyNames": { "format": "regex" },
+				"default": {}
 			},
-			"multipleOf": {
-				"type": "number",
-				"exclusiveMinimum": 0
+			"dependentSchemas": {
+				"type": "object",
+				"additionalProperties": { "$dynamicRef": "#meta" },
+				"default": {}
 			},
-			"maximum": { "type": "number" },
-			"exclusiveMaximum": { "type": "number" },
-			"minimum": { "type": "number" },
-			"exclusiveMinimum": { "type": "number" },
-			"maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
-			"minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
-			"pattern": {
-				"type": "string",
-				"format": "regex"
-			},
-			"additionalItems": { "$ref": "#" },
-			"items": {
-				"anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/schemaArray" }],
-				"default": true
-			},
-			"maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
-			"minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
-			"uniqueItems": {
-				"type": "boolean",
-				"default": false
+			"propertyNames": { "$dynamicRef": "#meta" },
+			"if": { "$dynamicRef": "#meta" },
+			"then": { "$dynamicRef": "#meta" },
+			"else": { "$dynamicRef": "#meta" },
+			"allOf": { "$ref": "#/$defs/schemaArray" },
+			"anyOf": { "$ref": "#/$defs/schemaArray" },
+			"oneOf": { "$ref": "#/$defs/schemaArray" },
+			"not": { "$dynamicRef": "#meta" }
+		},
+		"$defs": { "schemaArray": {
+			"type": "array",
+			"minItems": 1,
+			"items": { "$dynamicRef": "#meta" }
+		} }
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json
+var require_unevaluated = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/unevaluated",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/unevaluated": true },
+		"$dynamicAnchor": "meta",
+		"title": "Unevaluated applicator vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"unevaluatedItems": { "$dynamicRef": "#meta" },
+			"unevaluatedProperties": { "$dynamicRef": "#meta" }
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json
+var require_content = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/content",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/content": true },
+		"$dynamicAnchor": "meta",
+		"title": "Content vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"contentEncoding": { "type": "string" },
+			"contentMediaType": { "type": "string" },
+			"contentSchema": { "$dynamicRef": "#meta" }
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json
+var require_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/core",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/core": true },
+		"$dynamicAnchor": "meta",
+		"title": "Core vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"$id": {
+				"$ref": "#/$defs/uriReferenceString",
+				"$comment": "Non-empty fragments not allowed.",
+				"pattern": "^[^#]*#?$"
 			},
-			"contains": { "$ref": "#" },
-			"maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
-			"minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
-			"required": { "$ref": "#/definitions/stringArray" },
-			"additionalProperties": { "$ref": "#" },
-			"definitions": {
+			"$schema": { "$ref": "#/$defs/uriString" },
+			"$ref": { "$ref": "#/$defs/uriReferenceString" },
+			"$anchor": { "$ref": "#/$defs/anchorString" },
+			"$dynamicRef": { "$ref": "#/$defs/uriReferenceString" },
+			"$dynamicAnchor": { "$ref": "#/$defs/anchorString" },
+			"$vocabulary": {
 				"type": "object",
-				"additionalProperties": { "$ref": "#" },
-				"default": {}
+				"propertyNames": { "$ref": "#/$defs/uriString" },
+				"additionalProperties": { "type": "boolean" }
 			},
-			"properties": {
+			"$comment": { "type": "string" },
+			"$defs": {
 				"type": "object",
-				"additionalProperties": { "$ref": "#" },
-				"default": {}
+				"additionalProperties": { "$dynamicRef": "#meta" }
+			}
+		},
+		"$defs": {
+			"anchorString": {
+				"type": "string",
+				"pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
 			},
-			"patternProperties": {
-				"type": "object",
-				"additionalProperties": { "$ref": "#" },
-				"propertyNames": { "format": "regex" },
-				"default": {}
+			"uriString": {
+				"type": "string",
+				"format": "uri"
 			},
-			"dependencies": {
-				"type": "object",
-				"additionalProperties": { "anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/stringArray" }] }
+			"uriReferenceString": {
+				"type": "string",
+				"format": "uri-reference"
+			}
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json
+var require_format_annotation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/format-annotation": true },
+		"$dynamicAnchor": "meta",
+		"title": "Format vocabulary meta-schema for annotation results",
+		"type": ["object", "boolean"],
+		"properties": { "format": { "type": "string" } }
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json
+var require_meta_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/meta-data",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/meta-data": true },
+		"$dynamicAnchor": "meta",
+		"title": "Meta-data vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"title": { "type": "string" },
+			"description": { "type": "string" },
+			"default": true,
+			"deprecated": {
+				"type": "boolean",
+				"default": false
 			},
-			"propertyNames": { "$ref": "#" },
-			"const": true,
-			"enum": {
-				"type": "array",
-				"items": true,
-				"minItems": 1,
-				"uniqueItems": true
+			"readOnly": {
+				"type": "boolean",
+				"default": false
 			},
-			"type": { "anyOf": [{ "$ref": "#/definitions/simpleTypes" }, {
+			"writeOnly": {
+				"type": "boolean",
+				"default": false
+			},
+			"examples": {
 				"type": "array",
-				"items": { "$ref": "#/definitions/simpleTypes" },
+				"items": true
+			}
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
+var require_validation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/validation",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/validation": true },
+		"$dynamicAnchor": "meta",
+		"title": "Validation vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"type": { "anyOf": [{ "$ref": "#/$defs/simpleTypes" }, {
+				"type": "array",
+				"items": { "$ref": "#/$defs/simpleTypes" },
 				"minItems": 1,
 				"uniqueItems": true
 			}] },
-			"format": { "type": "string" },
-			"contentMediaType": { "type": "string" },
-			"contentEncoding": { "type": "string" },
-			"if": { "$ref": "#" },
-			"then": { "$ref": "#" },
-			"else": { "$ref": "#" },
-			"allOf": { "$ref": "#/definitions/schemaArray" },
-			"anyOf": { "$ref": "#/definitions/schemaArray" },
-			"oneOf": { "$ref": "#/definitions/schemaArray" },
-			"not": { "$ref": "#" }
+			"const": true,
+			"enum": {
+				"type": "array",
+				"items": true
+			},
+			"multipleOf": {
+				"type": "number",
+				"exclusiveMinimum": 0
+			},
+			"maximum": { "type": "number" },
+			"exclusiveMaximum": { "type": "number" },
+			"minimum": { "type": "number" },
+			"exclusiveMinimum": { "type": "number" },
+			"maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+			"minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+			"pattern": {
+				"type": "string",
+				"format": "regex"
+			},
+			"maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+			"minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+			"uniqueItems": {
+				"type": "boolean",
+				"default": false
+			},
+			"maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+			"minContains": {
+				"$ref": "#/$defs/nonNegativeInteger",
+				"default": 1
+			},
+			"maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+			"minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+			"required": { "$ref": "#/$defs/stringArray" },
+			"dependentRequired": {
+				"type": "object",
+				"additionalProperties": { "$ref": "#/$defs/stringArray" }
+			}
 		},
-		"default": true
+		"$defs": {
+			"nonNegativeInteger": {
+				"type": "integer",
+				"minimum": 0
+			},
+			"nonNegativeIntegerDefault0": {
+				"$ref": "#/$defs/nonNegativeInteger",
+				"default": 0
+			},
+			"simpleTypes": { "enum": [
+				"array",
+				"boolean",
+				"integer",
+				"null",
+				"number",
+				"object",
+				"string"
+			] },
+			"stringArray": {
+				"type": "array",
+				"items": { "type": "string" },
+				"uniqueItems": true,
+				"default": []
+			}
+		}
 	};
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/ajv.js
-var require_ajv = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-2020-12/index.js
+var require_json_schema_2020_12 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0;
-	const core_1 = require_core$1();
-	const draft7_1 = require_draft7();
-	const discriminator_1 = require_discriminator();
-	const draft7MetaSchema = require_json_schema_draft_07();
+	const metaSchema = require_schema();
+	const applicator = require_applicator();
+	const unevaluated = require_unevaluated();
+	const content = require_content();
+	const core = require_core();
+	const format = require_format_annotation();
+	const metadata = require_meta_data();
+	const validation = require_validation();
 	const META_SUPPORT_DATA = ["/properties"];
-	const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
-	var Ajv = class extends core_1.default {
+	function addMetaSchema2020($data) {
+		[
+			metaSchema,
+			applicator,
+			unevaluated,
+			content,
+			core,
+			with$data(this, format),
+			metadata,
+			with$data(this, validation)
+		].forEach((sch) => this.addMetaSchema(sch, void 0, false));
+		return this;
+		function with$data(ajv, sch) {
+			return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
+		}
+	}
+	exports.default = addMetaSchema2020;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/2020.js
+var require__2020 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2020 = void 0;
+	const core_1 = require_core$2();
+	const draft2020_1 = require_draft2020();
+	const discriminator_1 = require_discriminator();
+	const json_schema_2020_12_1 = require_json_schema_2020_12();
+	const META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
+	var Ajv2020 = class extends core_1.default {
+		constructor(opts = {}) {
+			super({
+				...opts,
+				dynamicRef: true,
+				next: true,
+				unevaluated: true
+			});
+		}
 		_addVocabularies() {
 			super._addVocabularies();
-			draft7_1.default.forEach((v) => this.addVocabulary(v));
+			draft2020_1.default.forEach((v) => this.addVocabulary(v));
 			if (this.opts.discriminator) this.addKeyword(discriminator_1.default);
 		}
 		_addDefaultMetaSchema() {
 			super._addDefaultMetaSchema();
-			if (!this.opts.meta) return;
-			const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema;
-			this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
+			const { $data, meta } = this.opts;
+			if (!meta) return;
+			json_schema_2020_12_1.default.call(this, $data);
 			this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
 		}
 		defaultMeta() {
 			return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
 		}
 	};
-	exports.Ajv = Ajv;
-	module.exports = exports = Ajv;
-	module.exports.Ajv = Ajv;
+	exports.Ajv2020 = Ajv2020;
+	module.exports = exports = Ajv2020;
+	module.exports.Ajv2020 = Ajv2020;
 	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.default = Ajv;
+	exports.default = Ajv2020;
 	var validate_1 = require_validate();
 	Object.defineProperty(exports, "KeywordCxt", {
 		enumerable: true,
@@ -6059,6 +6580,258 @@ var require_formats = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 }));
 
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/draft7.js
+var require_draft7 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const core_1 = require_core$1();
+	const validation_1 = require_validation$1();
+	const applicator_1 = require_applicator$1();
+	const format_1 = require_format();
+	const metadata_1 = require_metadata();
+	const draft7Vocabularies = [
+		core_1.default,
+		validation_1.default,
+		(0, applicator_1.default)(),
+		format_1.default,
+		metadata_1.metadataVocabulary,
+		metadata_1.contentVocabulary
+	];
+	exports.default = draft7Vocabularies;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-draft-07.json
+var require_json_schema_draft_07 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "http://json-schema.org/draft-07/schema#",
+		"$id": "http://json-schema.org/draft-07/schema#",
+		"title": "Core schema meta-schema",
+		"definitions": {
+			"schemaArray": {
+				"type": "array",
+				"minItems": 1,
+				"items": { "$ref": "#" }
+			},
+			"nonNegativeInteger": {
+				"type": "integer",
+				"minimum": 0
+			},
+			"nonNegativeIntegerDefault0": { "allOf": [{ "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 }] },
+			"simpleTypes": { "enum": [
+				"array",
+				"boolean",
+				"integer",
+				"null",
+				"number",
+				"object",
+				"string"
+			] },
+			"stringArray": {
+				"type": "array",
+				"items": { "type": "string" },
+				"uniqueItems": true,
+				"default": []
+			}
+		},
+		"type": ["object", "boolean"],
+		"properties": {
+			"$id": {
+				"type": "string",
+				"format": "uri-reference"
+			},
+			"$schema": {
+				"type": "string",
+				"format": "uri"
+			},
+			"$ref": {
+				"type": "string",
+				"format": "uri-reference"
+			},
+			"$comment": { "type": "string" },
+			"title": { "type": "string" },
+			"description": { "type": "string" },
+			"default": true,
+			"readOnly": {
+				"type": "boolean",
+				"default": false
+			},
+			"examples": {
+				"type": "array",
+				"items": true
+			},
+			"multipleOf": {
+				"type": "number",
+				"exclusiveMinimum": 0
+			},
+			"maximum": { "type": "number" },
+			"exclusiveMaximum": { "type": "number" },
+			"minimum": { "type": "number" },
+			"exclusiveMinimum": { "type": "number" },
+			"maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+			"minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+			"pattern": {
+				"type": "string",
+				"format": "regex"
+			},
+			"additionalItems": { "$ref": "#" },
+			"items": {
+				"anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/schemaArray" }],
+				"default": true
+			},
+			"maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+			"minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+			"uniqueItems": {
+				"type": "boolean",
+				"default": false
+			},
+			"contains": { "$ref": "#" },
+			"maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+			"minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+			"required": { "$ref": "#/definitions/stringArray" },
+			"additionalProperties": { "$ref": "#" },
+			"definitions": {
+				"type": "object",
+				"additionalProperties": { "$ref": "#" },
+				"default": {}
+			},
+			"properties": {
+				"type": "object",
+				"additionalProperties": { "$ref": "#" },
+				"default": {}
+			},
+			"patternProperties": {
+				"type": "object",
+				"additionalProperties": { "$ref": "#" },
+				"propertyNames": { "format": "regex" },
+				"default": {}
+			},
+			"dependencies": {
+				"type": "object",
+				"additionalProperties": { "anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/stringArray" }] }
+			},
+			"propertyNames": { "$ref": "#" },
+			"const": true,
+			"enum": {
+				"type": "array",
+				"items": true,
+				"minItems": 1,
+				"uniqueItems": true
+			},
+			"type": { "anyOf": [{ "$ref": "#/definitions/simpleTypes" }, {
+				"type": "array",
+				"items": { "$ref": "#/definitions/simpleTypes" },
+				"minItems": 1,
+				"uniqueItems": true
+			}] },
+			"format": { "type": "string" },
+			"contentMediaType": { "type": "string" },
+			"contentEncoding": { "type": "string" },
+			"if": { "$ref": "#" },
+			"then": { "$ref": "#" },
+			"else": { "$ref": "#" },
+			"allOf": { "$ref": "#/definitions/schemaArray" },
+			"anyOf": { "$ref": "#/definitions/schemaArray" },
+			"oneOf": { "$ref": "#/definitions/schemaArray" },
+			"not": { "$ref": "#" }
+		},
+		"default": true
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/ajv.js
+var require_ajv = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0;
+	const core_1 = require_core$2();
+	const draft7_1 = require_draft7();
+	const discriminator_1 = require_discriminator();
+	const draft7MetaSchema = require_json_schema_draft_07();
+	const META_SUPPORT_DATA = ["/properties"];
+	const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
+	var Ajv = class extends core_1.default {
+		_addVocabularies() {
+			super._addVocabularies();
+			draft7_1.default.forEach((v) => this.addVocabulary(v));
+			if (this.opts.discriminator) this.addKeyword(discriminator_1.default);
+		}
+		_addDefaultMetaSchema() {
+			super._addDefaultMetaSchema();
+			if (!this.opts.meta) return;
+			const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema;
+			this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
+			this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+		}
+		defaultMeta() {
+			return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
+		}
+	};
+	exports.Ajv = Ajv;
+	module.exports = exports = Ajv;
+	module.exports.Ajv = Ajv;
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = Ajv;
+	var validate_1 = require_validate();
+	Object.defineProperty(exports, "KeywordCxt", {
+		enumerable: true,
+		get: function() {
+			return validate_1.KeywordCxt;
+		}
+	});
+	var codegen_1 = require_codegen();
+	Object.defineProperty(exports, "_", {
+		enumerable: true,
+		get: function() {
+			return codegen_1._;
+		}
+	});
+	Object.defineProperty(exports, "str", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.str;
+		}
+	});
+	Object.defineProperty(exports, "stringify", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.stringify;
+		}
+	});
+	Object.defineProperty(exports, "nil", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.nil;
+		}
+	});
+	Object.defineProperty(exports, "Name", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.Name;
+		}
+	});
+	Object.defineProperty(exports, "CodeGen", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.CodeGen;
+		}
+	});
+	var validation_error_1 = require_validation_error();
+	Object.defineProperty(exports, "ValidationError", {
+		enumerable: true,
+		get: function() {
+			return validation_error_1.default;
+		}
+	});
+	var ref_error_1 = require_ref_error();
+	Object.defineProperty(exports, "MissingRefError", {
+		enumerable: true,
+		get: function() {
+			return ref_error_1.default;
+		}
+	});
+}));
+
 //#endregion
 //#region ../../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.18.0/node_modules/ajv-formats/dist/limit.js
 var require_limit = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -6176,22 +6949,38 @@ var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 
 //#endregion
 //#region ../core-internal/src/validators/ajvProvider.ts
-var import_ajv = require_ajv();
+var import__2020 = require__2020();
 var import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
+var import_ajv = require_ajv();
+/**
+* Canonical 2020-12 `$schema` URIs (http + https variants, trailing-`#` stripped). When a schema
+* declares anything else, the default provider throws a plain `Error` with a clear message rather
+* than letting the engine crash on an opaque internal error or silently mis-validate.
+*/
+const DRAFT_2020_12_URIS = new Set(["https://json-schema.org/draft/2020-12/schema", "http://json-schema.org/draft/2020-12/schema"]);
+const addFormats = import_dist.default;
 function createDefaultAjvInstance() {
-	const ajv = new import_ajv.Ajv({
+	const ajv = new import__2020.Ajv2020({
 		strict: false,
 		validateFormats: true,
 		validateSchema: false,
 		allErrors: true
 	});
-	(0, import_dist.default)(ajv);
+	addFormats(ajv);
 	return ajv;
 }
 /**
 * AJV-backed JSON Schema validator. See `@modelcontextprotocol/{client,server}/validators/ajv`
 * for the customisation entry point (re-exports `Ajv` and `addFormats` from the bundled copy).
 *
+* Default validates as **JSON Schema 2020-12** (SEP-1613). Schemas declaring a different
+* `$schema` are rejected with a plain `Error`; pass a pre-configured Ajv instance to validate
+* other dialects. The SDK bundles ajv internally but does not re-export `Ajv2020` (its type
+* graph tips downstream declaration bundling — see #2339). To construct a custom 2020-12
+* instance, add `ajv` to your own dependencies (matching the SDK's pinned version) and
+* `import { Ajv2020 } from 'ajv/dist/2020.js'` — `new Ajv(...)` is the draft-07 class and would
+* silently downgrade dialect.
+*
 * @example Use with default configuration
 * ```ts source="./ajvProvider.examples.ts#AjvJsonSchemaValidator_default"
 * const validator = new AjvJsonSchemaValidator();
@@ -6199,29 +6988,40 @@ function createDefaultAjvInstance() {
 *
 * @example Use with a custom AJV instance
 * ```ts source="./ajvProvider.examples.ts#AjvJsonSchemaValidator_customInstance"
-* const ajv = new Ajv({ strict: true, allErrors: true });
+* // import { Ajv2020 } from 'ajv/dist/2020.js';
+* const ajv = new Ajv2020({ strict: false, validateSchema: false, allErrors: true });
 * const validator = new AjvJsonSchemaValidator(ajv);
 * ```
 *
 * @example Register ajv-formats
 * ```ts source="./ajvProvider.examples.ts#AjvJsonSchemaValidator_withFormats"
-* const ajv = new Ajv({ strict: true, allErrors: true });
+* // import { Ajv2020 } from 'ajv/dist/2020.js';
+* const ajv = new Ajv2020({ strict: false, validateSchema: false, allErrors: true });
 * addFormats(ajv);
 * const validator = new AjvJsonSchemaValidator(ajv);
 * ```
 */
 var AjvJsonSchemaValidator = class {
 	_ajv;
+	/** True iff the constructor received a caller-supplied engine; the `$schema` check is skipped. */
+	_userAjv;
 	/**
-	* @param ajv - Optional pre-configured AJV-compatible instance. If omitted, a default instance is
-	* created with `strict: false`, `validateFormats: true`, `validateSchema: false`, `allErrors: true`,
-	* and `ajv-formats` registered. The parameter is typed structurally so consumers who don't pass
-	* an instance need not have `ajv` installed.
+	* @param ajv - Optional pre-configured AJV-compatible instance. When supplied, this instance is
+	* used for **every** schema regardless of its declared `$schema` (the caller owns dialect
+	* choice). When omitted, the provider constructs a single `Ajv2020` instance with
+	* `strict: false`, `validateFormats: true`, `validateSchema: false`, `allErrors: true`, and
+	* `ajv-formats` registered. The parameter is typed structurally so consumers who don't pass an
+	* instance need not have `ajv` installed.
 	*/
 	constructor(ajv) {
+		this._userAjv = ajv !== void 0;
 		this._ajv = ajv ?? createDefaultAjvInstance();
 	}
 	getValidator(schema) {
+		if (!this._userAjv && "$schema" in schema && typeof schema.$schema === "string" && !DRAFT_2020_12_URIS.has(schema.$schema.replace(/#$/, ""))) {
+			const declared = schema.$schema.slice(0, 200);
+			throw new Error(`JSON Schema declares an unsupported dialect ("$schema": "${declared}"). The default validator supports JSON Schema 2020-12 only; pass a pre-configured Ajv instance to AjvJsonSchemaValidator(ajv) to validate other dialects.`);
+		}
 		const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
 		return (input) => {
 			return ajvValidator(input) ? {
@@ -6236,9 +7036,7 @@ var AjvJsonSchemaValidator = class {
 		};
 	}
 };
-/** `ajv-formats` default export, normalised through the CJS/ESM interop wrapper. */
-const addFormats = import_dist.default;
 
 //#endregion
 export { addFormats as n, import_ajv as r, AjvJsonSchemaValidator as t };
-//# sourceMappingURL=ajvProvider-Birb50r-.mjs.map
+//# sourceMappingURL=ajvProvider-BQMcjynJ.mjs.map