@opentiny/next-sdk 0.1.12 → 0.1.14

package/dist/{mcpsdk@1.20.1.dev.js → mcpsdk@1.17.0.dev.js}

@@ -1021,8 +1021,8 @@
   var util$7 = {};
   Object.defineProperty(util$7, "__esModule", { value: true });
   util$7.checkStrictMode = util$7.getErrorPath = util$7.Type = util$7.useFunc = util$7.setEvaluated = util$7.evaluatedPropsToName = util$7.mergeEvaluated = util$7.eachItem = util$7.unescapeJsonPointer = util$7.escapeJsonPointer = util$7.escapeFragment = util$7.unescapeFragment = util$7.schemaRefOrVal = util$7.schemaHasRulesButRef = util$7.schemaHasRules = util$7.checkUnknownRules = util$7.alwaysValidSchema = util$7.toHash = void 0;
-  const codegen_1$q = codegen;
-  const code_1$9 = code$1;
+  const codegen_1$v = codegen;
+  const code_1$a = code$1;
   function toHash$2(arr) {
     const hash = {};
     for (const item of arr)
@@ -1075,9 +1075,9 @@
       if (typeof schema == "number" || typeof schema == "boolean")
         return schema;
       if (typeof schema == "string")
-        return (0, codegen_1$q._)`${schema}`;
+        return (0, codegen_1$v._)`${schema}`;
     }
-    return (0, codegen_1$q._)`${topSchemaRef}${schemaPath}${(0, codegen_1$q.getProperty)(keyword2)}`;
+    return (0, codegen_1$v._)`${topSchemaRef}${schemaPath}${(0, codegen_1$v.getProperty)(keyword2)}`;
   }
   util$7.schemaRefOrVal = schemaRefOrVal;
   function unescapeFragment$1(str) {
@@ -1109,20 +1109,20 @@
   util$7.eachItem = eachItem;
   function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues: mergeValues2, resultToName }) {
     return (gen, from, to, toName) => {
-      const res = to === void 0 ? from : to instanceof codegen_1$q.Name ? (from instanceof codegen_1$q.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1$q.Name ? (mergeToName(gen, to, from), from) : mergeValues2(from, to);
-      return toName === codegen_1$q.Name && !(res instanceof codegen_1$q.Name) ? resultToName(gen, res) : res;
+      const res = to === void 0 ? from : to instanceof codegen_1$v.Name ? (from instanceof codegen_1$v.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1$v.Name ? (mergeToName(gen, to, from), from) : mergeValues2(from, to);
+      return toName === codegen_1$v.Name && !(res instanceof codegen_1$v.Name) ? resultToName(gen, res) : res;
     };
   }
   util$7.mergeEvaluated = {
     props: makeMergeEvaluated({
-      mergeNames: (gen, from, to) => gen.if((0, codegen_1$q._)`${to} !== true && ${from} !== undefined`, () => {
-        gen.if((0, codegen_1$q._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1$q._)`${to} || {}`).code((0, codegen_1$q._)`Object.assign(${to}, ${from})`));
+      mergeNames: (gen, from, to) => gen.if((0, codegen_1$v._)`${to} !== true && ${from} !== undefined`, () => {
+        gen.if((0, codegen_1$v._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1$v._)`${to} || {}`).code((0, codegen_1$v._)`Object.assign(${to}, ${from})`));
       }),
-      mergeToName: (gen, from, to) => gen.if((0, codegen_1$q._)`${to} !== true`, () => {
+      mergeToName: (gen, from, to) => gen.if((0, codegen_1$v._)`${to} !== true`, () => {
         if (from === true) {
           gen.assign(to, true);
         } else {
-          gen.assign(to, (0, codegen_1$q._)`${to} || {}`);
+          gen.assign(to, (0, codegen_1$v._)`${to} || {}`);
           setEvaluated(gen, to, from);
         }
       }),
@@ -1130,8 +1130,8 @@
       resultToName: evaluatedPropsToName
     }),
     items: makeMergeEvaluated({
-      mergeNames: (gen, from, to) => gen.if((0, codegen_1$q._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1$q._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
-      mergeToName: (gen, from, to) => gen.if((0, codegen_1$q._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1$q._)`${to} > ${from} ? ${to} : ${from}`)),
+      mergeNames: (gen, from, to) => gen.if((0, codegen_1$v._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1$v._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
+      mergeToName: (gen, from, to) => gen.if((0, codegen_1$v._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1$v._)`${to} > ${from} ? ${to} : ${from}`)),
       mergeValues: (from, to) => from === true ? true : Math.max(from, to),
       resultToName: (gen, items2) => gen.var("items", items2)
     })
@@ -1139,21 +1139,21 @@
   function evaluatedPropsToName(gen, ps) {
     if (ps === true)
       return gen.var("props", true);
-    const props = gen.var("props", (0, codegen_1$q._)`{}`);
+    const props = gen.var("props", (0, codegen_1$v._)`{}`);
     if (ps !== void 0)
       setEvaluated(gen, props, ps);
     return props;
   }
   util$7.evaluatedPropsToName = evaluatedPropsToName;
   function setEvaluated(gen, props, ps) {
-    Object.keys(ps).forEach((p) => gen.assign((0, codegen_1$q._)`${props}${(0, codegen_1$q.getProperty)(p)}`, true));
+    Object.keys(ps).forEach((p) => gen.assign((0, codegen_1$v._)`${props}${(0, codegen_1$v.getProperty)(p)}`, true));
   }
   util$7.setEvaluated = setEvaluated;
   const snippets = {};
   function useFunc(gen, f) {
     return gen.scopeValue("func", {
       ref: f,
-      code: snippets[f.code] || (snippets[f.code] = new code_1$9._Code(f.code))
+      code: snippets[f.code] || (snippets[f.code] = new code_1$a._Code(f.code))
     });
   }
   util$7.useFunc = useFunc;
@@ -1163,11 +1163,11 @@
     Type2[Type2["Str"] = 1] = "Str";
   })(Type || (util$7.Type = Type = {}));
   function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
-    if (dataProp instanceof codegen_1$q.Name) {
+    if (dataProp instanceof codegen_1$v.Name) {
       const isNumber = dataPropType === Type.Num;
-      return jsPropertySyntax ? isNumber ? (0, codegen_1$q._)`"[" + ${dataProp} + "]"` : (0, codegen_1$q._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1$q._)`"/" + ${dataProp}` : (0, codegen_1$q._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
+      return jsPropertySyntax ? isNumber ? (0, codegen_1$v._)`"[" + ${dataProp} + "]"` : (0, codegen_1$v._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1$v._)`"/" + ${dataProp}` : (0, codegen_1$v._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
     }
-    return jsPropertySyntax ? (0, codegen_1$q.getProperty)(dataProp).toString() : "/" + escapeJsonPointer$1(dataProp);
+    return jsPropertySyntax ? (0, codegen_1$v.getProperty)(dataProp).toString() : "/" + escapeJsonPointer$1(dataProp);
   }
   util$7.getErrorPath = getErrorPath;
   function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
@@ -1181,35 +1181,35 @@
   util$7.checkStrictMode = checkStrictMode;
   var names$1 = {};
   Object.defineProperty(names$1, "__esModule", { value: true });
-  const codegen_1$p = codegen;
+  const codegen_1$u = codegen;
   const names = {
     // validation function arguments
-    data: new codegen_1$p.Name("data"),
+    data: new codegen_1$u.Name("data"),
     // data passed to validation function
     // args passed from referencing schema
-    valCxt: new codegen_1$p.Name("valCxt"),
+    valCxt: new codegen_1$u.Name("valCxt"),
     // validation/data context - should not be used directly, it is destructured to the names below
-    instancePath: new codegen_1$p.Name("instancePath"),
-    parentData: new codegen_1$p.Name("parentData"),
-    parentDataProperty: new codegen_1$p.Name("parentDataProperty"),
-    rootData: new codegen_1$p.Name("rootData"),
+    instancePath: new codegen_1$u.Name("instancePath"),
+    parentData: new codegen_1$u.Name("parentData"),
+    parentDataProperty: new codegen_1$u.Name("parentDataProperty"),
+    rootData: new codegen_1$u.Name("rootData"),
     // root data - same as the data passed to the first/top validation function
-    dynamicAnchors: new codegen_1$p.Name("dynamicAnchors"),
+    dynamicAnchors: new codegen_1$u.Name("dynamicAnchors"),
     // used to support recursiveRef and dynamicRef
     // function scoped variables
-    vErrors: new codegen_1$p.Name("vErrors"),
+    vErrors: new codegen_1$u.Name("vErrors"),
     // null or array of validation errors
-    errors: new codegen_1$p.Name("errors"),
+    errors: new codegen_1$u.Name("errors"),
     // counter of validation errors
-    this: new codegen_1$p.Name("this"),
+    this: new codegen_1$u.Name("this"),
     // "globals"
-    self: new codegen_1$p.Name("self"),
-    scope: new codegen_1$p.Name("scope"),
+    self: new codegen_1$u.Name("self"),
+    scope: new codegen_1$u.Name("scope"),
     // JTD serialize/parse name for JSON string and position
-    json: new codegen_1$p.Name("json"),
-    jsonPos: new codegen_1$p.Name("jsonPos"),
-    jsonLen: new codegen_1$p.Name("jsonLen"),
-    jsonPart: new codegen_1$p.Name("jsonPart")
+    json: new codegen_1$u.Name("json"),
+    jsonPos: new codegen_1$u.Name("jsonPos"),
+    jsonLen: new codegen_1$u.Name("jsonLen"),
+    jsonPart: new codegen_1$u.Name("jsonPart")
   };
   names$1.default = names;
   (function(exports3) {
@@ -1329,55 +1329,49 @@
         keyValues.push([E.propertyName, propertyName]);
     }
   })(errors);
-  var hasRequiredBoolSchema;
-  function requireBoolSchema() {
-    if (hasRequiredBoolSchema) return boolSchema;
-    hasRequiredBoolSchema = 1;
-    Object.defineProperty(boolSchema, "__esModule", { value: true });
-    boolSchema.boolOrEmptySchema = boolSchema.topBoolOrEmptySchema = void 0;
-    const errors_12 = errors;
-    const codegen_12 = codegen;
-    const names_12 = names$1;
-    const boolError = {
-      message: "boolean schema is false"
-    };
-    function topBoolOrEmptySchema(it) {
-      const { gen, schema, validateName } = it;
-      if (schema === false) {
-        falseSchemaError(it, false);
-      } else if (typeof schema == "object" && schema.$async === true) {
-        gen.return(names_12.default.data);
-      } else {
-        gen.assign((0, codegen_12._)`${validateName}.errors`, null);
-        gen.return(true);
-      }
-    }
-    boolSchema.topBoolOrEmptySchema = topBoolOrEmptySchema;
-    function boolOrEmptySchema(it, valid) {
-      const { gen, schema } = it;
-      if (schema === false) {
-        gen.var(valid, false);
-        falseSchemaError(it);
-      } else {
-        gen.var(valid, true);
-      }
+  Object.defineProperty(boolSchema, "__esModule", { value: true });
+  boolSchema.boolOrEmptySchema = boolSchema.topBoolOrEmptySchema = void 0;
+  const errors_1$3 = errors;
+  const codegen_1$t = codegen;
+  const names_1$6 = names$1;
+  const boolError = {
+    message: "boolean schema is false"
+  };
+  function topBoolOrEmptySchema(it) {
+    const { gen, schema, validateName } = it;
+    if (schema === false) {
+      falseSchemaError(it, false);
+    } else if (typeof schema == "object" && schema.$async === true) {
+      gen.return(names_1$6.default.data);
+    } else {
+      gen.assign((0, codegen_1$t._)`${validateName}.errors`, null);
+      gen.return(true);
     }
-    boolSchema.boolOrEmptySchema = boolOrEmptySchema;
-    function falseSchemaError(it, overrideAllErrors) {
-      const { gen, data: data2 } = it;
-      const cxt = {
-        gen,
-        keyword: "false schema",
-        data: data2,
-        schema: false,
-        schemaCode: false,
-        schemaValue: false,
-        params: {},
-        it
-      };
-      (0, errors_12.reportError)(cxt, boolError, void 0, overrideAllErrors);
+  }
+  boolSchema.topBoolOrEmptySchema = topBoolOrEmptySchema;
+  function boolOrEmptySchema(it, valid) {
+    const { gen, schema } = it;
+    if (schema === false) {
+      gen.var(valid, false);
+      falseSchemaError(it);
+    } else {
+      gen.var(valid, true);
     }
-    return boolSchema;
+  }
+  boolSchema.boolOrEmptySchema = boolOrEmptySchema;
+  function falseSchemaError(it, overrideAllErrors) {
+    const { gen, data: data2 } = it;
+    const cxt = {
+      gen,
+      keyword: "false schema",
+      data: data2,
+      schema: false,
+      schemaCode: false,
+      schemaValue: false,
+      params: {},
+      it
+    };
+    (0, errors_1$3.reportError)(cxt, boolError, void 0, overrideAllErrors);
   }
   var dataType = {};
   var rules$2 = {};
@@ -1425,10 +1419,10 @@
   Object.defineProperty(dataType, "__esModule", { value: true });
   dataType.reportTypeError = dataType.checkDataTypes = dataType.checkDataType = dataType.coerceAndCheckDataType = dataType.getJSONTypes = dataType.getSchemaTypes = dataType.DataType = void 0;
   const rules_1 = rules$2;
-  const applicability_1 = applicability;
-  const errors_1 = errors;
-  const codegen_1$o = codegen;
-  const util_1$n = util$7;
+  const applicability_1$1 = applicability;
+  const errors_1$2 = errors;
+  const codegen_1$s = codegen;
+  const util_1$q = util$7;
   var DataType;
   (function(DataType2) {
     DataType2[DataType2["Correct"] = 0] = "Correct";
@@ -1460,7 +1454,7 @@
   function coerceAndCheckDataType(it, types2) {
     const { gen, data: data2, opts } = it;
     const coerceTo = coerceToTypes$1(types2, opts.coerceTypes);
-    const checkTypes = types2.length > 0 && !(coerceTo.length === 0 && types2.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types2[0]));
+    const checkTypes = types2.length > 0 && !(coerceTo.length === 0 && types2.length === 1 && (0, applicability_1$1.schemaHasRulesForType)(it, types2[0]));
     if (checkTypes) {
       const wrongType = checkDataTypes$1(types2, data2, opts.strictNumbers, DataType.Wrong);
       gen.if(wrongType, () => {
@@ -1479,12 +1473,12 @@
   }
   function coerceData(it, types2, coerceTo) {
     const { gen, data: data2, opts } = it;
-    const dataType2 = gen.let("dataType", (0, codegen_1$o._)`typeof ${data2}`);
-    const coerced = gen.let("coerced", (0, codegen_1$o._)`undefined`);
+    const dataType2 = gen.let("dataType", (0, codegen_1$s._)`typeof ${data2}`);
+    const coerced = gen.let("coerced", (0, codegen_1$s._)`undefined`);
     if (opts.coerceTypes === "array") {
-      gen.if((0, codegen_1$o._)`${dataType2} == 'object' && Array.isArray(${data2}) && ${data2}.length == 1`, () => gen.assign(data2, (0, codegen_1$o._)`${data2}[0]`).assign(dataType2, (0, codegen_1$o._)`typeof ${data2}`).if(checkDataTypes$1(types2, data2, opts.strictNumbers), () => gen.assign(coerced, data2)));
+      gen.if((0, codegen_1$s._)`${dataType2} == 'object' && Array.isArray(${data2}) && ${data2}.length == 1`, () => gen.assign(data2, (0, codegen_1$s._)`${data2}[0]`).assign(dataType2, (0, codegen_1$s._)`typeof ${data2}`).if(checkDataTypes$1(types2, data2, opts.strictNumbers), () => gen.assign(coerced, data2)));
     }
-    gen.if((0, codegen_1$o._)`${coerced} !== undefined`);
+    gen.if((0, codegen_1$s._)`${coerced} !== undefined`);
     for (const t of coerceTo) {
       if (COERCIBLE.has(t) || t === "array" && opts.coerceTypes === "array") {
         coerceSpecificType(t);
@@ -1493,63 +1487,63 @@
     gen.else();
     reportTypeError(it);
     gen.endIf();
-    gen.if((0, codegen_1$o._)`${coerced} !== undefined`, () => {
+    gen.if((0, codegen_1$s._)`${coerced} !== undefined`, () => {
       gen.assign(data2, coerced);
       assignParentData(it, coerced);
     });
     function coerceSpecificType(t) {
       switch (t) {
         case "string":
-          gen.elseIf((0, codegen_1$o._)`${dataType2} == "number" || ${dataType2} == "boolean"`).assign(coerced, (0, codegen_1$o._)`"" + ${data2}`).elseIf((0, codegen_1$o._)`${data2} === null`).assign(coerced, (0, codegen_1$o._)`""`);
+          gen.elseIf((0, codegen_1$s._)`${dataType2} == "number" || ${dataType2} == "boolean"`).assign(coerced, (0, codegen_1$s._)`"" + ${data2}`).elseIf((0, codegen_1$s._)`${data2} === null`).assign(coerced, (0, codegen_1$s._)`""`);
           return;
         case "number":
-          gen.elseIf((0, codegen_1$o._)`${dataType2} == "boolean" || ${data2} === null
-              || (${dataType2} == "string" && ${data2} && ${data2} == +${data2})`).assign(coerced, (0, codegen_1$o._)`+${data2}`);
+          gen.elseIf((0, codegen_1$s._)`${dataType2} == "boolean" || ${data2} === null
+              || (${dataType2} == "string" && ${data2} && ${data2} == +${data2})`).assign(coerced, (0, codegen_1$s._)`+${data2}`);
           return;
         case "integer":
-          gen.elseIf((0, codegen_1$o._)`${dataType2} === "boolean" || ${data2} === null
-              || (${dataType2} === "string" && ${data2} && ${data2} == +${data2} && !(${data2} % 1))`).assign(coerced, (0, codegen_1$o._)`+${data2}`);
+          gen.elseIf((0, codegen_1$s._)`${dataType2} === "boolean" || ${data2} === null
+              || (${dataType2} === "string" && ${data2} && ${data2} == +${data2} && !(${data2} % 1))`).assign(coerced, (0, codegen_1$s._)`+${data2}`);
           return;
         case "boolean":
-          gen.elseIf((0, codegen_1$o._)`${data2} === "false" || ${data2} === 0 || ${data2} === null`).assign(coerced, false).elseIf((0, codegen_1$o._)`${data2} === "true" || ${data2} === 1`).assign(coerced, true);
+          gen.elseIf((0, codegen_1$s._)`${data2} === "false" || ${data2} === 0 || ${data2} === null`).assign(coerced, false).elseIf((0, codegen_1$s._)`${data2} === "true" || ${data2} === 1`).assign(coerced, true);
           return;
         case "null":
-          gen.elseIf((0, codegen_1$o._)`${data2} === "" || ${data2} === 0 || ${data2} === false`);
+          gen.elseIf((0, codegen_1$s._)`${data2} === "" || ${data2} === 0 || ${data2} === false`);
           gen.assign(coerced, null);
           return;
         case "array":
-          gen.elseIf((0, codegen_1$o._)`${dataType2} === "string" || ${dataType2} === "number"
-              || ${dataType2} === "boolean" || ${data2} === null`).assign(coerced, (0, codegen_1$o._)`[${data2}]`);
+          gen.elseIf((0, codegen_1$s._)`${dataType2} === "string" || ${dataType2} === "number"
+              || ${dataType2} === "boolean" || ${data2} === null`).assign(coerced, (0, codegen_1$s._)`[${data2}]`);
       }
     }
   }
   function assignParentData({ gen, parentData, parentDataProperty }, expr) {
-    gen.if((0, codegen_1$o._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1$o._)`${parentData}[${parentDataProperty}]`, expr));
+    gen.if((0, codegen_1$s._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1$s._)`${parentData}[${parentDataProperty}]`, expr));
   }
   function checkDataType$1(dataType2, data2, strictNums, correct = DataType.Correct) {
-    const EQ = correct === DataType.Correct ? codegen_1$o.operators.EQ : codegen_1$o.operators.NEQ;
+    const EQ = correct === DataType.Correct ? codegen_1$s.operators.EQ : codegen_1$s.operators.NEQ;
     let cond;
     switch (dataType2) {
       case "null":
-        return (0, codegen_1$o._)`${data2} ${EQ} null`;
+        return (0, codegen_1$s._)`${data2} ${EQ} null`;
       case "array":
-        cond = (0, codegen_1$o._)`Array.isArray(${data2})`;
+        cond = (0, codegen_1$s._)`Array.isArray(${data2})`;
         break;
       case "object":
-        cond = (0, codegen_1$o._)`${data2} && typeof ${data2} == "object" && !Array.isArray(${data2})`;
+        cond = (0, codegen_1$s._)`${data2} && typeof ${data2} == "object" && !Array.isArray(${data2})`;
         break;
       case "integer":
-        cond = numCond((0, codegen_1$o._)`!(${data2} % 1) && !isNaN(${data2})`);
+        cond = numCond((0, codegen_1$s._)`!(${data2} % 1) && !isNaN(${data2})`);
         break;
       case "number":
         cond = numCond();
         break;
       default:
-        return (0, codegen_1$o._)`typeof ${data2} ${EQ} ${dataType2}`;
+        return (0, codegen_1$s._)`typeof ${data2} ${EQ} ${dataType2}`;
     }
-    return correct === DataType.Correct ? cond : (0, codegen_1$o.not)(cond);
-    function numCond(_cond = codegen_1$o.nil) {
-      return (0, codegen_1$o.and)((0, codegen_1$o._)`typeof ${data2} == "number"`, _cond, strictNums ? (0, codegen_1$o._)`isFinite(${data2})` : codegen_1$o.nil);
+    return correct === DataType.Correct ? cond : (0, codegen_1$s.not)(cond);
+    function numCond(_cond = codegen_1$s.nil) {
+      return (0, codegen_1$s.and)((0, codegen_1$s._)`typeof ${data2} == "number"`, _cond, strictNums ? (0, codegen_1$s._)`isFinite(${data2})` : codegen_1$s.nil);
     }
   }
   dataType.checkDataType = checkDataType$1;
@@ -1558,35 +1552,35 @@
       return checkDataType$1(dataTypes[0], data2, strictNums, correct);
     }
     let cond;
-    const types2 = (0, util_1$n.toHash)(dataTypes);
+    const types2 = (0, util_1$q.toHash)(dataTypes);
     if (types2.array && types2.object) {
-      const notObj = (0, codegen_1$o._)`typeof ${data2} != "object"`;
-      cond = types2.null ? notObj : (0, codegen_1$o._)`!${data2} || ${notObj}`;
+      const notObj = (0, codegen_1$s._)`typeof ${data2} != "object"`;
+      cond = types2.null ? notObj : (0, codegen_1$s._)`!${data2} || ${notObj}`;
       delete types2.null;
       delete types2.array;
       delete types2.object;
     } else {
-      cond = codegen_1$o.nil;
+      cond = codegen_1$s.nil;
     }
     if (types2.number)
       delete types2.integer;
     for (const t in types2)
-      cond = (0, codegen_1$o.and)(cond, checkDataType$1(t, data2, strictNums, correct));
+      cond = (0, codegen_1$s.and)(cond, checkDataType$1(t, data2, strictNums, correct));
     return cond;
   }
   dataType.checkDataTypes = checkDataTypes$1;
   const typeError = {
     message: ({ schema }) => `must be ${schema}`,
-    params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1$o._)`{type: ${schema}}` : (0, codegen_1$o._)`{type: ${schemaValue}}`
+    params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1$s._)`{type: ${schema}}` : (0, codegen_1$s._)`{type: ${schemaValue}}`
   };
   function reportTypeError(it) {
     const cxt = getTypeErrorContext(it);
-    (0, errors_1.reportError)(cxt, typeError);
+    (0, errors_1$2.reportError)(cxt, typeError);
   }
   dataType.reportTypeError = reportTypeError;
   function getTypeErrorContext(it) {
     const { gen, data: data2, schema } = it;
-    const schemaCode = (0, util_1$n.schemaRefOrVal)(it, schema, "type");
+    const schemaCode = (0, util_1$q.schemaRefOrVal)(it, schema, "type");
     return {
       gen,
       keyword: "type",
@@ -1600,60 +1594,54 @@
     };
   }
   var defaults = {};
-  var hasRequiredDefaults;
-  function requireDefaults() {
-    if (hasRequiredDefaults) return defaults;
-    hasRequiredDefaults = 1;
-    Object.defineProperty(defaults, "__esModule", { value: true });
-    defaults.assignDefaults = void 0;
-    const codegen_12 = codegen;
-    const util_12 = util$7;
-    function assignDefaults(it, ty) {
-      const { properties: properties2, items: items2 } = it.schema;
-      if (ty === "object" && properties2) {
-        for (const key in properties2) {
-          assignDefault(it, key, properties2[key].default);
-        }
-      } else if (ty === "array" && Array.isArray(items2)) {
-        items2.forEach((sch, i) => assignDefault(it, i, sch.default));
-      }
+  Object.defineProperty(defaults, "__esModule", { value: true });
+  defaults.assignDefaults = void 0;
+  const codegen_1$r = codegen;
+  const util_1$p = util$7;
+  function assignDefaults(it, ty) {
+    const { properties: properties2, items: items2 } = it.schema;
+    if (ty === "object" && properties2) {
+      for (const key in properties2) {
+        assignDefault(it, key, properties2[key].default);
+      }
+    } else if (ty === "array" && Array.isArray(items2)) {
+      items2.forEach((sch, i) => assignDefault(it, i, sch.default));
+    }
+  }
+  defaults.assignDefaults = assignDefaults;
+  function assignDefault(it, prop, defaultValue) {
+    const { gen, compositeRule, data: data2, opts } = it;
+    if (defaultValue === void 0)
+      return;
+    const childData = (0, codegen_1$r._)`${data2}${(0, codegen_1$r.getProperty)(prop)}`;
+    if (compositeRule) {
+      (0, util_1$p.checkStrictMode)(it, `default is ignored for: ${childData}`);
+      return;
     }
-    defaults.assignDefaults = assignDefaults;
-    function assignDefault(it, prop, defaultValue) {
-      const { gen, compositeRule, data: data2, opts } = it;
-      if (defaultValue === void 0)
-        return;
-      const childData = (0, codegen_12._)`${data2}${(0, codegen_12.getProperty)(prop)}`;
-      if (compositeRule) {
-        (0, util_12.checkStrictMode)(it, `default is ignored for: ${childData}`);
-        return;
-      }
-      let condition = (0, codegen_12._)`${childData} === undefined`;
-      if (opts.useDefaults === "empty") {
-        condition = (0, codegen_12._)`${condition} || ${childData} === null || ${childData} === ""`;
-      }
-      gen.if(condition, (0, codegen_12._)`${childData} = ${(0, codegen_12.stringify)(defaultValue)}`);
+    let condition = (0, codegen_1$r._)`${childData} === undefined`;
+    if (opts.useDefaults === "empty") {
+      condition = (0, codegen_1$r._)`${condition} || ${childData} === null || ${childData} === ""`;
     }
-    return defaults;
+    gen.if(condition, (0, codegen_1$r._)`${childData} = ${(0, codegen_1$r.stringify)(defaultValue)}`);
   }
   var keyword$1 = {};
   var code = {};
   Object.defineProperty(code, "__esModule", { value: true });
   code.validateUnion = code.validateArray = code.usePattern = code.callValidateCode = code.schemaProperties = code.allSchemaProperties = code.noPropertyInData = code.propertyInData = code.isOwnProperty = code.hasPropFunc = code.reportMissingProp = code.checkMissingProp = code.checkReportMissingProp = void 0;
-  const codegen_1$n = codegen;
-  const util_1$m = util$7;
-  const names_1$3 = names$1;
+  const codegen_1$q = codegen;
+  const util_1$o = util$7;
+  const names_1$5 = names$1;
   const util_2$1 = util$7;
   function checkReportMissingProp(cxt, prop) {
     const { gen, data: data2, it } = cxt;
     gen.if(noPropertyInData(gen, data2, prop, it.opts.ownProperties), () => {
-      cxt.setParams({ missingProperty: (0, codegen_1$n._)`${prop}` }, true);
+      cxt.setParams({ missingProperty: (0, codegen_1$q._)`${prop}` }, true);
       cxt.error();
     });
   }
   code.checkReportMissingProp = checkReportMissingProp;
   function checkMissingProp({ gen, data: data2, it: { opts } }, properties2, missing) {
-    return (0, codegen_1$n.or)(...properties2.map((prop) => (0, codegen_1$n.and)(noPropertyInData(gen, data2, prop, opts.ownProperties), (0, codegen_1$n._)`${missing} = ${prop}`)));
+    return (0, codegen_1$q.or)(...properties2.map((prop) => (0, codegen_1$q.and)(noPropertyInData(gen, data2, prop, opts.ownProperties), (0, codegen_1$q._)`${missing} = ${prop}`)));
   }
   code.checkMissingProp = checkMissingProp;
   function reportMissingProp(cxt, missing) {
@@ -1665,22 +1653,22 @@
     return gen.scopeValue("func", {
       // eslint-disable-next-line @typescript-eslint/unbound-method
       ref: Object.prototype.hasOwnProperty,
-      code: (0, codegen_1$n._)`Object.prototype.hasOwnProperty`
+      code: (0, codegen_1$q._)`Object.prototype.hasOwnProperty`
     });
   }
   code.hasPropFunc = hasPropFunc;
   function isOwnProperty(gen, data2, property) {
-    return (0, codegen_1$n._)`${hasPropFunc(gen)}.call(${data2}, ${property})`;
+    return (0, codegen_1$q._)`${hasPropFunc(gen)}.call(${data2}, ${property})`;
   }
   code.isOwnProperty = isOwnProperty;
   function propertyInData(gen, data2, property, ownProperties) {
-    const cond = (0, codegen_1$n._)`${data2}${(0, codegen_1$n.getProperty)(property)} !== undefined`;
-    return ownProperties ? (0, codegen_1$n._)`${cond} && ${isOwnProperty(gen, data2, property)}` : cond;
+    const cond = (0, codegen_1$q._)`${data2}${(0, codegen_1$q.getProperty)(property)} !== undefined`;
+    return ownProperties ? (0, codegen_1$q._)`${cond} && ${isOwnProperty(gen, data2, property)}` : cond;
   }
   code.propertyInData = propertyInData;
   function noPropertyInData(gen, data2, property, ownProperties) {
-    const cond = (0, codegen_1$n._)`${data2}${(0, codegen_1$n.getProperty)(property)} === undefined`;
-    return ownProperties ? (0, codegen_1$n.or)(cond, (0, codegen_1$n.not)(isOwnProperty(gen, data2, property))) : cond;
+    const cond = (0, codegen_1$q._)`${data2}${(0, codegen_1$q.getProperty)(property)} === undefined`;
+    return ownProperties ? (0, codegen_1$q.or)(cond, (0, codegen_1$q.not)(isOwnProperty(gen, data2, property))) : cond;
   }
   code.noPropertyInData = noPropertyInData;
   function allSchemaProperties(schemaMap) {
@@ -1688,24 +1676,24 @@
   }
   code.allSchemaProperties = allSchemaProperties;
   function schemaProperties(it, schemaMap) {
-    return allSchemaProperties(schemaMap).filter((p) => !(0, util_1$m.alwaysValidSchema)(it, schemaMap[p]));
+    return allSchemaProperties(schemaMap).filter((p) => !(0, util_1$o.alwaysValidSchema)(it, schemaMap[p]));
   }
   code.schemaProperties = schemaProperties;
   function callValidateCode({ schemaCode, data: data2, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
-    const dataAndSchema = passSchema ? (0, codegen_1$n._)`${schemaCode}, ${data2}, ${topSchemaRef}${schemaPath}` : data2;
+    const dataAndSchema = passSchema ? (0, codegen_1$q._)`${schemaCode}, ${data2}, ${topSchemaRef}${schemaPath}` : data2;
     const valCxt = [
-      [names_1$3.default.instancePath, (0, codegen_1$n.strConcat)(names_1$3.default.instancePath, errorPath)],
-      [names_1$3.default.parentData, it.parentData],
-      [names_1$3.default.parentDataProperty, it.parentDataProperty],
-      [names_1$3.default.rootData, names_1$3.default.rootData]
+      [names_1$5.default.instancePath, (0, codegen_1$q.strConcat)(names_1$5.default.instancePath, errorPath)],
+      [names_1$5.default.parentData, it.parentData],
+      [names_1$5.default.parentDataProperty, it.parentDataProperty],
+      [names_1$5.default.rootData, names_1$5.default.rootData]
     ];
     if (it.opts.dynamicRef)
-      valCxt.push([names_1$3.default.dynamicAnchors, names_1$3.default.dynamicAnchors]);
-    const args = (0, codegen_1$n._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
-    return context !== codegen_1$n.nil ? (0, codegen_1$n._)`${func}.call(${context}, ${args})` : (0, codegen_1$n._)`${func}(${args})`;
+      valCxt.push([names_1$5.default.dynamicAnchors, names_1$5.default.dynamicAnchors]);
+    const args = (0, codegen_1$q._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
+    return context !== codegen_1$q.nil ? (0, codegen_1$q._)`${func}.call(${context}, ${args})` : (0, codegen_1$q._)`${func}(${args})`;
   }
   code.callValidateCode = callValidateCode;
-  const newRegExp = (0, codegen_1$n._)`new RegExp`;
+  const newRegExp = (0, codegen_1$q._)`new RegExp`;
   function usePattern({ gen, it: { opts } }, pattern2) {
     const u = opts.unicodeRegExp ? "u" : "";
     const { regExp } = opts.code;
@@ -1713,7 +1701,7 @@
     return gen.scopeValue("pattern", {
       key: rx.toString(),
       ref: rx,
-      code: (0, codegen_1$n._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2$1.useFunc)(gen, regExp)}(${pattern2}, ${u})`
+      code: (0, codegen_1$q._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2$1.useFunc)(gen, regExp)}(${pattern2}, ${u})`
     });
   }
   code.usePattern = usePattern;
@@ -1729,14 +1717,14 @@
     validateItems(() => gen.break());
     return valid;
     function validateItems(notValid) {
-      const len = gen.const("len", (0, codegen_1$n._)`${data2}.length`);
+      const len = gen.const("len", (0, codegen_1$q._)`${data2}.length`);
       gen.forRange("i", 0, len, (i) => {
         cxt.subschema({
           keyword: keyword2,
           dataProp: i,
-          dataPropType: util_1$m.Type.Num
+          dataPropType: util_1$o.Type.Num
         }, valid);
-        gen.if((0, codegen_1$n.not)(valid), notValid);
+        gen.if((0, codegen_1$q.not)(valid), notValid);
       });
     }
   }
@@ -1745,7 +1733,7 @@
     const { gen, schema, keyword: keyword2, it } = cxt;
     if (!Array.isArray(schema))
       throw new Error("ajv implementation error");
-    const alwaysValid = schema.some((sch) => (0, util_1$m.alwaysValidSchema)(it, sch));
+    const alwaysValid = schema.some((sch) => (0, util_1$o.alwaysValidSchema)(it, sch));
     if (alwaysValid && !it.opts.unevaluated)
       return;
     const valid = gen.let("valid", false);
@@ -1756,214 +1744,202 @@
         schemaProp: i,
         compositeRule: true
       }, schValid);
-      gen.assign(valid, (0, codegen_1$n._)`${valid} || ${schValid}`);
+      gen.assign(valid, (0, codegen_1$q._)`${valid} || ${schValid}`);
       const merged = cxt.mergeValidEvaluated(schCxt, schValid);
       if (!merged)
-        gen.if((0, codegen_1$n.not)(valid));
+        gen.if((0, codegen_1$q.not)(valid));
     }));
     cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
   }
   code.validateUnion = validateUnion;
-  var hasRequiredKeyword;
-  function requireKeyword() {
-    if (hasRequiredKeyword) return keyword$1;
-    hasRequiredKeyword = 1;
-    Object.defineProperty(keyword$1, "__esModule", { value: true });
-    keyword$1.validateKeywordUsage = keyword$1.validSchemaType = keyword$1.funcKeywordCode = keyword$1.macroKeywordCode = void 0;
-    const codegen_12 = codegen;
-    const names_12 = names$1;
-    const code_12 = code;
-    const errors_12 = errors;
-    function macroKeywordCode(cxt, def2) {
-      const { gen, keyword: keyword2, schema, parentSchema, it } = cxt;
-      const macroSchema = def2.macro.call(it.self, schema, parentSchema, it);
-      const schemaRef = useKeyword(gen, keyword2, macroSchema);
-      if (it.opts.validateSchema !== false)
-        it.self.validateSchema(macroSchema, true);
-      const valid = gen.name("valid");
-      cxt.subschema({
-        schema: macroSchema,
-        schemaPath: codegen_12.nil,
-        errSchemaPath: `${it.errSchemaPath}/${keyword2}`,
-        topSchemaRef: schemaRef,
-        compositeRule: true
-      }, valid);
-      cxt.pass(valid, () => cxt.error(true));
-    }
-    keyword$1.macroKeywordCode = macroKeywordCode;
-    function funcKeywordCode(cxt, def2) {
-      var _a;
-      const { gen, keyword: keyword2, schema, parentSchema, $data, it } = cxt;
-      checkAsyncKeyword(it, def2);
-      const validate2 = !$data && def2.compile ? def2.compile.call(it.self, schema, parentSchema, it) : def2.validate;
-      const validateRef = useKeyword(gen, keyword2, validate2);
-      const valid = gen.let("valid");
-      cxt.block$data(valid, validateKeyword2);
-      cxt.ok((_a = def2.valid) !== null && _a !== void 0 ? _a : valid);
-      function validateKeyword2() {
-        if (def2.errors === false) {
-          assignValid();
-          if (def2.modifying)
-            modifyData(cxt);
-          reportErrs(() => cxt.error());
-        } else {
-          const ruleErrs = def2.async ? validateAsync() : validateSync();
-          if (def2.modifying)
-            modifyData(cxt);
-          reportErrs(() => addErrs(cxt, ruleErrs));
-        }
-      }
-      function validateAsync() {
-        const ruleErrs = gen.let("ruleErrs", null);
-        gen.try(() => assignValid((0, codegen_12._)`await `), (e) => gen.assign(valid, false).if((0, codegen_12._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_12._)`${e}.errors`), () => gen.throw(e)));
-        return ruleErrs;
-      }
-      function validateSync() {
-        const validateErrs = (0, codegen_12._)`${validateRef}.errors`;
-        gen.assign(validateErrs, null);
-        assignValid(codegen_12.nil);
-        return validateErrs;
-      }
-      function assignValid(_await = def2.async ? (0, codegen_12._)`await ` : codegen_12.nil) {
-        const passCxt = it.opts.passContext ? names_12.default.this : names_12.default.self;
-        const passSchema = !("compile" in def2 && !$data || def2.schema === false);
-        gen.assign(valid, (0, codegen_12._)`${_await}${(0, code_12.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def2.modifying);
-      }
-      function reportErrs(errors2) {
-        var _a2;
-        gen.if((0, codegen_12.not)((_a2 = def2.valid) !== null && _a2 !== void 0 ? _a2 : valid), errors2);
+  Object.defineProperty(keyword$1, "__esModule", { value: true });
+  keyword$1.validateKeywordUsage = keyword$1.validSchemaType = keyword$1.funcKeywordCode = keyword$1.macroKeywordCode = void 0;
+  const codegen_1$p = codegen;
+  const names_1$4 = names$1;
+  const code_1$9 = code;
+  const errors_1$1 = errors;
+  function macroKeywordCode(cxt, def2) {
+    const { gen, keyword: keyword2, schema, parentSchema, it } = cxt;
+    const macroSchema = def2.macro.call(it.self, schema, parentSchema, it);
+    const schemaRef = useKeyword(gen, keyword2, macroSchema);
+    if (it.opts.validateSchema !== false)
+      it.self.validateSchema(macroSchema, true);
+    const valid = gen.name("valid");
+    cxt.subschema({
+      schema: macroSchema,
+      schemaPath: codegen_1$p.nil,
+      errSchemaPath: `${it.errSchemaPath}/${keyword2}`,
+      topSchemaRef: schemaRef,
+      compositeRule: true
+    }, valid);
+    cxt.pass(valid, () => cxt.error(true));
+  }
+  keyword$1.macroKeywordCode = macroKeywordCode;
+  function funcKeywordCode(cxt, def2) {
+    var _a;
+    const { gen, keyword: keyword2, schema, parentSchema, $data, it } = cxt;
+    checkAsyncKeyword(it, def2);
+    const validate2 = !$data && def2.compile ? def2.compile.call(it.self, schema, parentSchema, it) : def2.validate;
+    const validateRef = useKeyword(gen, keyword2, validate2);
+    const valid = gen.let("valid");
+    cxt.block$data(valid, validateKeyword2);
+    cxt.ok((_a = def2.valid) !== null && _a !== void 0 ? _a : valid);
+    function validateKeyword2() {
+      if (def2.errors === false) {
+        assignValid();
+        if (def2.modifying)
+          modifyData(cxt);
+        reportErrs(() => cxt.error());
+      } else {
+        const ruleErrs = def2.async ? validateAsync() : validateSync();
+        if (def2.modifying)
+          modifyData(cxt);
+        reportErrs(() => addErrs(cxt, ruleErrs));
       }
     }
-    keyword$1.funcKeywordCode = funcKeywordCode;
-    function modifyData(cxt) {
-      const { gen, data: data2, it } = cxt;
-      gen.if(it.parentData, () => gen.assign(data2, (0, codegen_12._)`${it.parentData}[${it.parentDataProperty}]`));
-    }
-    function addErrs(cxt, errs) {
-      const { gen } = cxt;
-      gen.if((0, codegen_12._)`Array.isArray(${errs})`, () => {
-        gen.assign(names_12.default.vErrors, (0, codegen_12._)`${names_12.default.vErrors} === null ? ${errs} : ${names_12.default.vErrors}.concat(${errs})`).assign(names_12.default.errors, (0, codegen_12._)`${names_12.default.vErrors}.length`);
-        (0, errors_12.extendErrors)(cxt);
-      }, () => cxt.error());
-    }
-    function checkAsyncKeyword({ schemaEnv }, def2) {
-      if (def2.async && !schemaEnv.$async)
-        throw new Error("async keyword in sync schema");
-    }
-    function useKeyword(gen, keyword2, result) {
-      if (result === void 0)
-        throw new Error(`keyword "${keyword2}" failed to compile`);
-      return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_12.stringify)(result) });
-    }
-    function validSchemaType(schema, schemaType, allowUndefined = false) {
-      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");
-    }
-    keyword$1.validSchemaType = validSchemaType;
-    function validateKeywordUsage({ schema, opts, self: self2, errSchemaPath }, def2, keyword2) {
-      if (Array.isArray(def2.keyword) ? !def2.keyword.includes(keyword2) : def2.keyword !== keyword2) {
-        throw new Error("ajv implementation error");
-      }
-      const deps = def2.dependencies;
-      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 ${keyword2}: ${deps.join(",")}`);
-      }
-      if (def2.validateSchema) {
-        const valid = def2.validateSchema(schema[keyword2]);
-        if (!valid) {
-          const msg = `keyword "${keyword2}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def2.validateSchema.errors);
-          if (opts.validateSchema === "log")
-            self2.logger.error(msg);
-          else
-            throw new Error(msg);
-        }
+    function validateAsync() {
+      const ruleErrs = gen.let("ruleErrs", null);
+      gen.try(() => assignValid((0, codegen_1$p._)`await `), (e) => gen.assign(valid, false).if((0, codegen_1$p._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1$p._)`${e}.errors`), () => gen.throw(e)));
+      return ruleErrs;
+    }
+    function validateSync() {
+      const validateErrs = (0, codegen_1$p._)`${validateRef}.errors`;
+      gen.assign(validateErrs, null);
+      assignValid(codegen_1$p.nil);
+      return validateErrs;
+    }
+    function assignValid(_await = def2.async ? (0, codegen_1$p._)`await ` : codegen_1$p.nil) {
+      const passCxt = it.opts.passContext ? names_1$4.default.this : names_1$4.default.self;
+      const passSchema = !("compile" in def2 && !$data || def2.schema === false);
+      gen.assign(valid, (0, codegen_1$p._)`${_await}${(0, code_1$9.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def2.modifying);
+    }
+    function reportErrs(errors2) {
+      var _a2;
+      gen.if((0, codegen_1$p.not)((_a2 = def2.valid) !== null && _a2 !== void 0 ? _a2 : valid), errors2);
+    }
+  }
+  keyword$1.funcKeywordCode = funcKeywordCode;
+  function modifyData(cxt) {
+    const { gen, data: data2, it } = cxt;
+    gen.if(it.parentData, () => gen.assign(data2, (0, codegen_1$p._)`${it.parentData}[${it.parentDataProperty}]`));
+  }
+  function addErrs(cxt, errs) {
+    const { gen } = cxt;
+    gen.if((0, codegen_1$p._)`Array.isArray(${errs})`, () => {
+      gen.assign(names_1$4.default.vErrors, (0, codegen_1$p._)`${names_1$4.default.vErrors} === null ? ${errs} : ${names_1$4.default.vErrors}.concat(${errs})`).assign(names_1$4.default.errors, (0, codegen_1$p._)`${names_1$4.default.vErrors}.length`);
+      (0, errors_1$1.extendErrors)(cxt);
+    }, () => cxt.error());
+  }
+  function checkAsyncKeyword({ schemaEnv }, def2) {
+    if (def2.async && !schemaEnv.$async)
+      throw new Error("async keyword in sync schema");
+  }
+  function useKeyword(gen, keyword2, result) {
+    if (result === void 0)
+      throw new Error(`keyword "${keyword2}" failed to compile`);
+    return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1$p.stringify)(result) });
+  }
+  function validSchemaType(schema, schemaType, allowUndefined = false) {
+    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");
+  }
+  keyword$1.validSchemaType = validSchemaType;
+  function validateKeywordUsage({ schema, opts, self: self2, errSchemaPath }, def2, keyword2) {
+    if (Array.isArray(def2.keyword) ? !def2.keyword.includes(keyword2) : def2.keyword !== keyword2) {
+      throw new Error("ajv implementation error");
+    }
+    const deps = def2.dependencies;
+    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 ${keyword2}: ${deps.join(",")}`);
+    }
+    if (def2.validateSchema) {
+      const valid = def2.validateSchema(schema[keyword2]);
+      if (!valid) {
+        const msg = `keyword "${keyword2}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def2.validateSchema.errors);
+        if (opts.validateSchema === "log")
+          self2.logger.error(msg);
+        else
+          throw new Error(msg);
       }
     }
-    keyword$1.validateKeywordUsage = validateKeywordUsage;
-    return keyword$1;
   }
+  keyword$1.validateKeywordUsage = validateKeywordUsage;
   var subschema = {};
-  var hasRequiredSubschema;
-  function requireSubschema() {
-    if (hasRequiredSubschema) return subschema;
-    hasRequiredSubschema = 1;
-    Object.defineProperty(subschema, "__esModule", { value: true });
-    subschema.extendSubschemaMode = subschema.extendSubschemaData = subschema.getSubschema = void 0;
-    const codegen_12 = codegen;
-    const util_12 = util$7;
-    function getSubschema(it, { keyword: keyword2, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
-      if (keyword2 !== void 0 && schema !== void 0) {
-        throw new Error('both "keyword" and "schema" passed, only one allowed');
-      }
-      if (keyword2 !== void 0) {
-        const sch = it.schema[keyword2];
-        return schemaProp === void 0 ? {
-          schema: sch,
-          schemaPath: (0, codegen_12._)`${it.schemaPath}${(0, codegen_12.getProperty)(keyword2)}`,
-          errSchemaPath: `${it.errSchemaPath}/${keyword2}`
-        } : {
-          schema: sch[schemaProp],
-          schemaPath: (0, codegen_12._)`${it.schemaPath}${(0, codegen_12.getProperty)(keyword2)}${(0, codegen_12.getProperty)(schemaProp)}`,
-          errSchemaPath: `${it.errSchemaPath}/${keyword2}/${(0, util_12.escapeFragment)(schemaProp)}`
-        };
-      }
-      if (schema !== void 0) {
-        if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) {
-          throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
-        }
-        return {
-          schema,
-          schemaPath,
-          topSchemaRef,
-          errSchemaPath
-        };
+  Object.defineProperty(subschema, "__esModule", { value: true });
+  subschema.extendSubschemaMode = subschema.extendSubschemaData = subschema.getSubschema = void 0;
+  const codegen_1$o = codegen;
+  const util_1$n = util$7;
+  function getSubschema(it, { keyword: keyword2, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
+    if (keyword2 !== void 0 && schema !== void 0) {
+      throw new Error('both "keyword" and "schema" passed, only one allowed');
+    }
+    if (keyword2 !== void 0) {
+      const sch = it.schema[keyword2];
+      return schemaProp === void 0 ? {
+        schema: sch,
+        schemaPath: (0, codegen_1$o._)`${it.schemaPath}${(0, codegen_1$o.getProperty)(keyword2)}`,
+        errSchemaPath: `${it.errSchemaPath}/${keyword2}`
+      } : {
+        schema: sch[schemaProp],
+        schemaPath: (0, codegen_1$o._)`${it.schemaPath}${(0, codegen_1$o.getProperty)(keyword2)}${(0, codegen_1$o.getProperty)(schemaProp)}`,
+        errSchemaPath: `${it.errSchemaPath}/${keyword2}/${(0, util_1$n.escapeFragment)(schemaProp)}`
+      };
+    }
+    if (schema !== void 0) {
+      if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) {
+        throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
       }
-      throw new Error('either "keyword" or "schema" must be passed');
-    }
-    subschema.getSubschema = getSubschema;
-    function extendSubschemaData(subschema2, it, { dataProp, dataPropType: dpType, data: data2, dataTypes, propertyName }) {
-      if (data2 !== void 0 && dataProp !== void 0) {
-        throw new Error('both "data" and "dataProp" passed, only one allowed');
-      }
-      const { gen } = it;
-      if (dataProp !== void 0) {
-        const { errorPath, dataPathArr, opts } = it;
-        const nextData = gen.let("data", (0, codegen_12._)`${it.data}${(0, codegen_12.getProperty)(dataProp)}`, true);
-        dataContextProps(nextData);
-        subschema2.errorPath = (0, codegen_12.str)`${errorPath}${(0, util_12.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
-        subschema2.parentDataProperty = (0, codegen_12._)`${dataProp}`;
-        subschema2.dataPathArr = [...dataPathArr, subschema2.parentDataProperty];
-      }
-      if (data2 !== void 0) {
-        const nextData = data2 instanceof codegen_12.Name ? data2 : gen.let("data", data2, true);
-        dataContextProps(nextData);
-        if (propertyName !== void 0)
-          subschema2.propertyName = propertyName;
-      }
-      if (dataTypes)
-        subschema2.dataTypes = dataTypes;
-      function dataContextProps(_nextData) {
-        subschema2.data = _nextData;
-        subschema2.dataLevel = it.dataLevel + 1;
-        subschema2.dataTypes = [];
-        it.definedProperties = /* @__PURE__ */ new Set();
-        subschema2.parentData = it.data;
-        subschema2.dataNames = [...it.dataNames, _nextData];
-      }
-    }
-    subschema.extendSubschemaData = extendSubschemaData;
-    function extendSubschemaMode(subschema2, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
-      if (compositeRule !== void 0)
-        subschema2.compositeRule = compositeRule;
-      if (createErrors !== void 0)
-        subschema2.createErrors = createErrors;
-      if (allErrors !== void 0)
-        subschema2.allErrors = allErrors;
-      subschema2.jtdDiscriminator = jtdDiscriminator;
-      subschema2.jtdMetadata = jtdMetadata;
-    }
-    subschema.extendSubschemaMode = extendSubschemaMode;
-    return subschema;
-  }
+      return {
+        schema,
+        schemaPath,
+        topSchemaRef,
+        errSchemaPath
+      };
+    }
+    throw new Error('either "keyword" or "schema" must be passed');
+  }
+  subschema.getSubschema = getSubschema;
+  function extendSubschemaData(subschema2, it, { dataProp, dataPropType: dpType, data: data2, dataTypes, propertyName }) {
+    if (data2 !== void 0 && dataProp !== void 0) {
+      throw new Error('both "data" and "dataProp" passed, only one allowed');
+    }
+    const { gen } = it;
+    if (dataProp !== void 0) {
+      const { errorPath, dataPathArr, opts } = it;
+      const nextData = gen.let("data", (0, codegen_1$o._)`${it.data}${(0, codegen_1$o.getProperty)(dataProp)}`, true);
+      dataContextProps(nextData);
+      subschema2.errorPath = (0, codegen_1$o.str)`${errorPath}${(0, util_1$n.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
+      subschema2.parentDataProperty = (0, codegen_1$o._)`${dataProp}`;
+      subschema2.dataPathArr = [...dataPathArr, subschema2.parentDataProperty];
+    }
+    if (data2 !== void 0) {
+      const nextData = data2 instanceof codegen_1$o.Name ? data2 : gen.let("data", data2, true);
+      dataContextProps(nextData);
+      if (propertyName !== void 0)
+        subschema2.propertyName = propertyName;
+    }
+    if (dataTypes)
+      subschema2.dataTypes = dataTypes;
+    function dataContextProps(_nextData) {
+      subschema2.data = _nextData;
+      subschema2.dataLevel = it.dataLevel + 1;
+      subschema2.dataTypes = [];
+      it.definedProperties = /* @__PURE__ */ new Set();
+      subschema2.parentData = it.data;
+      subschema2.dataNames = [...it.dataNames, _nextData];
+    }
+  }
+  subschema.extendSubschemaData = extendSubschemaData;
+  function extendSubschemaMode(subschema2, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
+    if (compositeRule !== void 0)
+      subschema2.compositeRule = compositeRule;
+    if (createErrors !== void 0)
+      subschema2.createErrors = createErrors;
+    if (allErrors !== void 0)
+      subschema2.allErrors = allErrors;
+    subschema2.jtdDiscriminator = jtdDiscriminator;
+    subschema2.jtdMetadata = jtdMetadata;
+  }
+  subschema.extendSubschemaMode = extendSubschemaMode;
   var resolve$6 = {};
   var fastDeepEqual = function equal2(a, b) {
     if (a === b) return true;
@@ -2078,7 +2054,7 @@
   var jsonSchemaTraverseExports$1 = jsonSchemaTraverse$1.exports;
   Object.defineProperty(resolve$6, "__esModule", { value: true });
   resolve$6.getSchemaRefs = resolve$6.resolveUrl = resolve$6.normalizeId = resolve$6._getFullPath = resolve$6.getFullPath = resolve$6.inlineRef = void 0;
-  const util_1$l = util$7;
+  const util_1$m = util$7;
   const equal$5 = fastDeepEqual;
   const traverse$2 = jsonSchemaTraverseExports$1;
   const SIMPLE_INLINED$1 = /* @__PURE__ */ new Set([
@@ -2137,7 +2113,7 @@
       if (SIMPLE_INLINED$1.has(key))
         continue;
       if (typeof schema[key] == "object") {
-        (0, util_1$l.eachItem)(schema[key], (sch) => count += countKeys$1(sch));
+        (0, util_1$m.eachItem)(schema[key], (sch) => count += countKeys$1(sch));
       }
       if (count === Infinity)
         return Infinity;
@@ -2225,528 +2201,516 @@
     }
   }
   resolve$6.getSchemaRefs = getSchemaRefs;
-  var hasRequiredValidate;
-  function requireValidate() {
-    if (hasRequiredValidate) return validate$2;
-    hasRequiredValidate = 1;
-    Object.defineProperty(validate$2, "__esModule", { value: true });
-    validate$2.getData = validate$2.KeywordCxt = validate$2.validateFunctionCode = void 0;
-    const boolSchema_1 = requireBoolSchema();
-    const dataType_12 = dataType;
-    const applicability_12 = applicability;
-    const dataType_2 = dataType;
-    const defaults_1 = requireDefaults();
-    const keyword_1 = requireKeyword();
-    const subschema_1 = requireSubschema();
-    const codegen_12 = codegen;
-    const names_12 = names$1;
-    const resolve_12 = resolve$6;
-    const util_12 = util$7;
-    const errors_12 = errors;
-    function validateFunctionCode(it) {
-      if (isSchemaObj(it)) {
-        checkKeywords(it);
-        if (schemaCxtHasRules(it)) {
-          topSchemaObjCode(it);
-          return;
-        }
+  Object.defineProperty(validate$2, "__esModule", { value: true });
+  validate$2.getData = validate$2.KeywordCxt = validate$2.validateFunctionCode = void 0;
+  const boolSchema_1 = boolSchema;
+  const dataType_1$1 = dataType;
+  const applicability_1 = applicability;
+  const dataType_2 = dataType;
+  const defaults_1 = defaults;
+  const keyword_1 = keyword$1;
+  const subschema_1 = subschema;
+  const codegen_1$n = codegen;
+  const names_1$3 = names$1;
+  const resolve_1$3 = resolve$6;
+  const util_1$l = util$7;
+  const errors_1 = errors;
+  function validateFunctionCode(it) {
+    if (isSchemaObj(it)) {
+      checkKeywords(it);
+      if (schemaCxtHasRules(it)) {
+        topSchemaObjCode(it);
+        return;
       }
-      validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
-    }
-    validate$2.validateFunctionCode = validateFunctionCode;
-    function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
-      if (opts.code.es5) {
-        gen.func(validateName, (0, codegen_12._)`${names_12.default.data}, ${names_12.default.valCxt}`, schemaEnv.$async, () => {
-          gen.code((0, codegen_12._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
-          destructureValCxtES5(gen, opts);
-          gen.code(body);
-        });
-      } else {
-        gen.func(validateName, (0, codegen_12._)`${names_12.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
-      }
-    }
-    function destructureValCxt(opts) {
-      return (0, codegen_12._)`{${names_12.default.instancePath}="", ${names_12.default.parentData}, ${names_12.default.parentDataProperty}, ${names_12.default.rootData}=${names_12.default.data}${opts.dynamicRef ? (0, codegen_12._)`, ${names_12.default.dynamicAnchors}={}` : codegen_12.nil}}={}`;
-    }
-    function destructureValCxtES5(gen, opts) {
-      gen.if(names_12.default.valCxt, () => {
-        gen.var(names_12.default.instancePath, (0, codegen_12._)`${names_12.default.valCxt}.${names_12.default.instancePath}`);
-        gen.var(names_12.default.parentData, (0, codegen_12._)`${names_12.default.valCxt}.${names_12.default.parentData}`);
-        gen.var(names_12.default.parentDataProperty, (0, codegen_12._)`${names_12.default.valCxt}.${names_12.default.parentDataProperty}`);
-        gen.var(names_12.default.rootData, (0, codegen_12._)`${names_12.default.valCxt}.${names_12.default.rootData}`);
-        if (opts.dynamicRef)
-          gen.var(names_12.default.dynamicAnchors, (0, codegen_12._)`${names_12.default.valCxt}.${names_12.default.dynamicAnchors}`);
-      }, () => {
-        gen.var(names_12.default.instancePath, (0, codegen_12._)`""`);
-        gen.var(names_12.default.parentData, (0, codegen_12._)`undefined`);
-        gen.var(names_12.default.parentDataProperty, (0, codegen_12._)`undefined`);
-        gen.var(names_12.default.rootData, names_12.default.data);
-        if (opts.dynamicRef)
-          gen.var(names_12.default.dynamicAnchors, (0, codegen_12._)`{}`);
-      });
     }
-    function topSchemaObjCode(it) {
-      const { schema, opts, gen } = it;
-      validateFunction(it, () => {
-        if (opts.$comment && schema.$comment)
-          commentKeyword(it);
-        checkNoDefault(it);
-        gen.let(names_12.default.vErrors, null);
-        gen.let(names_12.default.errors, 0);
-        if (opts.unevaluated)
-          resetEvaluated(it);
-        typeAndKeywords(it);
-        returnResults(it);
+    validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
+  }
+  validate$2.validateFunctionCode = validateFunctionCode;
+  function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
+    if (opts.code.es5) {
+      gen.func(validateName, (0, codegen_1$n._)`${names_1$3.default.data}, ${names_1$3.default.valCxt}`, schemaEnv.$async, () => {
+        gen.code((0, codegen_1$n._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
+        destructureValCxtES5(gen, opts);
+        gen.code(body);
       });
-      return;
-    }
-    function resetEvaluated(it) {
-      const { gen, validateName } = it;
-      it.evaluated = gen.const("evaluated", (0, codegen_12._)`${validateName}.evaluated`);
-      gen.if((0, codegen_12._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_12._)`${it.evaluated}.props`, (0, codegen_12._)`undefined`));
-      gen.if((0, codegen_12._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_12._)`${it.evaluated}.items`, (0, codegen_12._)`undefined`));
-    }
-    function funcSourceUrl(schema, opts) {
-      const schId = typeof schema == "object" && schema[opts.schemaId];
-      return schId && (opts.code.source || opts.code.process) ? (0, codegen_12._)`/*# sourceURL=${schId} */` : codegen_12.nil;
-    }
-    function subschemaCode(it, valid) {
-      if (isSchemaObj(it)) {
-        checkKeywords(it);
-        if (schemaCxtHasRules(it)) {
-          subSchemaObjCode(it, valid);
-          return;
-        }
-      }
-      (0, boolSchema_1.boolOrEmptySchema)(it, valid);
-    }
-    function schemaCxtHasRules({ schema, self: self2 }) {
-      if (typeof schema == "boolean")
-        return !schema;
-      for (const key in schema)
-        if (self2.RULES.all[key])
-          return true;
-      return false;
-    }
-    function isSchemaObj(it) {
-      return typeof it.schema != "boolean";
-    }
-    function subSchemaObjCode(it, valid) {
-      const { schema, gen, opts } = it;
+    } else {
+      gen.func(validateName, (0, codegen_1$n._)`${names_1$3.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
+    }
+  }
+  function destructureValCxt(opts) {
+    return (0, codegen_1$n._)`{${names_1$3.default.instancePath}="", ${names_1$3.default.parentData}, ${names_1$3.default.parentDataProperty}, ${names_1$3.default.rootData}=${names_1$3.default.data}${opts.dynamicRef ? (0, codegen_1$n._)`, ${names_1$3.default.dynamicAnchors}={}` : codegen_1$n.nil}}={}`;
+  }
+  function destructureValCxtES5(gen, opts) {
+    gen.if(names_1$3.default.valCxt, () => {
+      gen.var(names_1$3.default.instancePath, (0, codegen_1$n._)`${names_1$3.default.valCxt}.${names_1$3.default.instancePath}`);
+      gen.var(names_1$3.default.parentData, (0, codegen_1$n._)`${names_1$3.default.valCxt}.${names_1$3.default.parentData}`);
+      gen.var(names_1$3.default.parentDataProperty, (0, codegen_1$n._)`${names_1$3.default.valCxt}.${names_1$3.default.parentDataProperty}`);
+      gen.var(names_1$3.default.rootData, (0, codegen_1$n._)`${names_1$3.default.valCxt}.${names_1$3.default.rootData}`);
+      if (opts.dynamicRef)
+        gen.var(names_1$3.default.dynamicAnchors, (0, codegen_1$n._)`${names_1$3.default.valCxt}.${names_1$3.default.dynamicAnchors}`);
+    }, () => {
+      gen.var(names_1$3.default.instancePath, (0, codegen_1$n._)`""`);
+      gen.var(names_1$3.default.parentData, (0, codegen_1$n._)`undefined`);
+      gen.var(names_1$3.default.parentDataProperty, (0, codegen_1$n._)`undefined`);
+      gen.var(names_1$3.default.rootData, names_1$3.default.data);
+      if (opts.dynamicRef)
+        gen.var(names_1$3.default.dynamicAnchors, (0, codegen_1$n._)`{}`);
+    });
+  }
+  function topSchemaObjCode(it) {
+    const { schema, opts, gen } = it;
+    validateFunction(it, () => {
       if (opts.$comment && schema.$comment)
         commentKeyword(it);
-      updateContext(it);
-      checkAsyncSchema(it);
-      const errsCount = gen.const("_errs", names_12.default.errors);
-      typeAndKeywords(it, errsCount);
-      gen.var(valid, (0, codegen_12._)`${errsCount} === ${names_12.default.errors}`);
-    }
-    function checkKeywords(it) {
-      (0, util_12.checkUnknownRules)(it);
-      checkRefsAndKeywords(it);
-    }
-    function typeAndKeywords(it, errsCount) {
-      if (it.opts.jtd)
-        return schemaKeywords(it, [], false, errsCount);
-      const types2 = (0, dataType_12.getSchemaTypes)(it.schema);
-      const checkedTypes = (0, dataType_12.coerceAndCheckDataType)(it, types2);
-      schemaKeywords(it, types2, !checkedTypes, errsCount);
-    }
-    function checkRefsAndKeywords(it) {
-      const { schema, errSchemaPath, opts, self: self2 } = it;
-      if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_12.schemaHasRulesButRef)(schema, self2.RULES)) {
-        self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
-      }
-    }
-    function checkNoDefault(it) {
-      const { schema, opts } = it;
-      if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) {
-        (0, util_12.checkStrictMode)(it, "default is ignored in the schema root");
+      checkNoDefault(it);
+      gen.let(names_1$3.default.vErrors, null);
+      gen.let(names_1$3.default.errors, 0);
+      if (opts.unevaluated)
+        resetEvaluated(it);
+      typeAndKeywords(it);
+      returnResults(it);
+    });
+    return;
+  }
+  function resetEvaluated(it) {
+    const { gen, validateName } = it;
+    it.evaluated = gen.const("evaluated", (0, codegen_1$n._)`${validateName}.evaluated`);
+    gen.if((0, codegen_1$n._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1$n._)`${it.evaluated}.props`, (0, codegen_1$n._)`undefined`));
+    gen.if((0, codegen_1$n._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1$n._)`${it.evaluated}.items`, (0, codegen_1$n._)`undefined`));
+  }
+  function funcSourceUrl(schema, opts) {
+    const schId = typeof schema == "object" && schema[opts.schemaId];
+    return schId && (opts.code.source || opts.code.process) ? (0, codegen_1$n._)`/*# sourceURL=${schId} */` : codegen_1$n.nil;
+  }
+  function subschemaCode(it, valid) {
+    if (isSchemaObj(it)) {
+      checkKeywords(it);
+      if (schemaCxtHasRules(it)) {
+        subSchemaObjCode(it, valid);
+        return;
       }
     }
-    function updateContext(it) {
-      const schId = it.schema[it.opts.schemaId];
-      if (schId)
-        it.baseId = (0, resolve_12.resolveUrl)(it.opts.uriResolver, it.baseId, schId);
-    }
-    function checkAsyncSchema(it) {
-      if (it.schema.$async && !it.schemaEnv.$async)
-        throw new Error("async schema in sync schema");
-    }
-    function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
-      const msg = schema.$comment;
-      if (opts.$comment === true) {
-        gen.code((0, codegen_12._)`${names_12.default.self}.logger.log(${msg})`);
-      } else if (typeof opts.$comment == "function") {
-        const schemaPath = (0, codegen_12.str)`${errSchemaPath}/$comment`;
-        const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
-        gen.code((0, codegen_12._)`${names_12.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
-      }
+    (0, boolSchema_1.boolOrEmptySchema)(it, valid);
+  }
+  function schemaCxtHasRules({ schema, self: self2 }) {
+    if (typeof schema == "boolean")
+      return !schema;
+    for (const key in schema)
+      if (self2.RULES.all[key])
+        return true;
+    return false;
+  }
+  function isSchemaObj(it) {
+    return typeof it.schema != "boolean";
+  }
+  function subSchemaObjCode(it, valid) {
+    const { schema, gen, opts } = it;
+    if (opts.$comment && schema.$comment)
+      commentKeyword(it);
+    updateContext(it);
+    checkAsyncSchema(it);
+    const errsCount = gen.const("_errs", names_1$3.default.errors);
+    typeAndKeywords(it, errsCount);
+    gen.var(valid, (0, codegen_1$n._)`${errsCount} === ${names_1$3.default.errors}`);
+  }
+  function checkKeywords(it) {
+    (0, util_1$l.checkUnknownRules)(it);
+    checkRefsAndKeywords(it);
+  }
+  function typeAndKeywords(it, errsCount) {
+    if (it.opts.jtd)
+      return schemaKeywords(it, [], false, errsCount);
+    const types2 = (0, dataType_1$1.getSchemaTypes)(it.schema);
+    const checkedTypes = (0, dataType_1$1.coerceAndCheckDataType)(it, types2);
+    schemaKeywords(it, types2, !checkedTypes, errsCount);
+  }
+  function checkRefsAndKeywords(it) {
+    const { schema, errSchemaPath, opts, self: self2 } = it;
+    if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1$l.schemaHasRulesButRef)(schema, self2.RULES)) {
+      self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
+    }
+  }
+  function checkNoDefault(it) {
+    const { schema, opts } = it;
+    if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) {
+      (0, util_1$l.checkStrictMode)(it, "default is ignored in the schema root");
+    }
+  }
+  function updateContext(it) {
+    const schId = it.schema[it.opts.schemaId];
+    if (schId)
+      it.baseId = (0, resolve_1$3.resolveUrl)(it.opts.uriResolver, it.baseId, schId);
+  }
+  function checkAsyncSchema(it) {
+    if (it.schema.$async && !it.schemaEnv.$async)
+      throw new Error("async schema in sync schema");
+  }
+  function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
+    const msg = schema.$comment;
+    if (opts.$comment === true) {
+      gen.code((0, codegen_1$n._)`${names_1$3.default.self}.logger.log(${msg})`);
+    } else if (typeof opts.$comment == "function") {
+      const schemaPath = (0, codegen_1$n.str)`${errSchemaPath}/$comment`;
+      const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
+      gen.code((0, codegen_1$n._)`${names_1$3.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
+    }
+  }
+  function returnResults(it) {
+    const { gen, schemaEnv, validateName, ValidationError: ValidationError2, opts } = it;
+    if (schemaEnv.$async) {
+      gen.if((0, codegen_1$n._)`${names_1$3.default.errors} === 0`, () => gen.return(names_1$3.default.data), () => gen.throw((0, codegen_1$n._)`new ${ValidationError2}(${names_1$3.default.vErrors})`));
+    } else {
+      gen.assign((0, codegen_1$n._)`${validateName}.errors`, names_1$3.default.vErrors);
+      if (opts.unevaluated)
+        assignEvaluated(it);
+      gen.return((0, codegen_1$n._)`${names_1$3.default.errors} === 0`);
+    }
+  }
+  function assignEvaluated({ gen, evaluated, props, items: items2 }) {
+    if (props instanceof codegen_1$n.Name)
+      gen.assign((0, codegen_1$n._)`${evaluated}.props`, props);
+    if (items2 instanceof codegen_1$n.Name)
+      gen.assign((0, codegen_1$n._)`${evaluated}.items`, items2);
+  }
+  function schemaKeywords(it, types2, typeErrors, errsCount) {
+    const { gen, schema, data: data2, allErrors, opts, self: self2 } = it;
+    const { RULES } = self2;
+    if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1$l.schemaHasRulesButRef)(schema, RULES))) {
+      gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
+      return;
     }
-    function returnResults(it) {
-      const { gen, schemaEnv, validateName, ValidationError: ValidationError2, opts } = it;
-      if (schemaEnv.$async) {
-        gen.if((0, codegen_12._)`${names_12.default.errors} === 0`, () => gen.return(names_12.default.data), () => gen.throw((0, codegen_12._)`new ${ValidationError2}(${names_12.default.vErrors})`));
-      } else {
-        gen.assign((0, codegen_12._)`${validateName}.errors`, names_12.default.vErrors);
-        if (opts.unevaluated)
-          assignEvaluated(it);
-        gen.return((0, codegen_12._)`${names_12.default.errors} === 0`);
-      }
-    }
-    function assignEvaluated({ gen, evaluated, props, items: items2 }) {
-      if (props instanceof codegen_12.Name)
-        gen.assign((0, codegen_12._)`${evaluated}.props`, props);
-      if (items2 instanceof codegen_12.Name)
-        gen.assign((0, codegen_12._)`${evaluated}.items`, items2);
-    }
-    function schemaKeywords(it, types2, typeErrors, errsCount) {
-      const { gen, schema, data: data2, allErrors, opts, self: self2 } = it;
-      const { RULES } = self2;
-      if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_12.schemaHasRulesButRef)(schema, RULES))) {
-        gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
+    if (!opts.jtd)
+      checkStrictTypes(it, types2);
+    gen.block(() => {
+      for (const group of RULES.rules)
+        groupKeywords(group);
+      groupKeywords(RULES.post);
+    });
+    function groupKeywords(group) {
+      if (!(0, applicability_1.shouldUseGroup)(schema, group))
         return;
-      }
-      if (!opts.jtd)
-        checkStrictTypes(it, types2);
-      gen.block(() => {
-        for (const group of RULES.rules)
-          groupKeywords(group);
-        groupKeywords(RULES.post);
-      });
-      function groupKeywords(group) {
-        if (!(0, applicability_12.shouldUseGroup)(schema, group))
-          return;
-        if (group.type) {
-          gen.if((0, dataType_2.checkDataType)(group.type, data2, opts.strictNumbers));
-          iterateKeywords(it, group);
-          if (types2.length === 1 && types2[0] === group.type && typeErrors) {
-            gen.else();
-            (0, dataType_2.reportTypeError)(it);
-          }
-          gen.endIf();
-        } else {
-          iterateKeywords(it, group);
+      if (group.type) {
+        gen.if((0, dataType_2.checkDataType)(group.type, data2, opts.strictNumbers));
+        iterateKeywords(it, group);
+        if (types2.length === 1 && types2[0] === group.type && typeErrors) {
+          gen.else();
+          (0, dataType_2.reportTypeError)(it);
         }
-        if (!allErrors)
-          gen.if((0, codegen_12._)`${names_12.default.errors} === ${errsCount || 0}`);
+        gen.endIf();
+      } else {
+        iterateKeywords(it, group);
       }
+      if (!allErrors)
+        gen.if((0, codegen_1$n._)`${names_1$3.default.errors} === ${errsCount || 0}`);
     }
-    function iterateKeywords(it, group) {
-      const { gen, schema, opts: { useDefaults } } = it;
-      if (useDefaults)
-        (0, defaults_1.assignDefaults)(it, group.type);
-      gen.block(() => {
-        for (const rule of group.rules) {
-          if ((0, applicability_12.shouldUseRule)(schema, rule)) {
-            keywordCode(it, rule.keyword, rule.definition, group.type);
-          }
-        }
-      });
-    }
-    function checkStrictTypes(it, types2) {
-      if (it.schemaEnv.meta || !it.opts.strictTypes)
-        return;
-      checkContextTypes(it, types2);
-      if (!it.opts.allowUnionTypes)
-        checkMultipleTypes(it, types2);
-      checkKeywordTypes(it, it.dataTypes);
-    }
-    function checkContextTypes(it, types2) {
-      if (!types2.length)
-        return;
-      if (!it.dataTypes.length) {
-        it.dataTypes = types2;
-        return;
-      }
-      types2.forEach((t) => {
-        if (!includesType(it.dataTypes, t)) {
-          strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
-        }
-      });
-      narrowSchemaTypes(it, types2);
-    }
-    function checkMultipleTypes(it, ts) {
-      if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
-        strictTypesError(it, "use allowUnionTypes to allow union type keyword");
-      }
-    }
-    function checkKeywordTypes(it, ts) {
-      const rules2 = it.self.RULES.all;
-      for (const keyword2 in rules2) {
-        const rule = rules2[keyword2];
-        if (typeof rule == "object" && (0, applicability_12.shouldUseRule)(it.schema, rule)) {
-          const { type: type2 } = rule.definition;
-          if (type2.length && !type2.some((t) => hasApplicableType(ts, t))) {
-            strictTypesError(it, `missing type "${type2.join(",")}" for keyword "${keyword2}"`);
-          }
-        }
-      }
-    }
-    function hasApplicableType(schTs, kwdT) {
-      return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
-    }
-    function includesType(ts, t) {
-      return ts.includes(t) || t === "integer" && ts.includes("number");
-    }
-    function narrowSchemaTypes(it, withTypes) {
-      const ts = [];
-      for (const t of it.dataTypes) {
-        if (includesType(withTypes, t))
-          ts.push(t);
-        else if (withTypes.includes("integer") && t === "number")
-          ts.push("integer");
-      }
-      it.dataTypes = ts;
-    }
-    function strictTypesError(it, msg) {
-      const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
-      msg += ` at "${schemaPath}" (strictTypes)`;
-      (0, util_12.checkStrictMode)(it, msg, it.opts.strictTypes);
-    }
-    class KeywordCxt {
-      constructor(it, def2, keyword2) {
-        (0, keyword_1.validateKeywordUsage)(it, def2, keyword2);
-        this.gen = it.gen;
-        this.allErrors = it.allErrors;
-        this.keyword = keyword2;
-        this.data = it.data;
-        this.schema = it.schema[keyword2];
-        this.$data = def2.$data && it.opts.$data && this.schema && this.schema.$data;
-        this.schemaValue = (0, util_12.schemaRefOrVal)(it, this.schema, keyword2, this.$data);
-        this.schemaType = def2.schemaType;
-        this.parentSchema = it.schema;
-        this.params = {};
-        this.it = it;
-        this.def = def2;
-        if (this.$data) {
-          this.schemaCode = it.gen.const("vSchema", getData2(this.$data, it));
-        } else {
-          this.schemaCode = this.schemaValue;
-          if (!(0, keyword_1.validSchemaType)(this.schema, def2.schemaType, def2.allowUndefined)) {
-            throw new Error(`${keyword2} value must be ${JSON.stringify(def2.schemaType)}`);
-          }
-        }
-        if ("code" in def2 ? def2.trackErrors : def2.errors !== false) {
-          this.errsCount = it.gen.const("_errs", names_12.default.errors);
+  }
+  function iterateKeywords(it, group) {
+    const { gen, schema, opts: { useDefaults } } = it;
+    if (useDefaults)
+      (0, defaults_1.assignDefaults)(it, group.type);
+    gen.block(() => {
+      for (const rule of group.rules) {
+        if ((0, applicability_1.shouldUseRule)(schema, rule)) {
+          keywordCode(it, rule.keyword, rule.definition, group.type);
         }
       }
-      result(condition, successAction, failAction) {
-        this.failResult((0, codegen_12.not)(condition), successAction, failAction);
+    });
+  }
+  function checkStrictTypes(it, types2) {
+    if (it.schemaEnv.meta || !it.opts.strictTypes)
+      return;
+    checkContextTypes(it, types2);
+    if (!it.opts.allowUnionTypes)
+      checkMultipleTypes(it, types2);
+    checkKeywordTypes(it, it.dataTypes);
+  }
+  function checkContextTypes(it, types2) {
+    if (!types2.length)
+      return;
+    if (!it.dataTypes.length) {
+      it.dataTypes = types2;
+      return;
+    }
+    types2.forEach((t) => {
+      if (!includesType(it.dataTypes, t)) {
+        strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
       }
-      failResult(condition, successAction, failAction) {
-        this.gen.if(condition);
-        if (failAction)
-          failAction();
-        else
-          this.error();
-        if (successAction) {
-          this.gen.else();
-          successAction();
-          if (this.allErrors)
-            this.gen.endIf();
-        } else {
-          if (this.allErrors)
-            this.gen.endIf();
-          else
-            this.gen.else();
+    });
+    narrowSchemaTypes(it, types2);
+  }
+  function checkMultipleTypes(it, ts) {
+    if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
+      strictTypesError(it, "use allowUnionTypes to allow union type keyword");
+    }
+  }
+  function checkKeywordTypes(it, ts) {
+    const rules2 = it.self.RULES.all;
+    for (const keyword2 in rules2) {
+      const rule = rules2[keyword2];
+      if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {
+        const { type: type2 } = rule.definition;
+        if (type2.length && !type2.some((t) => hasApplicableType(ts, t))) {
+          strictTypesError(it, `missing type "${type2.join(",")}" for keyword "${keyword2}"`);
+        }
+      }
+    }
+  }
+  function hasApplicableType(schTs, kwdT) {
+    return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
+  }
+  function includesType(ts, t) {
+    return ts.includes(t) || t === "integer" && ts.includes("number");
+  }
+  function narrowSchemaTypes(it, withTypes) {
+    const ts = [];
+    for (const t of it.dataTypes) {
+      if (includesType(withTypes, t))
+        ts.push(t);
+      else if (withTypes.includes("integer") && t === "number")
+        ts.push("integer");
+    }
+    it.dataTypes = ts;
+  }
+  function strictTypesError(it, msg) {
+    const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
+    msg += ` at "${schemaPath}" (strictTypes)`;
+    (0, util_1$l.checkStrictMode)(it, msg, it.opts.strictTypes);
+  }
+  class KeywordCxt {
+    constructor(it, def2, keyword2) {
+      (0, keyword_1.validateKeywordUsage)(it, def2, keyword2);
+      this.gen = it.gen;
+      this.allErrors = it.allErrors;
+      this.keyword = keyword2;
+      this.data = it.data;
+      this.schema = it.schema[keyword2];
+      this.$data = def2.$data && it.opts.$data && this.schema && this.schema.$data;
+      this.schemaValue = (0, util_1$l.schemaRefOrVal)(it, this.schema, keyword2, this.$data);
+      this.schemaType = def2.schemaType;
+      this.parentSchema = it.schema;
+      this.params = {};
+      this.it = it;
+      this.def = def2;
+      if (this.$data) {
+        this.schemaCode = it.gen.const("vSchema", getData$1(this.$data, it));
+      } else {
+        this.schemaCode = this.schemaValue;
+        if (!(0, keyword_1.validSchemaType)(this.schema, def2.schemaType, def2.allowUndefined)) {
+          throw new Error(`${keyword2} value must be ${JSON.stringify(def2.schemaType)}`);
         }
       }
-      pass(condition, failAction) {
-        this.failResult((0, codegen_12.not)(condition), void 0, failAction);
+      if ("code" in def2 ? def2.trackErrors : def2.errors !== false) {
+        this.errsCount = it.gen.const("_errs", names_1$3.default.errors);
       }
-      fail(condition) {
-        if (condition === void 0) {
-          this.error();
-          if (!this.allErrors)
-            this.gen.if(false);
-          return;
-        }
-        this.gen.if(condition);
+    }
+    result(condition, successAction, failAction) {
+      this.failResult((0, codegen_1$n.not)(condition), successAction, failAction);
+    }
+    failResult(condition, successAction, failAction) {
+      this.gen.if(condition);
+      if (failAction)
+        failAction();
+      else
         this.error();
+      if (successAction) {
+        this.gen.else();
+        successAction();
+        if (this.allErrors)
+          this.gen.endIf();
+      } else {
         if (this.allErrors)
           this.gen.endIf();
         else
           this.gen.else();
       }
-      fail$data(condition) {
-        if (!this.$data)
-          return this.fail(condition);
-        const { schemaCode } = this;
-        this.fail((0, codegen_12._)`${schemaCode} !== undefined && (${(0, codegen_12.or)(this.invalid$data(), condition)})`);
-      }
-      error(append, errorParams, errorPaths) {
-        if (errorParams) {
-          this.setParams(errorParams);
-          this._error(append, errorPaths);
-          this.setParams({});
-          return;
-        }
-        this._error(append, errorPaths);
-      }
-      _error(append, errorPaths) {
-        (append ? errors_12.reportExtraError : errors_12.reportError)(this, this.def.error, errorPaths);
-      }
-      $dataError() {
-        (0, errors_12.reportError)(this, this.def.$dataError || errors_12.keyword$DataError);
-      }
-      reset() {
-        if (this.errsCount === void 0)
-          throw new Error('add "trackErrors" to keyword definition');
-        (0, errors_12.resetErrorsCount)(this.gen, this.errsCount);
-      }
-      ok(cond) {
+    }
+    pass(condition, failAction) {
+      this.failResult((0, codegen_1$n.not)(condition), void 0, failAction);
+    }
+    fail(condition) {
+      if (condition === void 0) {
+        this.error();
         if (!this.allErrors)
-          this.gen.if(cond);
+          this.gen.if(false);
+        return;
       }
-      setParams(obj, assign) {
-        if (assign)
-          Object.assign(this.params, obj);
-        else
-          this.params = obj;
+      this.gen.if(condition);
+      this.error();
+      if (this.allErrors)
+        this.gen.endIf();
+      else
+        this.gen.else();
+    }
+    fail$data(condition) {
+      if (!this.$data)
+        return this.fail(condition);
+      const { schemaCode } = this;
+      this.fail((0, codegen_1$n._)`${schemaCode} !== undefined && (${(0, codegen_1$n.or)(this.invalid$data(), condition)})`);
+    }
+    error(append, errorParams, errorPaths) {
+      if (errorParams) {
+        this.setParams(errorParams);
+        this._error(append, errorPaths);
+        this.setParams({});
+        return;
       }
-      block$data(valid, codeBlock, $dataValid = codegen_12.nil) {
-        this.gen.block(() => {
-          this.check$data(valid, $dataValid);
-          codeBlock();
-        });
+      this._error(append, errorPaths);
+    }
+    _error(append, errorPaths) {
+      (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
+    }
+    $dataError() {
+      (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
+    }
+    reset() {
+      if (this.errsCount === void 0)
+        throw new Error('add "trackErrors" to keyword definition');
+      (0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
+    }
+    ok(cond) {
+      if (!this.allErrors)
+        this.gen.if(cond);
+    }
+    setParams(obj, assign) {
+      if (assign)
+        Object.assign(this.params, obj);
+      else
+        this.params = obj;
+    }
+    block$data(valid, codeBlock, $dataValid = codegen_1$n.nil) {
+      this.gen.block(() => {
+        this.check$data(valid, $dataValid);
+        codeBlock();
+      });
+    }
+    check$data(valid = codegen_1$n.nil, $dataValid = codegen_1$n.nil) {
+      if (!this.$data)
+        return;
+      const { gen, schemaCode, schemaType, def: def2 } = this;
+      gen.if((0, codegen_1$n.or)((0, codegen_1$n._)`${schemaCode} === undefined`, $dataValid));
+      if (valid !== codegen_1$n.nil)
+        gen.assign(valid, true);
+      if (schemaType.length || def2.validateSchema) {
+        gen.elseIf(this.invalid$data());
+        this.$dataError();
+        if (valid !== codegen_1$n.nil)
+          gen.assign(valid, false);
       }
-      check$data(valid = codegen_12.nil, $dataValid = codegen_12.nil) {
-        if (!this.$data)
-          return;
-        const { gen, schemaCode, schemaType, def: def2 } = this;
-        gen.if((0, codegen_12.or)((0, codegen_12._)`${schemaCode} === undefined`, $dataValid));
-        if (valid !== codegen_12.nil)
-          gen.assign(valid, true);
-        if (schemaType.length || def2.validateSchema) {
-          gen.elseIf(this.invalid$data());
-          this.$dataError();
-          if (valid !== codegen_12.nil)
-            gen.assign(valid, false);
+      gen.else();
+    }
+    invalid$data() {
+      const { gen, schemaCode, schemaType, def: def2, it } = this;
+      return (0, codegen_1$n.or)(wrong$DataType(), invalid$DataSchema());
+      function wrong$DataType() {
+        if (schemaType.length) {
+          if (!(schemaCode instanceof codegen_1$n.Name))
+            throw new Error("ajv implementation error");
+          const st = Array.isArray(schemaType) ? schemaType : [schemaType];
+          return (0, codegen_1$n._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
         }
-        gen.else();
+        return codegen_1$n.nil;
       }
-      invalid$data() {
-        const { gen, schemaCode, schemaType, def: def2, it } = this;
-        return (0, codegen_12.or)(wrong$DataType(), invalid$DataSchema());
-        function wrong$DataType() {
-          if (schemaType.length) {
-            if (!(schemaCode instanceof codegen_12.Name))
-              throw new Error("ajv implementation error");
-            const st = Array.isArray(schemaType) ? schemaType : [schemaType];
-            return (0, codegen_12._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
-          }
-          return codegen_12.nil;
-        }
-        function invalid$DataSchema() {
-          if (def2.validateSchema) {
-            const validateSchemaRef = gen.scopeValue("validate$data", { ref: def2.validateSchema });
-            return (0, codegen_12._)`!${validateSchemaRef}(${schemaCode})`;
-          }
-          return codegen_12.nil;
-        }
-      }
-      subschema(appl, valid) {
-        const subschema2 = (0, subschema_1.getSubschema)(this.it, appl);
-        (0, subschema_1.extendSubschemaData)(subschema2, this.it, appl);
-        (0, subschema_1.extendSubschemaMode)(subschema2, appl);
-        const nextContext = { ...this.it, ...subschema2, items: void 0, props: void 0 };
-        subschemaCode(nextContext, valid);
-        return nextContext;
-      }
-      mergeEvaluated(schemaCxt, toName) {
-        const { it, gen } = this;
-        if (!it.opts.unevaluated)
-          return;
-        if (it.props !== true && schemaCxt.props !== void 0) {
-          it.props = util_12.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
-        }
-        if (it.items !== true && schemaCxt.items !== void 0) {
-          it.items = util_12.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
+      function invalid$DataSchema() {
+        if (def2.validateSchema) {
+          const validateSchemaRef = gen.scopeValue("validate$data", { ref: def2.validateSchema });
+          return (0, codegen_1$n._)`!${validateSchemaRef}(${schemaCode})`;
         }
+        return codegen_1$n.nil;
       }
-      mergeValidEvaluated(schemaCxt, valid) {
-        const { it, gen } = this;
-        if (it.opts.unevaluated && (it.props !== true || it.items !== true)) {
-          gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_12.Name));
-          return true;
-        }
+    }
+    subschema(appl, valid) {
+      const subschema2 = (0, subschema_1.getSubschema)(this.it, appl);
+      (0, subschema_1.extendSubschemaData)(subschema2, this.it, appl);
+      (0, subschema_1.extendSubschemaMode)(subschema2, appl);
+      const nextContext = { ...this.it, ...subschema2, items: void 0, props: void 0 };
+      subschemaCode(nextContext, valid);
+      return nextContext;
+    }
+    mergeEvaluated(schemaCxt, toName) {
+      const { it, gen } = this;
+      if (!it.opts.unevaluated)
+        return;
+      if (it.props !== true && schemaCxt.props !== void 0) {
+        it.props = util_1$l.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
+      }
+      if (it.items !== true && schemaCxt.items !== void 0) {
+        it.items = util_1$l.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
+      }
+    }
+    mergeValidEvaluated(schemaCxt, valid) {
+      const { it, gen } = this;
+      if (it.opts.unevaluated && (it.props !== true || it.items !== true)) {
+        gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1$n.Name));
+        return true;
       }
     }
-    validate$2.KeywordCxt = KeywordCxt;
-    function keywordCode(it, keyword2, def2, ruleType) {
-      const cxt = new KeywordCxt(it, def2, keyword2);
-      if ("code" in def2) {
-        def2.code(cxt, ruleType);
-      } else if (cxt.$data && def2.validate) {
-        (0, keyword_1.funcKeywordCode)(cxt, def2);
-      } else if ("macro" in def2) {
-        (0, keyword_1.macroKeywordCode)(cxt, def2);
-      } else if (def2.compile || def2.validate) {
-        (0, keyword_1.funcKeywordCode)(cxt, def2);
-      }
-    }
-    const JSON_POINTER2 = /^\/(?:[^~]|~0|~1)*$/;
-    const RELATIVE_JSON_POINTER2 = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
-    function getData2($data, { dataLevel, dataNames, dataPathArr }) {
-      let jsonPointer;
-      let data2;
-      if ($data === "")
-        return names_12.default.rootData;
-      if ($data[0] === "/") {
-        if (!JSON_POINTER2.test($data))
-          throw new Error(`Invalid JSON-pointer: ${$data}`);
-        jsonPointer = $data;
-        data2 = names_12.default.rootData;
-      } else {
-        const matches = RELATIVE_JSON_POINTER2.exec($data);
-        if (!matches)
-          throw new Error(`Invalid JSON-pointer: ${$data}`);
-        const up = +matches[1];
-        jsonPointer = matches[2];
-        if (jsonPointer === "#") {
-          if (up >= dataLevel)
-            throw new Error(errorMsg("property/index", up));
-          return dataPathArr[dataLevel - up];
-        }
-        if (up > dataLevel)
-          throw new Error(errorMsg("data", up));
-        data2 = dataNames[dataLevel - up];
-        if (!jsonPointer)
-          return data2;
-      }
-      let expr = data2;
-      const segments = jsonPointer.split("/");
-      for (const segment of segments) {
-        if (segment) {
-          data2 = (0, codegen_12._)`${data2}${(0, codegen_12.getProperty)((0, util_12.unescapeJsonPointer)(segment))}`;
-          expr = (0, codegen_12._)`${expr} && ${data2}`;
-        }
-      }
-      return expr;
-      function errorMsg(pointerType, up) {
-        return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
-      }
-    }
-    validate$2.getData = getData2;
-    return validate$2;
   }
-  var validation_error = {};
-  var hasRequiredValidation_error;
-  function requireValidation_error() {
-    if (hasRequiredValidation_error) return validation_error;
-    hasRequiredValidation_error = 1;
-    Object.defineProperty(validation_error, "__esModule", { value: true });
-    class ValidationError2 extends Error {
-      constructor(errors2) {
-        super("validation failed");
-        this.errors = errors2;
-        this.ajv = this.validation = true;
+  validate$2.KeywordCxt = KeywordCxt;
+  function keywordCode(it, keyword2, def2, ruleType) {
+    const cxt = new KeywordCxt(it, def2, keyword2);
+    if ("code" in def2) {
+      def2.code(cxt, ruleType);
+    } else if (cxt.$data && def2.validate) {
+      (0, keyword_1.funcKeywordCode)(cxt, def2);
+    } else if ("macro" in def2) {
+      (0, keyword_1.macroKeywordCode)(cxt, def2);
+    } else if (def2.compile || def2.validate) {
+      (0, keyword_1.funcKeywordCode)(cxt, def2);
+    }
+  }
+  const JSON_POINTER$2 = /^\/(?:[^~]|~0|~1)*$/;
+  const RELATIVE_JSON_POINTER$2 = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
+  function getData$1($data, { dataLevel, dataNames, dataPathArr }) {
+    let jsonPointer;
+    let data2;
+    if ($data === "")
+      return names_1$3.default.rootData;
+    if ($data[0] === "/") {
+      if (!JSON_POINTER$2.test($data))
+        throw new Error(`Invalid JSON-pointer: ${$data}`);
+      jsonPointer = $data;
+      data2 = names_1$3.default.rootData;
+    } else {
+      const matches = RELATIVE_JSON_POINTER$2.exec($data);
+      if (!matches)
+        throw new Error(`Invalid JSON-pointer: ${$data}`);
+      const up = +matches[1];
+      jsonPointer = matches[2];
+      if (jsonPointer === "#") {
+        if (up >= dataLevel)
+          throw new Error(errorMsg("property/index", up));
+        return dataPathArr[dataLevel - up];
+      }
+      if (up > dataLevel)
+        throw new Error(errorMsg("data", up));
+      data2 = dataNames[dataLevel - up];
+      if (!jsonPointer)
+        return data2;
+    }
+    let expr = data2;
+    const segments = jsonPointer.split("/");
+    for (const segment of segments) {
+      if (segment) {
+        data2 = (0, codegen_1$n._)`${data2}${(0, codegen_1$n.getProperty)((0, util_1$l.unescapeJsonPointer)(segment))}`;
+        expr = (0, codegen_1$n._)`${expr} && ${data2}`;
       }
     }
-    validation_error.default = ValidationError2;
-    return validation_error;
+    return expr;
+    function errorMsg(pointerType, up) {
+      return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
+    }
   }
+  validate$2.getData = getData$1;
+  var validation_error = {};
+  Object.defineProperty(validation_error, "__esModule", { value: true });
+  let ValidationError$2 = class ValidationError extends Error {
+    constructor(errors2) {
+      super("validation failed");
+      this.errors = errors2;
+      this.ajv = this.validation = true;
+    }
+  };
+  validation_error.default = ValidationError$2;
   var ref_error = {};
   Object.defineProperty(ref_error, "__esModule", { value: true });
   const resolve_1$2 = resolve$6;
@@ -2762,11 +2726,11 @@
   Object.defineProperty(compile$2, "__esModule", { value: true });
   compile$2.resolveSchema = compile$2.getCompilingSchema = compile$2.resolveRef = compile$2.compileSchema = compile$2.SchemaEnv = void 0;
   const codegen_1$m = codegen;
-  const validation_error_1 = requireValidation_error();
+  const validation_error_1 = validation_error;
   const names_1$2 = names$1;
   const resolve_1$1 = resolve$6;
   const util_1$k = util$7;
-  const validate_1$1 = requireValidate();
+  const validate_1$1 = validate$2;
   class SchemaEnv {
     constructor(env) {
       var _a;
@@ -3006,58 +2970,81 @@
   };
   var uri$2 = {};
   var fastUri$1 = { exports: {} };
-  const isUUID$1 = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
-  const isIPv4$1 = 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);
-  function stringArrayToHexStripped(input) {
-    let acc = "";
-    let code2 = 0;
-    let i = 0;
-    for (i = 0; i < input.length; i++) {
-      code2 = input[i].charCodeAt(0);
-      if (code2 === 48) {
-        continue;
-      }
-      if (!(code2 >= 48 && code2 <= 57 || code2 >= 65 && code2 <= 70 || code2 >= 97 && code2 <= 102)) {
-        return "";
-      }
-      acc += input[i];
-      break;
-    }
-    for (i += 1; i < input.length; i++) {
-      code2 = input[i].charCodeAt(0);
-      if (!(code2 >= 48 && code2 <= 57 || code2 >= 65 && code2 <= 70 || code2 >= 97 && code2 <= 102)) {
-        return "";
-      }
-      acc += input[i];
+  const HEX$1 = {
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3,
+    4: 4,
+    5: 5,
+    6: 6,
+    7: 7,
+    8: 8,
+    9: 9,
+    a: 10,
+    A: 10,
+    b: 11,
+    B: 11,
+    c: 12,
+    C: 12,
+    d: 13,
+    D: 13,
+    e: 14,
+    E: 14,
+    f: 15,
+    F: 15
+  };
+  var scopedChars = {
+    HEX: HEX$1
+  };
+  const { HEX } = scopedChars;
+  const IPV4_REG = /^(?:(?: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;
+  function normalizeIPv4$1(host) {
+    if (findToken(host, ".") < 3) {
+      return { host, isIPV4: false };
+    }
+    const matches = host.match(IPV4_REG) || [];
+    const [address] = matches;
+    if (address) {
+      return { host: stripLeadingZeros(address, "."), isIPV4: true };
+    } else {
+      return { host, isIPV4: false };
     }
-    return acc;
   }
-  const nonSimpleDomain$1 = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-  function consumeIsZone(buffer) {
-    buffer.length = 0;
-    return true;
-  }
-  function consumeHextets(buffer, address, output) {
-    if (buffer.length) {
-      const hex = stringArrayToHexStripped(buffer);
-      if (hex !== "") {
-        address.push(hex);
-      } else {
-        output.error = true;
-        return false;
-      }
-      buffer.length = 0;
+  function stringArrayToHexStripped(input, keepZero = false) {
+    let acc = "";
+    let strip = true;
+    for (const c of input) {
+      if (HEX[c] === void 0) return void 0;
+      if (c !== "0" && strip === true) strip = false;
+      if (!strip) acc += c;
     }
-    return true;
+    if (keepZero && acc.length === 0) acc = "0";
+    return acc;
   }
   function getIPV6(input) {
     let tokenCount = 0;
     const output = { error: false, address: "", zone: "" };
     const address = [];
     const buffer = [];
+    let isZone = false;
     let endipv6Encountered = false;
     let endIpv6 = false;
-    let consume = consumeHextets;
+    function consume() {
+      if (buffer.length) {
+        if (isZone === false) {
+          const hex = stringArrayToHexStripped(buffer);
+          if (hex !== void 0) {
+            address.push(hex);
+          } else {
+            output.error = true;
+            return false;
+          }
+        }
+        buffer.length = 0;
+      }
+      return true;
+    }
     for (let i = 0; i < input.length; i++) {
       const cursor = input[i];
       if (cursor === "[" || cursor === "]") {
@@ -3067,30 +3054,31 @@
         if (endipv6Encountered === true) {
           endIpv6 = true;
         }
-        if (!consume(buffer, address, output)) {
+        if (!consume()) {
           break;
         }
-        if (++tokenCount > 7) {
+        tokenCount++;
+        address.push(":");
+        if (tokenCount > 7) {
           output.error = true;
           break;
         }
-        if (i > 0 && input[i - 1] === ":") {
+        if (i - 1 >= 0 && input[i - 1] === ":") {
           endipv6Encountered = true;
         }
-        address.push(":");
         continue;
       } else if (cursor === "%") {
-        if (!consume(buffer, address, output)) {
+        if (!consume()) {
           break;
         }
-        consume = consumeIsZone;
+        isZone = true;
       } else {
         buffer.push(cursor);
         continue;
       }
     }
     if (buffer.length) {
-      if (consume === consumeIsZone) {
+      if (isZone) {
         output.zone = buffer.join("");
       } else if (endIpv6) {
         address.push(buffer.join(""));
@@ -3113,11 +3101,33 @@
         newHost += "%" + ipv6.zone;
         escapedHost += "%25" + ipv6.zone;
       }
-      return { host: newHost, isIPV6: true, escapedHost };
+      return { host: newHost, escapedHost, isIPV6: true };
     } else {
       return { host, isIPV6: false };
     }
   }
+  function stripLeadingZeros(str, token) {
+    let out = "";
+    let skip = true;
+    const l = str.length;
+    for (let i = 0; i < l; i++) {
+      const c = str[i];
+      if (c === "0" && skip) {
+        if (i + 1 <= l && str[i + 1] === token || i + 1 === l) {
+          out += c;
+          skip = false;
+        }
+      } else {
+        if (c === token) {
+          skip = true;
+        } else {
+          skip = false;
+        }
+        out += c;
+      }
+    }
+    return out;
+  }
   function findToken(str, token) {
     let ind = 0;
     for (let i = 0; i < str.length; i++) {
@@ -3125,339 +3135,246 @@
     }
     return ind;
   }
-  function removeDotSegments$1(path) {
-    let input = path;
+  const RDS1 = /^\.\.?\//u;
+  const RDS2 = /^\/\.(?:\/|$)/u;
+  const RDS3 = /^\/\.\.(?:\/|$)/u;
+  const RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/u;
+  function removeDotSegments$1(input) {
     const output = [];
-    let nextSlash = -1;
-    let len = 0;
-    while (len = input.length) {
-      if (len === 1) {
-        if (input === ".") {
-          break;
-        } else if (input === "/") {
-          output.push("/");
-          break;
+    while (input.length) {
+      if (input.match(RDS1)) {
+        input = input.replace(RDS1, "");
+      } else if (input.match(RDS2)) {
+        input = input.replace(RDS2, "/");
+      } else if (input.match(RDS3)) {
+        input = input.replace(RDS3, "/");
+        output.pop();
+      } else if (input === "." || input === "..") {
+        input = "";
+      } else {
+        const im = input.match(RDS5);
+        if (im) {
+          const s = im[0];
+          input = input.slice(s.length);
+          output.push(s);
         } else {
-          output.push(input);
-          break;
-        }
-      } else if (len === 2) {
-        if (input[0] === ".") {
-          if (input[1] === ".") {
-            break;
-          } else if (input[1] === "/") {
-            input = input.slice(2);
-            continue;
-          }
-        } else if (input[0] === "/") {
-          if (input[1] === "." || input[1] === "/") {
-            output.push("/");
-            break;
-          }
-        }
-      } else if (len === 3) {
-        if (input === "/..") {
-          if (output.length !== 0) {
-            output.pop();
-          }
-          output.push("/");
-          break;
-        }
-      }
-      if (input[0] === ".") {
-        if (input[1] === ".") {
-          if (input[2] === "/") {
-            input = input.slice(3);
-            continue;
-          }
-        } else if (input[1] === "/") {
-          input = input.slice(2);
-          continue;
-        }
-      } else if (input[0] === "/") {
-        if (input[1] === ".") {
-          if (input[2] === "/") {
-            input = input.slice(2);
-            continue;
-          } else if (input[2] === ".") {
-            if (input[3] === "/") {
-              input = input.slice(3);
-              if (output.length !== 0) {
-                output.pop();
-              }
-              continue;
-            }
-          }
+          throw new Error("Unexpected dot segment condition");
         }
       }
-      if ((nextSlash = input.indexOf("/", 1)) === -1) {
-        output.push(input);
-        break;
-      } else {
-        output.push(input.slice(0, nextSlash));
-        input = input.slice(nextSlash);
-      }
     }
     return output.join("");
   }
-  function normalizeComponentEncoding$1(component, esc) {
+  function normalizeComponentEncoding$1(components, esc) {
     const func = esc !== true ? escape : unescape;
-    if (component.scheme !== void 0) {
-      component.scheme = func(component.scheme);
+    if (components.scheme !== void 0) {
+      components.scheme = func(components.scheme);
     }
-    if (component.userinfo !== void 0) {
-      component.userinfo = func(component.userinfo);
+    if (components.userinfo !== void 0) {
+      components.userinfo = func(components.userinfo);
     }
-    if (component.host !== void 0) {
-      component.host = func(component.host);
+    if (components.host !== void 0) {
+      components.host = func(components.host);
     }
-    if (component.path !== void 0) {
-      component.path = func(component.path);
+    if (components.path !== void 0) {
+      components.path = func(components.path);
     }
-    if (component.query !== void 0) {
-      component.query = func(component.query);
+    if (components.query !== void 0) {
+      components.query = func(components.query);
     }
-    if (component.fragment !== void 0) {
-      component.fragment = func(component.fragment);
+    if (components.fragment !== void 0) {
+      components.fragment = func(components.fragment);
     }
-    return component;
+    return components;
   }
-  function recomposeAuthority$1(component) {
+  function recomposeAuthority$1(components) {
     const uriTokens = [];
-    if (component.userinfo !== void 0) {
-      uriTokens.push(component.userinfo);
+    if (components.userinfo !== void 0) {
+      uriTokens.push(components.userinfo);
       uriTokens.push("@");
     }
-    if (component.host !== void 0) {
-      let host = unescape(component.host);
-      if (!isIPv4$1(host)) {
-        const ipV6res = normalizeIPv6$1(host);
+    if (components.host !== void 0) {
+      let host = unescape(components.host);
+      const ipV4res = normalizeIPv4$1(host);
+      if (ipV4res.isIPV4) {
+        host = ipV4res.host;
+      } else {
+        const ipV6res = normalizeIPv6$1(ipV4res.host);
         if (ipV6res.isIPV6 === true) {
           host = `[${ipV6res.escapedHost}]`;
         } else {
-          host = component.host;
+          host = components.host;
         }
       }
       uriTokens.push(host);
     }
-    if (typeof component.port === "number" || typeof component.port === "string") {
+    if (typeof components.port === "number" || typeof components.port === "string") {
       uriTokens.push(":");
-      uriTokens.push(String(component.port));
+      uriTokens.push(String(components.port));
     }
     return uriTokens.length ? uriTokens.join("") : void 0;
   }
   var utils = {
-    nonSimpleDomain: nonSimpleDomain$1,
     recomposeAuthority: recomposeAuthority$1,
     normalizeComponentEncoding: normalizeComponentEncoding$1,
     removeDotSegments: removeDotSegments$1,
-    isIPv4: isIPv4$1,
-    isUUID: isUUID$1,
+    normalizeIPv4: normalizeIPv4$1,
     normalizeIPv6: normalizeIPv6$1
   };
-  const { isUUID } = utils;
+  const UUID_REG = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu;
   const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
-  function wsIsSecure(wsComponent) {
-    if (wsComponent.secure === true) {
-      return true;
-    } else if (wsComponent.secure === false) {
-      return false;
-    } 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");
-    } else {
-      return false;
-    }
+  function isSecure(wsComponents) {
+    return typeof wsComponents.secure === "boolean" ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
   }
-  function httpParse(component) {
-    if (!component.host) {
-      component.error = component.error || "HTTP URIs must have a host.";
+  function httpParse(components) {
+    if (!components.host) {
+      components.error = components.error || "HTTP URIs must have a host.";
     }
-    return component;
+    return components;
   }
-  function httpSerialize(component) {
-    const secure = String(component.scheme).toLowerCase() === "https";
-    if (component.port === (secure ? 443 : 80) || component.port === "") {
-      component.port = void 0;
+  function httpSerialize(components) {
+    const secure = String(components.scheme).toLowerCase() === "https";
+    if (components.port === (secure ? 443 : 80) || components.port === "") {
+      components.port = void 0;
     }
-    if (!component.path) {
-      component.path = "/";
+    if (!components.path) {
+      components.path = "/";
     }
-    return component;
+    return components;
   }
-  function wsParse(wsComponent) {
-    wsComponent.secure = wsIsSecure(wsComponent);
-    wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : "");
-    wsComponent.path = void 0;
-    wsComponent.query = void 0;
-    return wsComponent;
+  function wsParse(wsComponents) {
+    wsComponents.secure = isSecure(wsComponents);
+    wsComponents.resourceName = (wsComponents.path || "/") + (wsComponents.query ? "?" + wsComponents.query : "");
+    wsComponents.path = void 0;
+    wsComponents.query = void 0;
+    return wsComponents;
   }
-  function wsSerialize(wsComponent) {
-    if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") {
-      wsComponent.port = void 0;
+  function wsSerialize(wsComponents) {
+    if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") {
+      wsComponents.port = void 0;
     }
-    if (typeof wsComponent.secure === "boolean") {
-      wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
-      wsComponent.secure = void 0;
+    if (typeof wsComponents.secure === "boolean") {
+      wsComponents.scheme = wsComponents.secure ? "wss" : "ws";
+      wsComponents.secure = void 0;
     }
-    if (wsComponent.resourceName) {
-      const [path, query] = wsComponent.resourceName.split("?");
-      wsComponent.path = path && path !== "/" ? path : void 0;
-      wsComponent.query = query;
-      wsComponent.resourceName = void 0;
+    if (wsComponents.resourceName) {
+      const [path, query] = wsComponents.resourceName.split("?");
+      wsComponents.path = path && path !== "/" ? path : void 0;
+      wsComponents.query = query;
+      wsComponents.resourceName = void 0;
     }
-    wsComponent.fragment = void 0;
-    return wsComponent;
+    wsComponents.fragment = void 0;
+    return wsComponents;
   }
-  function urnParse(urnComponent, options) {
-    if (!urnComponent.path) {
-      urnComponent.error = "URN can not be parsed";
-      return urnComponent;
+  function urnParse(urnComponents, options) {
+    if (!urnComponents.path) {
+      urnComponents.error = "URN can not be parsed";
+      return urnComponents;
     }
-    const matches = urnComponent.path.match(URN_REG);
+    const matches = urnComponents.path.match(URN_REG);
     if (matches) {
-      const scheme = options.scheme || urnComponent.scheme || "urn";
-      urnComponent.nid = matches[1].toLowerCase();
-      urnComponent.nss = matches[2];
-      const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`;
-      const schemeHandler = getSchemeHandler$1(urnScheme);
-      urnComponent.path = void 0;
+      const scheme = options.scheme || urnComponents.scheme || "urn";
+      urnComponents.nid = matches[1].toLowerCase();
+      urnComponents.nss = matches[2];
+      const urnScheme = `${scheme}:${options.nid || urnComponents.nid}`;
+      const schemeHandler = SCHEMES$1[urnScheme];
+      urnComponents.path = void 0;
       if (schemeHandler) {
-        urnComponent = schemeHandler.parse(urnComponent, options);
+        urnComponents = schemeHandler.parse(urnComponents, options);
       }
     } else {
-      urnComponent.error = urnComponent.error || "URN can not be parsed.";
+      urnComponents.error = urnComponents.error || "URN can not be parsed.";
     }
-    return urnComponent;
+    return urnComponents;
   }
-  function urnSerialize(urnComponent, options) {
-    if (urnComponent.nid === void 0) {
-      throw new Error("URN without nid cannot be serialized");
-    }
-    const scheme = options.scheme || urnComponent.scheme || "urn";
-    const nid = urnComponent.nid.toLowerCase();
+  function urnSerialize(urnComponents, options) {
+    const scheme = options.scheme || urnComponents.scheme || "urn";
+    const nid = urnComponents.nid.toLowerCase();
     const urnScheme = `${scheme}:${options.nid || nid}`;
-    const schemeHandler = getSchemeHandler$1(urnScheme);
+    const schemeHandler = SCHEMES$1[urnScheme];
     if (schemeHandler) {
-      urnComponent = schemeHandler.serialize(urnComponent, options);
+      urnComponents = schemeHandler.serialize(urnComponents, options);
     }
-    const uriComponent = urnComponent;
-    const nss = urnComponent.nss;
-    uriComponent.path = `${nid || options.nid}:${nss}`;
+    const uriComponents = urnComponents;
+    const nss = urnComponents.nss;
+    uriComponents.path = `${nid || options.nid}:${nss}`;
     options.skipEscape = true;
-    return uriComponent;
-  }
-  function urnuuidParse(urnComponent, options) {
-    const uuidComponent = urnComponent;
-    uuidComponent.uuid = uuidComponent.nss;
-    uuidComponent.nss = void 0;
-    if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) {
-      uuidComponent.error = uuidComponent.error || "UUID is not valid.";
-    }
-    return uuidComponent;
-  }
-  function urnuuidSerialize(uuidComponent) {
-    const urnComponent = uuidComponent;
-    urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
-    return urnComponent;
-  }
-  const http = (
-    /** @type {SchemeHandler} */
-    {
-      scheme: "http",
-      domainHost: true,
-      parse: httpParse,
-      serialize: httpSerialize
-    }
-  );
-  const https = (
-    /** @type {SchemeHandler} */
-    {
-      scheme: "https",
-      domainHost: http.domainHost,
-      parse: httpParse,
-      serialize: httpSerialize
-    }
-  );
-  const ws = (
-    /** @type {SchemeHandler} */
-    {
-      scheme: "ws",
-      domainHost: true,
-      parse: wsParse,
-      serialize: wsSerialize
-    }
-  );
-  const wss = (
-    /** @type {SchemeHandler} */
-    {
-      scheme: "wss",
-      domainHost: ws.domainHost,
-      parse: ws.parse,
-      serialize: ws.serialize
-    }
-  );
-  const urn = (
-    /** @type {SchemeHandler} */
-    {
-      scheme: "urn",
-      parse: urnParse,
-      serialize: urnSerialize,
-      skipNormalize: true
-    }
-  );
-  const urnuuid = (
-    /** @type {SchemeHandler} */
-    {
-      scheme: "urn:uuid",
-      parse: urnuuidParse,
-      serialize: urnuuidSerialize,
-      skipNormalize: true
-    }
-  );
-  const SCHEMES$1 = (
-    /** @type {Record<SchemeName, SchemeHandler>} */
-    {
-      http,
-      https,
-      ws,
-      wss,
-      urn,
-      "urn:uuid": urnuuid
-    }
-  );
-  Object.setPrototypeOf(SCHEMES$1, null);
-  function getSchemeHandler$1(scheme) {
-    return scheme && (SCHEMES$1[
-      /** @type {SchemeName} */
-      scheme
-    ] || SCHEMES$1[
-      /** @type {SchemeName} */
-      scheme.toLowerCase()
-    ]) || void 0;
-  }
-  var schemes = {
-    SCHEMES: SCHEMES$1,
-    getSchemeHandler: getSchemeHandler$1
+    return uriComponents;
+  }
+  function urnuuidParse(urnComponents, options) {
+    const uuidComponents = urnComponents;
+    uuidComponents.uuid = uuidComponents.nss;
+    uuidComponents.nss = void 0;
+    if (!options.tolerant && (!uuidComponents.uuid || !UUID_REG.test(uuidComponents.uuid))) {
+      uuidComponents.error = uuidComponents.error || "UUID is not valid.";
+    }
+    return uuidComponents;
+  }
+  function urnuuidSerialize(uuidComponents) {
+    const urnComponents = uuidComponents;
+    urnComponents.nss = (uuidComponents.uuid || "").toLowerCase();
+    return urnComponents;
+  }
+  const http = {
+    scheme: "http",
+    domainHost: true,
+    parse: httpParse,
+    serialize: httpSerialize
+  };
+  const https = {
+    scheme: "https",
+    domainHost: http.domainHost,
+    parse: httpParse,
+    serialize: httpSerialize
+  };
+  const ws = {
+    scheme: "ws",
+    domainHost: true,
+    parse: wsParse,
+    serialize: wsSerialize
+  };
+  const wss = {
+    scheme: "wss",
+    domainHost: ws.domainHost,
+    parse: ws.parse,
+    serialize: ws.serialize
   };
-  const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = utils;
-  const { SCHEMES, getSchemeHandler } = schemes;
+  const urn = {
+    scheme: "urn",
+    parse: urnParse,
+    serialize: urnSerialize,
+    skipNormalize: true
+  };
+  const urnuuid = {
+    scheme: "urn:uuid",
+    parse: urnuuidParse,
+    serialize: urnuuidSerialize,
+    skipNormalize: true
+  };
+  const SCHEMES$1 = {
+    http,
+    https,
+    ws,
+    wss,
+    urn,
+    "urn:uuid": urnuuid
+  };
+  var schemes = SCHEMES$1;
+  const { normalizeIPv6, normalizeIPv4, removeDotSegments, recomposeAuthority, normalizeComponentEncoding } = utils;
+  const SCHEMES = schemes;
   function normalize(uri2, options) {
     if (typeof uri2 === "string") {
-      uri2 = /** @type {T} */
-      serialize(parse(uri2, options), options);
+      uri2 = serialize(parse(uri2, options), options);
     } else if (typeof uri2 === "object") {
-      uri2 = /** @type {T} */
-      parse(serialize(uri2, options), options);
+      uri2 = parse(serialize(uri2, options), options);
     }
     return uri2;
   }
   function resolve$4(baseURI, relativeURI, options) {
-    const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
-    schemelessOptions.skipEscape = true;
-    return serialize(resolved, schemelessOptions);
+    const schemelessOptions = Object.assign({ scheme: "null" }, options);
+    const resolved = resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+    return serialize(resolved, { ...schemelessOptions, skipEscape: true });
   }
-  function resolveComponent(base, relative, options, skipNormalization) {
+  function resolveComponents(base, relative, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
       base = parse(serialize(base, options), options);
@@ -3487,7 +3404,7 @@
             target.query = base.query;
           }
         } else {
-          if (relative.path[0] === "/") {
+          if (relative.path.charAt(0) === "/") {
             target.path = removeDotSegments(relative.path);
           } else {
             if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
@@ -3526,7 +3443,7 @@
     return uriA.toLowerCase() === uriB.toLowerCase();
   }
   function serialize(cmpts, opts) {
-    const component = {
+    const components = {
       host: cmpts.host,
       scheme: cmpts.scheme,
       userinfo: cmpts.userinfo,
@@ -3544,49 +3461,60 @@
     };
     const options = Object.assign({}, opts);
     const uriTokens = [];
-    const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
-    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
-    if (component.path !== void 0) {
+    const schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
+    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);
+    if (components.path !== void 0) {
       if (!options.skipEscape) {
-        component.path = escape(component.path);
-        if (component.scheme !== void 0) {
-          component.path = component.path.split("%3A").join(":");
+        components.path = escape(components.path);
+        if (components.scheme !== void 0) {
+          components.path = components.path.split("%3A").join(":");
         }
       } else {
-        component.path = unescape(component.path);
+        components.path = unescape(components.path);
       }
     }
-    if (options.reference !== "suffix" && component.scheme) {
-      uriTokens.push(component.scheme, ":");
+    if (options.reference !== "suffix" && components.scheme) {
+      uriTokens.push(components.scheme, ":");
     }
-    const authority = recomposeAuthority(component);
+    const authority = recomposeAuthority(components);
     if (authority !== void 0) {
       if (options.reference !== "suffix") {
         uriTokens.push("//");
       }
       uriTokens.push(authority);
-      if (component.path && component.path[0] !== "/") {
+      if (components.path && components.path.charAt(0) !== "/") {
         uriTokens.push("/");
       }
     }
-    if (component.path !== void 0) {
-      let s = component.path;
+    if (components.path !== void 0) {
+      let s = components.path;
       if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
         s = removeDotSegments(s);
       }
-      if (authority === void 0 && s[0] === "/" && s[1] === "/") {
-        s = "/%2F" + s.slice(2);
+      if (authority === void 0) {
+        s = s.replace(/^\/\//u, "/%2F");
       }
       uriTokens.push(s);
     }
-    if (component.query !== void 0) {
-      uriTokens.push("?", component.query);
+    if (components.query !== void 0) {
+      uriTokens.push("?", components.query);
     }
-    if (component.fragment !== void 0) {
-      uriTokens.push("#", component.fragment);
+    if (components.fragment !== void 0) {
+      uriTokens.push("#", components.fragment);
     }
     return uriTokens.join("");
   }
+  const hexLookUp = Array.from({ length: 127 }, (_v, k) => /[^!"$&'()*+,\-.;=_`a-z{}~]/u.test(String.fromCharCode(k)));
+  function nonSimpleDomain(value) {
+    let code2 = 0;
+    for (let i = 0, len = value.length; i < len; ++i) {
+      code2 = value.charCodeAt(i);
+      if (code2 > 126 || hexLookUp[code2]) {
+        return true;
+      }
+    }
+    return false;
+  }
   const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
   function parse(uri2, opts) {
     const options = Object.assign({}, opts);
@@ -3599,14 +3527,9 @@
       query: void 0,
       fragment: void 0
     };
+    const gotEncoding = uri2.indexOf("%") !== -1;
     let isIP = false;
-    if (options.reference === "suffix") {
-      if (options.scheme) {
-        uri2 = options.scheme + ":" + uri2;
-      } else {
-        uri2 = "//" + uri2;
-      }
-    }
+    if (options.reference === "suffix") uri2 = (options.scheme ? options.scheme + ":" : "") + "//" + uri2;
     const matches = uri2.match(URI_PARSE);
     if (matches) {
       parsed.scheme = matches[1];
@@ -3620,12 +3543,13 @@
         parsed.port = matches[5];
       }
       if (parsed.host) {
-        const ipv4result = isIPv4(parsed.host);
-        if (ipv4result === false) {
-          const ipv6result = normalizeIPv6(parsed.host);
+        const ipv4result = normalizeIPv4(parsed.host);
+        if (ipv4result.isIPV4 === false) {
+          const ipv6result = normalizeIPv6(ipv4result.host);
           parsed.host = ipv6result.host.toLowerCase();
           isIP = ipv6result.isIPV6;
         } else {
+          parsed.host = ipv4result.host;
           isIP = true;
         }
       }
@@ -3641,7 +3565,7 @@
       if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) {
         parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
       }
-      const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
+      const schemeHandler = SCHEMES[(options.scheme || parsed.scheme || "").toLowerCase()];
       if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
         if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
           try {
@@ -3652,13 +3576,11 @@
         }
       }
       if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-        if (uri2.indexOf("%") !== -1) {
-          if (parsed.scheme !== void 0) {
-            parsed.scheme = unescape(parsed.scheme);
-          }
-          if (parsed.host !== void 0) {
-            parsed.host = unescape(parsed.host);
-          }
+        if (gotEncoding && parsed.scheme !== void 0) {
+          parsed.scheme = unescape(parsed.scheme);
+        }
+        if (gotEncoding && parsed.host !== void 0) {
+          parsed.host = unescape(parsed.host);
         }
         if (parsed.path) {
           parsed.path = escape(unescape(parsed.path));
@@ -3679,7 +3601,7 @@
     SCHEMES,
     normalize,
     resolve: resolve$4,
-    resolveComponent,
+    resolveComponents,
     equal: equal$4,
     serialize,
     parse
@@ -3695,7 +3617,7 @@
   (function(exports3) {
     Object.defineProperty(exports3, "__esModule", { value: true });
     exports3.CodeGen = exports3.Name = exports3.nil = exports3.stringify = exports3.str = exports3._ = exports3.KeywordCxt = void 0;
-    var validate_12 = requireValidate();
+    var validate_12 = validate$2;
     Object.defineProperty(exports3, "KeywordCxt", { enumerable: true, get: function() {
       return validate_12.KeywordCxt;
     } });
@@ -3718,7 +3640,7 @@
     Object.defineProperty(exports3, "CodeGen", { enumerable: true, get: function() {
       return codegen_12.CodeGen;
     } });
-    const validation_error_12 = requireValidation_error();
+    const validation_error_12 = validation_error;
     const ref_error_12 = ref_error;
     const rules_12 = rules$2;
     const compile_12 = compile$2;
@@ -5297,7 +5219,7 @@
   additionalProperties$1.default = def$a;
   var properties$4 = {};
   Object.defineProperty(properties$4, "__esModule", { value: true });
-  const validate_1 = requireValidate();
+  const validate_1 = validate$2;
   const code_1$2 = code;
   const util_1$7 = util$7;
   const additionalProperties_1$1 = additionalProperties$1;
@@ -6148,7 +6070,7 @@
     module2.exports.Ajv = Ajv2;
     Object.defineProperty(exports3, "__esModule", { value: true });
     exports3.default = Ajv2;
-    var validate_12 = requireValidate();
+    var validate_12 = validate$2;
     Object.defineProperty(exports3, "KeywordCxt", { enumerable: true, get: function() {
       return validate_12.KeywordCxt;
     } });
@@ -6171,7 +6093,7 @@
     Object.defineProperty(exports3, "CodeGen", { enumerable: true, get: function() {
       return codegen_12.CodeGen;
     } });
-    var validation_error_12 = requireValidation_error();
+    var validation_error_12 = validation_error;
     Object.defineProperty(exports3, "ValidationError", { enumerable: true, get: function() {
       return validation_error_12.default;
     } });
@@ -9921,10 +9843,14 @@
   ZodPromise.create;
   const optionalType = ZodOptional.create;
   ZodNullable.create;
-  const NEVER = INVALID;
   const LATEST_PROTOCOL_VERSION = "2025-06-18";
   const DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
-  const SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-03-26", "2024-11-05", "2024-10-07"];
+  const SUPPORTED_PROTOCOL_VERSIONS = [
+    LATEST_PROTOCOL_VERSION,
+    "2025-03-26",
+    "2024-11-05",
+    "2024-10-07"
+  ];
   const JSONRPC_VERSION = "2.0";
   const ProgressTokenSchema = unionType([stringType(), numberType().int()]);
   const CursorSchema = stringType();
@@ -10004,7 +9930,12 @@
     })
   }).strict();
   const isJSONRPCError = (value) => JSONRPCErrorSchema.safeParse(value).success;
-  const JSONRPCMessageSchema = unionType([JSONRPCRequestSchema, JSONRPCNotificationSchema, JSONRPCResponseSchema, JSONRPCErrorSchema]);
+  const JSONRPCMessageSchema = unionType([
+    JSONRPCRequestSchema,
+    JSONRPCNotificationSchema,
+    JSONRPCResponseSchema,
+    JSONRPCErrorSchema
+  ]);
   const EmptyResultSchema = ResultSchema.strict();
   const CancelledNotificationSchema = NotificationSchema.extend({
     method: literalType("notifications/cancelled"),
@@ -10021,57 +9952,22 @@
       reason: stringType().optional()
     })
   });
-  const IconSchema = objectType({
-    /**
-     * URL or data URI for the icon.
-     */
-    src: stringType(),
-    /**
-     * Optional MIME type for the icon.
-     */
-    mimeType: optionalType(stringType()),
-    /**
-     * Optional array of strings that specify sizes at which the icon can be used.
-     * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
-     *
-     * If not provided, the client should assume that the icon can be used at any size.
-     */
-    sizes: optionalType(arrayType(stringType()))
-  }).passthrough();
-  const IconsSchema = objectType({
-    /**
-     * Optional set of sized icons that the client can display in a user interface.
-     *
-     * Clients that support rendering icons MUST support at least the following MIME types:
-     * - `image/png` - PNG images (safe, universal compatibility)
-     * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
-     *
-     * Clients that support rendering icons SHOULD also support:
-     * - `image/svg+xml` - SVG images (scalable but requires security precautions)
-     * - `image/webp` - WebP images (modern, efficient format)
-     */
-    icons: arrayType(IconSchema).optional()
-  }).passthrough();
   const BaseMetadataSchema = objectType({
     /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
     name: stringType(),
     /**
-     * Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
-     * even by those unfamiliar with domain-specific terminology.
-     *
-     * If not provided, the name should be used for display (except for Tool,
-     * where `annotations.title` should be given precedence over using `name`,
-     * if present).
-     */
+    * Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
+    * even by those unfamiliar with domain-specific terminology.
+    *
+    * If not provided, the name should be used for display (except for Tool,
+    * where `annotations.title` should be given precedence over using `name`,
+    * if present).
+    */
     title: optionalType(stringType())
   }).passthrough();
   const ImplementationSchema = BaseMetadataSchema.extend({
-    version: stringType(),
-    /**
-     * An optional URL of the website for this implementation.
-     */
-    websiteUrl: optionalType(stringType())
-  }).merge(IconsSchema);
+    version: stringType()
+  });
   const ClientCapabilitiesSchema = objectType({
     /**
      * Experimental, non-standard capabilities that the client supports.
@@ -10267,7 +10163,7 @@
      * for notes on _meta usage.
      */
     _meta: optionalType(objectType({}).passthrough())
-  }).merge(IconsSchema);
+  });
   const ResourceTemplateSchema = BaseMetadataSchema.extend({
     /**
      * A URI template (according to RFC 6570) that can be used to construct resource URIs.
@@ -10288,7 +10184,7 @@
      * for notes on _meta usage.
      */
     _meta: optionalType(objectType({}).passthrough())
-  }).merge(IconsSchema);
+  });
   const ListResourcesRequestSchema = PaginatedRequestSchema.extend({
     method: literalType("resources/list")
   });
@@ -10371,7 +10267,7 @@
      * for notes on _meta usage.
      */
     _meta: optionalType(objectType({}).passthrough())
-  }).merge(IconsSchema);
+  });
   const ListPromptsRequestSchema = PaginatedRequestSchema.extend({
     method: literalType("prompts/list")
   });
@@ -10538,7 +10434,7 @@
      * for notes on _meta usage.
      */
     _meta: optionalType(objectType({}).passthrough())
-  }).merge(IconsSchema);
+  });
   const ListToolsRequestSchema = PaginatedRequestSchema.extend({
     method: literalType("tools/list")
   });
@@ -10588,7 +10484,16 @@
   const ToolListChangedNotificationSchema = NotificationSchema.extend({
     method: literalType("notifications/tools/list_changed")
   });
-  const LoggingLevelSchema = enumType(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
+  const LoggingLevelSchema = enumType([
+    "debug",
+    "info",
+    "notice",
+    "warning",
+    "error",
+    "critical",
+    "alert",
+    "emergency"
+  ]);
   const SetLevelRequestSchema = RequestSchema.extend({
     method: literalType("logging/setLevel"),
     params: BaseRequestParamsSchema.extend({
@@ -10681,7 +10586,11 @@
      */
     stopReason: optionalType(enumType(["endTurn", "stopSequence", "maxTokens"]).or(stringType())),
     role: enumType(["user", "assistant"]),
-    content: discriminatedUnionType("type", [TextContentSchema, ImageContentSchema, AudioContentSchema])
+    content: discriminatedUnionType("type", [
+      TextContentSchema,
+      ImageContentSchema,
+      AudioContentSchema
+    ])
   });
   const BooleanSchemaSchema = objectType({
     type: literalType("boolean"),
@@ -10711,7 +10620,12 @@
     enum: arrayType(stringType()),
     enumNames: optionalType(arrayType(stringType()))
   }).passthrough();
-  const PrimitiveSchemaDefinitionSchema = unionType([BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema, EnumSchemaSchema]);
+  const PrimitiveSchemaDefinitionSchema = unionType([
+    BooleanSchemaSchema,
+    StringSchemaSchema,
+    NumberSchemaSchema,
+    EnumSchemaSchema
+  ]);
   const ElicitRequestSchema = RequestSchema.extend({
     method: literalType("elicitation/create"),
     params: BaseRequestParamsSchema.extend({
@@ -10840,8 +10754,18 @@
     InitializedNotificationSchema,
     RootsListChangedNotificationSchema
   ]);
-  const ClientResultSchema = unionType([EmptyResultSchema, CreateMessageResultSchema, ElicitResultSchema, ListRootsResultSchema]);
-  const ServerRequestSchema = unionType([PingRequestSchema, CreateMessageRequestSchema, ElicitRequestSchema, ListRootsRequestSchema]);
+  const ClientResultSchema = unionType([
+    EmptyResultSchema,
+    CreateMessageResultSchema,
+    ElicitResultSchema,
+    ListRootsResultSchema
+  ]);
+  const ServerRequestSchema = unionType([
+    PingRequestSchema,
+    CreateMessageRequestSchema,
+    ElicitRequestSchema,
+    ListRootsRequestSchema
+  ]);
   const ServerNotificationSchema = unionType([
     CancelledNotificationSchema,
     ProgressNotificationSchema,
@@ -11199,10 +11123,7 @@
       const totalElapsed = Date.now() - info.startTime;
       if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
         this._timeoutInfo.delete(messageId);
-        throw new McpError(exports2.ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
-          maxTotalTimeout: info.maxTotalTimeout,
-          totalElapsed
-        });
+        throw new McpError(exports2.ErrorCode.RequestTimeout, "Maximum total timeout exceeded", { maxTotalTimeout: info.maxTotalTimeout, totalElapsed });
       }
       clearTimeout(info.timeoutId);
       info.timeoutId = setTimeout(info.onTimeout, info.timeout);
@@ -11274,11 +11195,10 @@
       Promise.resolve().then(() => handler(notification)).catch((error2) => this._onerror(new Error(`Uncaught error in notification handler: ${error2}`)));
     }
     _onrequest(request, extra) {
-      var _a, _b;
+      var _a, _b, _c, _d;
       const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== void 0 ? _a : this.fallbackRequestHandler;
-      const capturedTransport = this._transport;
       if (handler === void 0) {
-        capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+        (_b = this._transport) === null || _b === void 0 ? void 0 : _b.send({
           jsonrpc: "2.0",
           id: request.id,
           error: {
@@ -11292,8 +11212,8 @@
       this._requestHandlerAbortControllers.set(request.id, abortController);
       const fullExtra = {
         signal: abortController.signal,
-        sessionId: capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId,
-        _meta: (_b = request.params) === null || _b === void 0 ? void 0 : _b._meta,
+        sessionId: (_c = this._transport) === null || _c === void 0 ? void 0 : _c.sessionId,
+        _meta: (_d = request.params) === null || _d === void 0 ? void 0 : _d._meta,
         sendNotification: (notification) => this.notification(notification, { relatedRequestId: request.id }),
         sendRequest: (r, resultSchema, options) => this.request(r, resultSchema, { ...options, relatedRequestId: request.id }),
         authInfo: extra === null || extra === void 0 ? void 0 : extra.authInfo,
@@ -11301,25 +11221,26 @@
         requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo
       };
       Promise.resolve().then(() => handler(request, fullExtra)).then((result) => {
+        var _a2;
         if (abortController.signal.aborted) {
           return;
         }
-        return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+        return (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send({
           result,
           jsonrpc: "2.0",
           id: request.id
         });
       }, (error2) => {
-        var _a2;
+        var _a2, _b2;
         if (abortController.signal.aborted) {
           return;
         }
-        return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+        return (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send({
           jsonrpc: "2.0",
           id: request.id,
           error: {
             code: Number.isSafeInteger(error2["code"]) ? error2["code"] : exports2.ErrorCode.InternalError,
-            message: (_a2 = error2.message) !== null && _a2 !== void 0 ? _a2 : "Internal error"
+            message: (_b2 = error2.message) !== null && _b2 !== void 0 ? _b2 : "Internal error"
           }
         });
       }).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => {
@@ -12150,24 +12071,24 @@
         }
         return uriTokens.length ? uriTokens.join("") : void 0;
       }
-      var RDS1 = /^\.\.?\//;
-      var RDS2 = /^\/\.(\/|$)/;
-      var RDS3 = /^\/\.\.(\/|$)/;
-      var RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/;
+      var RDS12 = /^\.\.?\//;
+      var RDS22 = /^\/\.(\/|$)/;
+      var RDS32 = /^\/\.\.(\/|$)/;
+      var RDS52 = /^\/?(?:.|\n)*?(?=\/|$)/;
       function removeDotSegments2(input) {
         var output = [];
         while (input.length) {
-          if (input.match(RDS1)) {
-            input = input.replace(RDS1, "");
-          } else if (input.match(RDS2)) {
-            input = input.replace(RDS2, "/");
-          } else if (input.match(RDS3)) {
-            input = input.replace(RDS3, "/");
+          if (input.match(RDS12)) {
+            input = input.replace(RDS12, "");
+          } else if (input.match(RDS22)) {
+            input = input.replace(RDS22, "/");
+          } else if (input.match(RDS32)) {
+            input = input.replace(RDS32, "/");
             output.pop();
           } else if (input === "." || input === "..") {
             input = "";
           } else {
-            var im = input.match(RDS5);
+            var im = input.match(RDS52);
             if (im) {
               var s = im[0];
               input = input.slice(s.length);
@@ -12230,7 +12151,7 @@
         }
         return uriTokens.join("");
       }
-      function resolveComponents(base2, relative) {
+      function resolveComponents2(base2, relative) {
         var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
         var skipNormalization = arguments[3];
         var target = {};
@@ -12287,7 +12208,7 @@
       }
       function resolve2(baseURI, relativeURI, options) {
         var schemelessOptions = assign({ scheme: "null" }, options);
-        return serialize2(resolveComponents(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
+        return serialize2(resolveComponents2(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
       }
       function normalize2(uri2, options) {
         if (typeof uri2 === "string") {
@@ -12342,7 +12263,7 @@
         parse: handler.parse,
         serialize: handler.serialize
       };
-      function isSecure(wsComponents) {
+      function isSecure2(wsComponents) {
         return typeof wsComponents.secure === "boolean" ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
       }
       var handler$2 = {
@@ -12350,14 +12271,14 @@
         domainHost: true,
         parse: function parse3(components, options) {
           var wsComponents = components;
-          wsComponents.secure = isSecure(wsComponents);
+          wsComponents.secure = isSecure2(wsComponents);
           wsComponents.resourceName = (wsComponents.path || "/") + (wsComponents.query ? "?" + wsComponents.query : "");
           wsComponents.path = void 0;
           wsComponents.query = void 0;
           return wsComponents;
         },
         serialize: function serialize3(wsComponents, options) {
-          if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") {
+          if (wsComponents.port === (isSecure2(wsComponents) ? 443 : 80) || wsComponents.port === "") {
             wsComponents.port = void 0;
           }
           if (typeof wsComponents.secure === "boolean") {
@@ -12548,7 +12469,7 @@
       exports4.parse = parse2;
       exports4.removeDotSegments = removeDotSegments2;
       exports4.serialize = serialize2;
-      exports4.resolveComponents = resolveComponents;
+      exports4.resolveComponents = resolveComponents2;
       exports4.resolve = resolve2;
       exports4.normalize = normalize2;
       exports4.equal = equal2;
@@ -17749,22 +17670,9 @@
       code_challenge: challenge
     };
   }
-  const SafeUrlSchema = stringType().url().superRefine((val, ctx) => {
-    if (!URL.canParse(val)) {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: "URL must be parseable",
-        fatal: true
-      });
-      return NEVER;
-    }
-  }).refine((url) => {
-    const u = new URL(url);
-    return u.protocol !== "javascript:" && u.protocol !== "data:" && u.protocol !== "vbscript:";
-  }, { message: "URL cannot use javascript:, data:, or vbscript: scheme" });
   const OAuthProtectedResourceMetadataSchema = objectType({
     resource: stringType().url(),
-    authorization_servers: arrayType(SafeUrlSchema).optional(),
+    authorization_servers: arrayType(stringType().url()).optional(),
     jwks_uri: stringType().url().optional(),
     scopes_supported: arrayType(stringType()).optional(),
     bearer_methods_supported: arrayType(stringType()).optional(),
@@ -17780,17 +17688,17 @@
   }).passthrough();
   const OAuthMetadataSchema = objectType({
     issuer: stringType(),
-    authorization_endpoint: SafeUrlSchema,
-    token_endpoint: SafeUrlSchema,
-    registration_endpoint: SafeUrlSchema.optional(),
+    authorization_endpoint: stringType(),
+    token_endpoint: stringType(),
+    registration_endpoint: stringType().optional(),
     scopes_supported: arrayType(stringType()).optional(),
     response_types_supported: arrayType(stringType()),
     response_modes_supported: arrayType(stringType()).optional(),
     grant_types_supported: arrayType(stringType()).optional(),
     token_endpoint_auth_methods_supported: arrayType(stringType()).optional(),
     token_endpoint_auth_signing_alg_values_supported: arrayType(stringType()).optional(),
-    service_documentation: SafeUrlSchema.optional(),
-    revocation_endpoint: SafeUrlSchema.optional(),
+    service_documentation: stringType().optional(),
+    revocation_endpoint: stringType().optional(),
     revocation_endpoint_auth_methods_supported: arrayType(stringType()).optional(),
     revocation_endpoint_auth_signing_alg_values_supported: arrayType(stringType()).optional(),
     introspection_endpoint: stringType().optional(),
@@ -17800,11 +17708,11 @@
   }).passthrough();
   const OpenIdProviderMetadataSchema = objectType({
     issuer: stringType(),
-    authorization_endpoint: SafeUrlSchema,
-    token_endpoint: SafeUrlSchema,
-    userinfo_endpoint: SafeUrlSchema.optional(),
-    jwks_uri: SafeUrlSchema,
-    registration_endpoint: SafeUrlSchema.optional(),
+    authorization_endpoint: stringType(),
+    token_endpoint: stringType(),
+    userinfo_endpoint: stringType().optional(),
+    jwks_uri: stringType(),
+    registration_endpoint: stringType().optional(),
     scopes_supported: arrayType(stringType()).optional(),
     response_types_supported: arrayType(stringType()),
     response_modes_supported: arrayType(stringType()).optional(),
@@ -17832,8 +17740,8 @@
     request_parameter_supported: booleanType().optional(),
     request_uri_parameter_supported: booleanType().optional(),
     require_request_uri_registration: booleanType().optional(),
-    op_policy_uri: SafeUrlSchema.optional(),
-    op_tos_uri: SafeUrlSchema.optional()
+    op_policy_uri: stringType().optional(),
+    op_tos_uri: stringType().optional()
   }).passthrough();
   const OpenIdProviderDiscoveryMetadataSchema = OpenIdProviderMetadataSchema.merge(OAuthMetadataSchema.pick({
     code_challenge_methods_supported: true
@@ -17852,20 +17760,19 @@
     error_description: stringType().optional(),
     error_uri: stringType().optional()
   });
-  const OptionalSafeUrlSchema = SafeUrlSchema.optional().or(literalType("").transform(() => void 0));
   const OAuthClientMetadataSchema = objectType({
-    redirect_uris: arrayType(SafeUrlSchema),
+    redirect_uris: arrayType(stringType()).refine((uris) => uris.every((uri2) => URL.canParse(uri2)), { message: "redirect_uris must contain valid URLs" }),
     token_endpoint_auth_method: stringType().optional(),
     grant_types: arrayType(stringType()).optional(),
     response_types: arrayType(stringType()).optional(),
     client_name: stringType().optional(),
-    client_uri: SafeUrlSchema.optional(),
-    logo_uri: OptionalSafeUrlSchema,
+    client_uri: stringType().optional(),
+    logo_uri: stringType().optional(),
     scope: stringType().optional(),
     contacts: arrayType(stringType()).optional(),
-    tos_uri: OptionalSafeUrlSchema,
+    tos_uri: stringType().optional(),
     policy_uri: stringType().optional(),
-    jwks_uri: SafeUrlSchema.optional(),
+    jwks_uri: stringType().optional(),
     jwks: anyType().optional(),
     software_id: stringType().optional(),
     software_version: stringType().optional(),
@@ -17998,8 +17905,6 @@
       super(message !== null && message !== void 0 ? message : "Unauthorized");
     }
   }
-  const AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
-  const AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
   function selectClientAuthMethod(clientInformation, supportedMethods) {
     const hasClientSecret = clientInformation.client_secret !== void 0;
     if (supportedMethods.length === 0) {
@@ -18103,8 +18008,7 @@
       }
       const fullInformation = await registerClient(authorizationServerUrl, {
         metadata: metadata2,
-        clientMetadata: provider.clientMetadata,
-        fetchFn
+        clientMetadata: provider.clientMetadata
       });
       await provider.saveClientInformation(fullInformation);
       clientInformation = fullInformation;
@@ -18132,8 +18036,7 @@
           clientInformation,
           refreshToken: tokens.refresh_token,
           resource,
-          addClientAuthentication: provider.addClientAuthentication,
-          fetchFn
+          addClientAuthentication: provider.addClientAuthentication
         });
         await provider.saveTokens(newTokens);
         return "AUTHORIZED";
@@ -18230,7 +18133,7 @@
     return await fetchWithCorsRetry(url, headers, fetchFn);
   }
   function shouldAttemptFallback(response, pathname) {
-    return !response || response.status >= 400 && response.status < 500 && pathname !== "/";
+    return !response || response.status === 404 && pathname !== "/";
   }
   async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
     var _a, _b;
@@ -18312,15 +18215,13 @@
     return urlsToTry;
   }
   async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = LATEST_PROTOCOL_VERSION } = {}) {
-    const headers = {
-      "MCP-Protocol-Version": protocolVersion,
-      Accept: "application/json"
-    };
+    var _a;
+    const headers = { "MCP-Protocol-Version": protocolVersion };
     const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
     for (const { url: endpointUrl, type: type2 } of urlsToTry) {
       const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
       if (!response) {
-        continue;
+        throw new Error(`CORS error trying to load ${type2 === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
       }
       if (!response.ok) {
         if (response.status >= 400 && response.status < 500) {
@@ -18331,20 +18232,26 @@
       if (type2 === "oauth") {
         return OAuthMetadataSchema.parse(await response.json());
       } else {
-        return OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
+        const metadata2 = OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
+        if (!((_a = metadata2.code_challenge_methods_supported) === null || _a === void 0 ? void 0 : _a.includes("S256"))) {
+          throw new Error(`Incompatible OIDC provider at ${endpointUrl}: does not support S256 code challenge method required by MCP specification`);
+        }
+        return metadata2;
       }
     }
     return void 0;
   }
   async function startAuthorization(authorizationServerUrl, { metadata: metadata2, clientInformation, redirectUrl, scope: scope2, state, resource }) {
+    const responseType = "code";
+    const codeChallengeMethod = "S256";
     let authorizationUrl;
     if (metadata2) {
       authorizationUrl = new URL(metadata2.authorization_endpoint);
-      if (!metadata2.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE)) {
-        throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`);
+      if (!metadata2.response_types_supported.includes(responseType)) {
+        throw new Error(`Incompatible auth server: does not support response type ${responseType}`);
       }
-      if (metadata2.code_challenge_methods_supported && !metadata2.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD)) {
-        throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`);
+      if (!metadata2.code_challenge_methods_supported || !metadata2.code_challenge_methods_supported.includes(codeChallengeMethod)) {
+        throw new Error(`Incompatible auth server: does not support code challenge method ${codeChallengeMethod}`);
       }
     } else {
       authorizationUrl = new URL("/authorize", authorizationServerUrl);
@@ -18352,10 +18259,10 @@
     const challenge = await pkceChallenge();
     const codeVerifier = challenge.code_verifier;
     const codeChallenge = challenge.code_challenge;
-    authorizationUrl.searchParams.set("response_type", AUTHORIZATION_CODE_RESPONSE_TYPE);
+    authorizationUrl.searchParams.set("response_type", responseType);
     authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
     authorizationUrl.searchParams.set("code_challenge", codeChallenge);
-    authorizationUrl.searchParams.set("code_challenge_method", AUTHORIZATION_CODE_CHALLENGE_METHOD);
+    authorizationUrl.searchParams.set("code_challenge_method", codeChallengeMethod);
     authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
     if (state) {
       authorizationUrl.searchParams.set("state", state);
@@ -18380,7 +18287,7 @@
     }
     const headers = new Headers({
       "Content-Type": "application/x-www-form-urlencoded",
-      Accept: "application/json"
+      "Accept": "application/json"
     });
     const params = new URLSearchParams({
       grant_type: grantType,
@@ -18559,7 +18466,7 @@
       const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
 `, searchIndex);
       let lineEnd = -1;
-      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
         incompleteLine = chunk.slice(searchIndex);
         break;
       } else {
@@ -18860,11 +18767,7 @@
       }
       let result;
       try {
-        result = await auth(this._authProvider, {
-          serverUrl: this._url,
-          resourceMetadataUrl: this._resourceMetadataUrl,
-          fetchFn: this._fetch
-        });
+        result = await auth(this._authProvider, { serverUrl: this._url, resourceMetadataUrl: this._resourceMetadataUrl, fetchFn: this._fetch });
       } catch (error2) {
         (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error2);
         throw error2;
@@ -18963,12 +18866,7 @@
       if (!this._authProvider) {
         throw new UnauthorizedError("No auth provider");
       }
-      const result = await auth(this._authProvider, {
-        serverUrl: this._url,
-        authorizationCode,
-        resourceMetadataUrl: this._resourceMetadataUrl,
-        fetchFn: this._fetch
-      });
+      const result = await auth(this._authProvider, { serverUrl: this._url, authorizationCode, resourceMetadataUrl: this._resourceMetadataUrl, fetchFn: this._fetch });
       if (result !== "AUTHORIZED") {
         throw new UnauthorizedError("Failed to authorize");
       }
@@ -18998,11 +18896,7 @@
         if (!response.ok) {
           if (response.status === 401 && this._authProvider) {
             this._resourceMetadataUrl = extractResourceMetadataUrl(response);
-            const result = await auth(this._authProvider, {
-              serverUrl: this._url,
-              resourceMetadataUrl: this._resourceMetadataUrl,
-              fetchFn: this._fetch
-            });
+            const result = await auth(this._authProvider, { serverUrl: this._url, resourceMetadataUrl: this._resourceMetadataUrl, fetchFn: this._fetch });
             if (result !== "AUTHORIZED") {
               throw new UnauthorizedError();
             }
@@ -19057,7 +18951,6 @@
   class StreamableHTTPClientTransport {
     constructor(url, opts) {
       var _a;
-      this._hasCompletedAuthFlow = false;
       this._url = url;
       this._resourceMetadataUrl = void 0;
       this._requestInit = opts === null || opts === void 0 ? void 0 : opts.requestInit;
@@ -19073,11 +18966,7 @@
       }
       let result;
       try {
-        result = await auth(this._authProvider, {
-          serverUrl: this._url,
-          resourceMetadataUrl: this._resourceMetadataUrl,
-          fetchFn: this._fetch
-        });
+        result = await auth(this._authProvider, { serverUrl: this._url, resourceMetadataUrl: this._resourceMetadataUrl, fetchFn: this._fetch });
       } catch (error2) {
         (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error2);
         throw error2;
@@ -19243,12 +19132,7 @@
       if (!this._authProvider) {
         throw new UnauthorizedError("No auth provider");
       }
-      const result = await auth(this._authProvider, {
-        serverUrl: this._url,
-        authorizationCode,
-        resourceMetadataUrl: this._resourceMetadataUrl,
-        fetchFn: this._fetch
-      });
+      const result = await auth(this._authProvider, { serverUrl: this._url, authorizationCode, resourceMetadataUrl: this._resourceMetadataUrl, fetchFn: this._fetch });
       if (result !== "AUTHORIZED") {
         throw new UnauthorizedError("Failed to authorize");
       }
@@ -19286,25 +19170,16 @@
         }
         if (!response.ok) {
           if (response.status === 401 && this._authProvider) {
-            if (this._hasCompletedAuthFlow) {
-              throw new StreamableHTTPError(401, "Server returned 401 after successful authentication");
-            }
             this._resourceMetadataUrl = extractResourceMetadataUrl(response);
-            const result = await auth(this._authProvider, {
-              serverUrl: this._url,
-              resourceMetadataUrl: this._resourceMetadataUrl,
-              fetchFn: this._fetch
-            });
+            const result = await auth(this._authProvider, { serverUrl: this._url, resourceMetadataUrl: this._resourceMetadataUrl, fetchFn: this._fetch });
             if (result !== "AUTHORIZED") {
               throw new UnauthorizedError();
             }
-            this._hasCompletedAuthFlow = true;
             return this.send(message);
           }
           const text = await response.text().catch(() => null);
           throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`);
         }
-        this._hasCompletedAuthFlow = false;
         if (response.status === 202) {
           if (isInitializedNotification(message)) {
             this._startOrAuthSse({ resumptionToken: void 0 }).catch((err) => {
@@ -19387,12 +19262,6 @@
       var _a;
       super(options);
       this._serverInfo = _serverInfo;
-      this._loggingLevels = /* @__PURE__ */ new Map();
-      this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
-      this.isMessageIgnored = (level, sessionId) => {
-        const currentLevel = this._loggingLevels.get(sessionId);
-        return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
-      };
       this._capabilities = (_a = options === null || options === void 0 ? void 0 : options.capabilities) !== null && _a !== void 0 ? _a : {};
       this._instructions = options === null || options === void 0 ? void 0 : options.instructions;
       this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
@@ -19400,18 +19269,6 @@
         var _a2;
         return (_a2 = this.oninitialized) === null || _a2 === void 0 ? void 0 : _a2.call(this);
       });
-      if (this._capabilities.logging) {
-        this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
-          var _a2;
-          const transportSessionId = extra.sessionId || ((_a2 = extra.requestInfo) === null || _a2 === void 0 ? void 0 : _a2.headers["mcp-session-id"]) || void 0;
-          const { level } = request.params;
-          const parseResult = LoggingLevelSchema.safeParse(level);
-          if (parseResult.success) {
-            this._loggingLevels.set(transportSessionId, parseResult.data);
-          }
-          return {};
-        });
-      }
     }
     /**
      * Registers new capabilities. This can only be called before connecting to a transport.
@@ -19557,19 +19414,8 @@
     async listRoots(params, options) {
       return this.request({ method: "roots/list", params }, ListRootsResultSchema, options);
     }
-    /**
-     * Sends a logging message to the client, if connected.
-     * Note: You only need to send the parameters object, not the entire JSON RPC message
-     * @see LoggingMessageNotification
-     * @param params
-     * @param sessionId optional for stateless and backward compatibility
-     */
-    async sendLoggingMessage(params, sessionId) {
-      if (this._capabilities.logging) {
-        if (!this.isMessageIgnored(params.level, sessionId)) {
-          return this.notification({ method: "notifications/message", params });
-        }
-      }
+    async sendLoggingMessage(params) {
+      return this.notification({ method: "notifications/message", params });
     }
     async sendResourceUpdated(params) {
       return this.notification({
@@ -20845,13 +20691,10 @@
             inputSchema: tool.inputSchema ? zodToJsonSchema(tool.inputSchema, {
               strictUnions: true
             }) : EMPTY_OBJECT_JSON_SCHEMA,
-            annotations: tool.annotations,
-            _meta: tool._meta
+            annotations: tool.annotations
           };
           if (tool.outputSchema) {
-            toolDefinition.outputSchema = zodToJsonSchema(tool.outputSchema, {
-              strictUnions: true
-            });
+            toolDefinition.outputSchema = zodToJsonSchema(tool.outputSchema, { strictUnions: true });
           }
           return toolDefinition;
         })
@@ -21214,14 +21057,13 @@
       this._registeredPrompts[name] = registeredPrompt;
       return registeredPrompt;
     }
-    _createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, _meta, callback) {
+    _createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, callback) {
       const registeredTool = {
         title: title2,
         description: description2,
         inputSchema: inputSchema === void 0 ? void 0 : objectType(inputSchema),
         outputSchema: outputSchema === void 0 ? void 0 : objectType(outputSchema),
         annotations,
-        _meta,
         callback,
         enabled: true,
         disable: () => registeredTool.update({ enabled: false }),
@@ -21243,8 +21085,6 @@
             registeredTool.callback = updates.callback;
           if (typeof updates.annotations !== "undefined")
             registeredTool.annotations = updates.annotations;
-          if (typeof updates._meta !== "undefined")
-            registeredTool._meta = updates._meta;
           if (typeof updates.enabled !== "undefined")
             registeredTool.enabled = updates.enabled;
           this.sendToolListChanged();
@@ -21281,7 +21121,7 @@
         }
       }
       const callback = rest[0];
-      return this._createRegisteredTool(name, void 0, description2, inputSchema, outputSchema, annotations, void 0, callback);
+      return this._createRegisteredTool(name, void 0, description2, inputSchema, outputSchema, annotations, callback);
     }
     /**
      * Registers a tool with a config object and callback.
@@ -21290,8 +21130,8 @@
       if (this._registeredTools[name]) {
         throw new Error(`Tool ${name} is already registered`);
       }
-      const { title: title2, description: description2, inputSchema, outputSchema, annotations, _meta } = config;
-      return this._createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, _meta, cb);
+      const { title: title2, description: description2, inputSchema, outputSchema, annotations } = config;
+      return this._createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, cb);
     }
     prompt(name, ...rest) {
       if (this._registeredPrompts[name]) {
@@ -21331,16 +21171,6 @@
     isConnected() {
       return this.server.transport !== void 0;
     }
-    /**
-     * Sends a logging message to the client, if connected.
-     * Note: You only need to send the parameters object, not the entire JSON RPC message
-     * @see LoggingMessageNotification
-     * @param params
-     * @param sessionId optional for stateless and backward compatibility
-     */
-    async sendLoggingMessage(params, sessionId) {
-      return this.server.sendLoggingMessage(params, sessionId);
-    }
     /**
      * Sends a resource list changed event to the client, if connected.
      */
@@ -21456,8 +21286,6 @@
   exports2.EnumSchemaSchema = EnumSchemaSchema;
   exports2.GetPromptRequestSchema = GetPromptRequestSchema;
   exports2.GetPromptResultSchema = GetPromptResultSchema;
-  exports2.IconSchema = IconSchema;
-  exports2.IconsSchema = IconsSchema;
   exports2.ImageContentSchema = ImageContentSchema;
   exports2.ImplementationSchema = ImplementationSchema;
   exports2.InitializeRequestSchema = InitializeRequestSchema;