@casys/mcp-erpnext 3.0.0 → 3.0.1

package/mcp-erpnext.mjs

@@ -1769,7 +1769,7 @@ var require_code2 = __commonJS({
       return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
     }
     exports.schemaProperties = schemaProperties;
-    function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
+    function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context2, passSchema) {
       const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
       const valCxt = [
         [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
@@ -1780,7 +1780,7 @@ var require_code2 = __commonJS({
       if (it.opts.dynamicRef)
         valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
       const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
-      return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`;
+      return context2 !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context2}, ${args})` : (0, codegen_1._)`${func}(${args})`;
     }
     exports.callValidateCode = callValidateCode;
     var newRegExp = (0, codegen_1._)`new RegExp`;
@@ -4776,8 +4776,8 @@ var require_multipleOf = __commonJS({
         const { gen, data, schemaCode, it } = cxt;
         const prec = it.opts.multipleOfPrecision;
         const res = gen.let("res");
-        const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
-        cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`);
+        const invalid2 = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
+        cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid2}))`);
       }
     };
     exports.default = def;
@@ -6676,8 +6676,8 @@ var require_formats = __commonJS({
       email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i
     };
     exports.formatNames = Object.keys(exports.fullFormats);
-    function isLeapYear(year2) {
-      return year2 % 4 === 0 && (year2 % 100 !== 0 || year2 % 400 === 0);
+    function isLeapYear(year) {
+      return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
     }
     var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
     var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
@@ -6685,10 +6685,10 @@ var require_formats = __commonJS({
       const matches = DATE.exec(str);
       if (!matches)
         return false;
-      const year2 = +matches[1];
+      const year = +matches[1];
       const month = +matches[2];
-      const day2 = +matches[3];
-      return month >= 1 && month <= 12 && day2 >= 1 && day2 <= (month === 2 && isLeapYear(year2) ? 29 : DAYS[month]);
+      const day = +matches[3];
+      return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
     }
     function compareDate(d1, d2) {
       if (!(d1 && d2))
@@ -6921,6 +6921,830 @@ var require_dist = __commonJS({
   }
 });
 
+// node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js
+var require_dynamicAnchor = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.dynamicAnchor = void 0;
+    var codegen_1 = require_codegen();
+    var names_1 = require_names();
+    var compile_1 = require_compile();
+    var ref_1 = require_ref();
+    var def = {
+      keyword: "$dynamicAnchor",
+      schemaType: "string",
+      code: (cxt) => dynamicAnchor(cxt, cxt.schema)
+    };
+    function dynamicAnchor(cxt, anchor) {
+      const { gen, it } = cxt;
+      it.schemaEnv.root.dynamicAnchors[anchor] = true;
+      const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`;
+      const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
+      gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate));
+    }
+    exports.dynamicAnchor = dynamicAnchor;
+    function _getValidate(cxt) {
+      const { schemaEnv, schema, self: self2 } = cxt.it;
+      const { root, baseId, localRefs, meta: meta2 } = schemaEnv.root;
+      const { schemaId } = self2.opts;
+      const sch = new compile_1.SchemaEnv({ schema, schemaId, root, baseId, localRefs, meta: meta2 });
+      compile_1.compileSchema.call(self2, sch);
+      return (0, ref_1.getValidate)(cxt, sch);
+    }
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js
+var require_dynamicRef = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.dynamicRef = void 0;
+    var codegen_1 = require_codegen();
+    var names_1 = require_names();
+    var ref_1 = require_ref();
+    var def = {
+      keyword: "$dynamicRef",
+      schemaType: "string",
+      code: (cxt) => dynamicRef(cxt, cxt.schema)
+    };
+    function dynamicRef(cxt, ref) {
+      const { gen, keyword, it } = cxt;
+      if (ref[0] !== "#")
+        throw new Error(`"${keyword}" only supports hash fragment reference`);
+      const anchor = ref.slice(1);
+      if (it.allErrors) {
+        _dynamicRef();
+      } else {
+        const valid = gen.let("valid", false);
+        _dynamicRef(valid);
+        cxt.ok(valid);
+      }
+      function _dynamicRef(valid) {
+        if (it.schemaEnv.root.dynamicAnchors[anchor]) {
+          const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`);
+          gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
+        } else {
+          _callRef(it.validateName, valid)();
+        }
+      }
+      function _callRef(validate, valid) {
+        return valid ? () => gen.block(() => {
+          (0, ref_1.callRef)(cxt, validate);
+          gen.let(valid, true);
+        }) : () => (0, ref_1.callRef)(cxt, validate);
+      }
+    }
+    exports.dynamicRef = dynamicRef;
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js
+var require_recursiveAnchor = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dynamicAnchor_1 = require_dynamicAnchor();
+    var util_1 = require_util();
+    var def = {
+      keyword: "$recursiveAnchor",
+      schemaType: "boolean",
+      code(cxt) {
+        if (cxt.schema)
+          (0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
+        else
+          (0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js
+var require_recursiveRef = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dynamicRef_1 = require_dynamicRef();
+    var def = {
+      keyword: "$recursiveRef",
+      schemaType: "string",
+      code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/index.js
+var require_dynamic = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dynamicAnchor_1 = require_dynamicAnchor();
+    var dynamicRef_1 = require_dynamicRef();
+    var recursiveAnchor_1 = require_recursiveAnchor();
+    var recursiveRef_1 = require_recursiveRef();
+    var dynamic = [dynamicAnchor_1.default, dynamicRef_1.default, recursiveAnchor_1.default, recursiveRef_1.default];
+    exports.default = dynamic;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/validation/dependentRequired.js
+var require_dependentRequired = __commonJS({
+  "node_modules/ajv/dist/vocabularies/validation/dependentRequired.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dependencies_1 = require_dependencies();
+    var def = {
+      keyword: "dependentRequired",
+      type: "object",
+      schemaType: "object",
+      error: dependencies_1.error,
+      code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt)
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js
+var require_dependentSchemas = __commonJS({
+  "node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dependencies_1 = require_dependencies();
+    var def = {
+      keyword: "dependentSchemas",
+      type: "object",
+      schemaType: "object",
+      code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/validation/limitContains.js
+var require_limitContains = __commonJS({
+  "node_modules/ajv/dist/vocabularies/validation/limitContains.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var util_1 = require_util();
+    var def = {
+      keyword: ["maxContains", "minContains"],
+      type: "array",
+      schemaType: "number",
+      code({ keyword, parentSchema, it }) {
+        if (parentSchema.contains === void 0) {
+          (0, util_1.checkStrictMode)(it, `"${keyword}" without "contains" is ignored`);
+        }
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/next.js
+var require_next = __commonJS({
+  "node_modules/ajv/dist/vocabularies/next.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dependentRequired_1 = require_dependentRequired();
+    var dependentSchemas_1 = require_dependentSchemas();
+    var limitContains_1 = require_limitContains();
+    var next = [dependentRequired_1.default, dependentSchemas_1.default, limitContains_1.default];
+    exports.default = next;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js
+var require_unevaluatedProperties = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var codegen_1 = require_codegen();
+    var util_1 = require_util();
+    var names_1 = require_names();
+    var error2 = {
+      message: "must NOT have unevaluated properties",
+      params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
+    };
+    var def = {
+      keyword: "unevaluatedProperties",
+      type: "object",
+      schemaType: ["boolean", "object"],
+      trackErrors: true,
+      error: error2,
+      code(cxt) {
+        const { gen, schema, data, errsCount, it } = cxt;
+        if (!errsCount)
+          throw new Error("ajv implementation error");
+        const { allErrors, props } = it;
+        if (props instanceof codegen_1.Name) {
+          gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
+        } else if (props !== true) {
+          gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
+        }
+        it.props = true;
+        cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+        function unevaluatedPropCode(key) {
+          if (schema === false) {
+            cxt.setParams({ unevaluatedProperty: key });
+            cxt.error();
+            if (!allErrors)
+              gen.break();
+            return;
+          }
+          if (!(0, util_1.alwaysValidSchema)(it, schema)) {
+            const valid = gen.name("valid");
+            cxt.subschema({
+              keyword: "unevaluatedProperties",
+              dataProp: key,
+              dataPropType: util_1.Type.Str
+            }, valid);
+            if (!allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          }
+        }
+        function unevaluatedDynamic(evaluatedProps, key) {
+          return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
+        }
+        function unevaluatedStatic(evaluatedProps, key) {
+          const ps = [];
+          for (const p in evaluatedProps) {
+            if (evaluatedProps[p] === true)
+              ps.push((0, codegen_1._)`${key} !== ${p}`);
+          }
+          return (0, codegen_1.and)(...ps);
+        }
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js
+var require_unevaluatedItems = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var codegen_1 = require_codegen();
+    var util_1 = require_util();
+    var error2 = {
+      message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
+      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
+    };
+    var def = {
+      keyword: "unevaluatedItems",
+      type: "array",
+      schemaType: ["boolean", "object"],
+      error: error2,
+      code(cxt) {
+        const { gen, schema, data, it } = cxt;
+        const items = it.items || 0;
+        if (items === true)
+          return;
+        const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+        if (schema === false) {
+          cxt.setParams({ len: items });
+          cxt.fail((0, codegen_1._)`${len} > ${items}`);
+        } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+          const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items}`);
+          gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
+          cxt.ok(valid);
+        }
+        it.items = true;
+        function validateItems(valid, from) {
+          gen.forRange("i", from, len, (i) => {
+            cxt.subschema({ keyword: "unevaluatedItems", dataProp: i, dataPropType: util_1.Type.Num }, valid);
+            if (!it.allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          });
+        }
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/index.js
+var require_unevaluated = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var unevaluatedProperties_1 = require_unevaluatedProperties();
+    var unevaluatedItems_1 = require_unevaluatedItems();
+    var unevaluated = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
+    exports.default = unevaluated;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/draft2020.js
+var require_draft2020 = __commonJS({
+  "node_modules/ajv/dist/vocabularies/draft2020.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var core_1 = require_core2();
+    var validation_1 = require_validation();
+    var applicator_1 = require_applicator();
+    var dynamic_1 = require_dynamic();
+    var next_1 = require_next();
+    var unevaluated_1 = require_unevaluated();
+    var format_1 = require_format2();
+    var metadata_1 = require_metadata();
+    var draft2020Vocabularies = [
+      dynamic_1.default,
+      core_1.default,
+      validation_1.default,
+      (0, applicator_1.default)(true),
+      format_1.default,
+      metadata_1.metadataVocabulary,
+      metadata_1.contentVocabulary,
+      next_1.default,
+      unevaluated_1.default
+    ];
+    exports.default = draft2020Vocabularies;
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/schema.json
+var require_schema = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/schema.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/schema",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Core and Validation specifications meta-schema",
+      allOf: [
+        { $ref: "meta/core" },
+        { $ref: "meta/applicator" },
+        { $ref: "meta/unevaluated" },
+        { $ref: "meta/validation" },
+        { $ref: "meta/meta-data" },
+        { $ref: "meta/format-annotation" },
+        { $ref: "meta/content" }
+      ],
+      type: ["object", "boolean"],
+      $comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+      properties: {
+        definitions: {
+          $comment: '"definitions" has been replaced by "$defs".',
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          deprecated: true,
+          default: {}
+        },
+        dependencies: {
+          $comment: '"dependencies" has been split and replaced by "dependentSchemas" and "dependentRequired" in order to serve their differing semantics.',
+          type: "object",
+          additionalProperties: {
+            anyOf: [{ $dynamicRef: "#meta" }, { $ref: "meta/validation#/$defs/stringArray" }]
+          },
+          deprecated: true,
+          default: {}
+        },
+        $recursiveAnchor: {
+          $comment: '"$recursiveAnchor" has been replaced by "$dynamicAnchor".',
+          $ref: "meta/core#/$defs/anchorString",
+          deprecated: true
+        },
+        $recursiveRef: {
+          $comment: '"$recursiveRef" has been replaced by "$dynamicRef".',
+          $ref: "meta/core#/$defs/uriReferenceString",
+          deprecated: true
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json
+var require_applicator2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/applicator",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Applicator vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        prefixItems: { $ref: "#/$defs/schemaArray" },
+        items: { $dynamicRef: "#meta" },
+        contains: { $dynamicRef: "#meta" },
+        additionalProperties: { $dynamicRef: "#meta" },
+        properties: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          default: {}
+        },
+        patternProperties: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          propertyNames: { format: "regex" },
+          default: {}
+        },
+        dependentSchemas: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          default: {}
+        },
+        propertyNames: { $dynamicRef: "#meta" },
+        if: { $dynamicRef: "#meta" },
+        then: { $dynamicRef: "#meta" },
+        else: { $dynamicRef: "#meta" },
+        allOf: { $ref: "#/$defs/schemaArray" },
+        anyOf: { $ref: "#/$defs/schemaArray" },
+        oneOf: { $ref: "#/$defs/schemaArray" },
+        not: { $dynamicRef: "#meta" }
+      },
+      $defs: {
+        schemaArray: {
+          type: "array",
+          minItems: 1,
+          items: { $dynamicRef: "#meta" }
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json
+var require_unevaluated2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Unevaluated applicator vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        unevaluatedItems: { $dynamicRef: "#meta" },
+        unevaluatedProperties: { $dynamicRef: "#meta" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json
+var require_content = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/content",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Content vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        contentEncoding: { type: "string" },
+        contentMediaType: { type: "string" },
+        contentSchema: { $dynamicRef: "#meta" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json
+var require_core3 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/core",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/core": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Core vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        $id: {
+          $ref: "#/$defs/uriReferenceString",
+          $comment: "Non-empty fragments not allowed.",
+          pattern: "^[^#]*#?$"
+        },
+        $schema: { $ref: "#/$defs/uriString" },
+        $ref: { $ref: "#/$defs/uriReferenceString" },
+        $anchor: { $ref: "#/$defs/anchorString" },
+        $dynamicRef: { $ref: "#/$defs/uriReferenceString" },
+        $dynamicAnchor: { $ref: "#/$defs/anchorString" },
+        $vocabulary: {
+          type: "object",
+          propertyNames: { $ref: "#/$defs/uriString" },
+          additionalProperties: {
+            type: "boolean"
+          }
+        },
+        $comment: {
+          type: "string"
+        },
+        $defs: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" }
+        }
+      },
+      $defs: {
+        anchorString: {
+          type: "string",
+          pattern: "^[A-Za-z_][-A-Za-z0-9._]*$"
+        },
+        uriString: {
+          type: "string",
+          format: "uri"
+        },
+        uriReferenceString: {
+          type: "string",
+          format: "uri-reference"
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json
+var require_format_annotation = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Format vocabulary meta-schema for annotation results",
+      type: ["object", "boolean"],
+      properties: {
+        format: { type: "string" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json
+var require_meta_data = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/meta-data",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Meta-data vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        title: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        },
+        default: true,
+        deprecated: {
+          type: "boolean",
+          default: false
+        },
+        readOnly: {
+          type: "boolean",
+          default: false
+        },
+        writeOnly: {
+          type: "boolean",
+          default: false
+        },
+        examples: {
+          type: "array",
+          items: true
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
+var require_validation2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/validation",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/validation": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Validation vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        type: {
+          anyOf: [
+            { $ref: "#/$defs/simpleTypes" },
+            {
+              type: "array",
+              items: { $ref: "#/$defs/simpleTypes" },
+              minItems: 1,
+              uniqueItems: true
+            }
+          ]
+        },
+        const: true,
+        enum: {
+          type: "array",
+          items: true
+        },
+        multipleOf: {
+          type: "number",
+          exclusiveMinimum: 0
+        },
+        maximum: {
+          type: "number"
+        },
+        exclusiveMaximum: {
+          type: "number"
+        },
+        minimum: {
+          type: "number"
+        },
+        exclusiveMinimum: {
+          type: "number"
+        },
+        maxLength: { $ref: "#/$defs/nonNegativeInteger" },
+        minLength: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        pattern: {
+          type: "string",
+          format: "regex"
+        },
+        maxItems: { $ref: "#/$defs/nonNegativeInteger" },
+        minItems: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        uniqueItems: {
+          type: "boolean",
+          default: false
+        },
+        maxContains: { $ref: "#/$defs/nonNegativeInteger" },
+        minContains: {
+          $ref: "#/$defs/nonNegativeInteger",
+          default: 1
+        },
+        maxProperties: { $ref: "#/$defs/nonNegativeInteger" },
+        minProperties: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        required: { $ref: "#/$defs/stringArray" },
+        dependentRequired: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/stringArray"
+          }
+        }
+      },
+      $defs: {
+        nonNegativeInteger: {
+          type: "integer",
+          minimum: 0
+        },
+        nonNegativeIntegerDefault0: {
+          $ref: "#/$defs/nonNegativeInteger",
+          default: 0
+        },
+        simpleTypes: {
+          enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
+        },
+        stringArray: {
+          type: "array",
+          items: { type: "string" },
+          uniqueItems: true,
+          default: []
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/index.js
+var require_json_schema_2020_12 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var metaSchema = require_schema();
+    var applicator = require_applicator2();
+    var unevaluated = require_unevaluated2();
+    var content = require_content();
+    var core = require_core3();
+    var format = require_format_annotation();
+    var metadata = require_meta_data();
+    var validation = require_validation2();
+    var META_SUPPORT_DATA = ["/properties"];
+    function addMetaSchema2020($data) {
+      ;
+      [
+        metaSchema,
+        applicator,
+        unevaluated,
+        content,
+        core,
+        with$data(this, format),
+        metadata,
+        with$data(this, validation)
+      ].forEach((sch) => this.addMetaSchema(sch, void 0, false));
+      return this;
+      function with$data(ajv, sch) {
+        return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
+      }
+    }
+    exports.default = addMetaSchema2020;
+  }
+});
+
+// node_modules/ajv/dist/2020.js
+var require__ = __commonJS({
+  "node_modules/ajv/dist/2020.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2020 = void 0;
+    var core_1 = require_core();
+    var draft2020_1 = require_draft2020();
+    var discriminator_1 = require_discriminator();
+    var json_schema_2020_12_1 = require_json_schema_2020_12();
+    var META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
+    var Ajv2020 = class extends core_1.default {
+      constructor(opts = {}) {
+        super({
+          ...opts,
+          dynamicRef: true,
+          next: true,
+          unevaluated: true
+        });
+      }
+      _addVocabularies() {
+        super._addVocabularies();
+        draft2020_1.default.forEach((v) => this.addVocabulary(v));
+        if (this.opts.discriminator)
+          this.addKeyword(discriminator_1.default);
+      }
+      _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        const { $data, meta: meta2 } = this.opts;
+        if (!meta2)
+          return;
+        json_schema_2020_12_1.default.call(this, $data);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+      }
+      defaultMeta() {
+        return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
+      }
+    };
+    exports.Ajv2020 = Ajv2020;
+    module.exports = exports = Ajv2020;
+    module.exports.Ajv2020 = Ajv2020;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.default = Ajv2020;
+    var validate_1 = require_validate();
+    Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
+      return validate_1.KeywordCxt;
+    } });
+    var codegen_1 = require_codegen();
+    Object.defineProperty(exports, "_", { enumerable: true, get: function() {
+      return codegen_1._;
+    } });
+    Object.defineProperty(exports, "str", { enumerable: true, get: function() {
+      return codegen_1.str;
+    } });
+    Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
+      return codegen_1.stringify;
+    } });
+    Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
+      return codegen_1.nil;
+    } });
+    Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
+      return codegen_1.Name;
+    } });
+    Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
+      return codegen_1.CodeGen;
+    } });
+    var validation_error_1 = require_validation_error();
+    Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
+      return validation_error_1.default;
+    } });
+    var ref_error_1 = require_ref_error();
+    Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
+      return ref_error_1.default;
+    } });
+  }
+});
+
 // node_modules/@casys/mcp-server/src/runtime/runtime.deno.ts
 var runtime_deno_exports = {};
 __export(runtime_deno_exports, {
@@ -9692,7 +10516,7 @@ var require_int = __commonJS({
 });
 
 // node_modules/yaml/dist/schema/core/schema.js
-var require_schema = __commonJS({
+var require_schema2 = __commonJS({
   "node_modules/yaml/dist/schema/core/schema.js"(exports) {
     "use strict";
     var map = require_map();
@@ -9720,7 +10544,7 @@ var require_schema = __commonJS({
 });
 
 // node_modules/yaml/dist/schema/json/schema.js
-var require_schema2 = __commonJS({
+var require_schema3 = __commonJS({
   "node_modules/yaml/dist/schema/json/schema.js"(exports) {
     "use strict";
     var Scalar = require_Scalar();
@@ -10325,9 +11149,9 @@ var require_timestamp = __commonJS({
         const match2 = str.match(timestamp.test);
         if (!match2)
           throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
-        const [, year2, month, day2, hour2, minute2, second] = match2.map(Number);
+        const [, year, month, day, hour, minute, second] = match2.map(Number);
         const millisec = match2[7] ? Number((match2[7] + "00").substr(1, 3)) : 0;
-        let date3 = Date.UTC(year2, month - 1, day2, hour2 || 0, minute2 || 0, second || 0, millisec);
+        let date3 = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);
         const tz = match2[8];
         if (tz && tz !== "Z") {
           let d = parseSexagesimal(tz, false);
@@ -10346,7 +11170,7 @@ var require_timestamp = __commonJS({
 });
 
 // node_modules/yaml/dist/schema/yaml-1.1/schema.js
-var require_schema3 = __commonJS({
+var require_schema4 = __commonJS({
   "node_modules/yaml/dist/schema/yaml-1.1/schema.js"(exports) {
     "use strict";
     var map = require_map();
@@ -10400,13 +11224,13 @@ var require_tags = __commonJS({
     var bool = require_bool();
     var float = require_float();
     var int2 = require_int();
-    var schema = require_schema();
-    var schema$1 = require_schema2();
+    var schema = require_schema2();
+    var schema$1 = require_schema3();
     var binary = require_binary();
     var merge2 = require_merge();
     var omap = require_omap();
     var pairs = require_pairs();
-    var schema$2 = require_schema3();
+    var schema$2 = require_schema4();
     var set = require_set();
     var timestamp = require_timestamp();
     var schemas = /* @__PURE__ */ new Map([
@@ -12539,15 +13363,15 @@ var require_cst_scalar = __commonJS({
       }
       return null;
     }
-    function createScalarToken(value, context) {
-      const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context;
+    function createScalarToken(value, context2) {
+      const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context2;
       const source = stringifyString.stringifyString({ type, value }, {
         implicitKey,
         indent: indent > 0 ? " ".repeat(indent) : "",
         inFlow,
         options: { blockQuote: true, lineWidth: -1 }
       });
-      const end = context.end ?? [
+      const end = context2.end ?? [
         { type: "newline", offset: -1, indent, source: "\n" }
       ];
       switch (source[0]) {
@@ -12571,8 +13395,8 @@ var require_cst_scalar = __commonJS({
           return { type: "scalar", offset, indent, source, end };
       }
     }
-    function setScalarValue(token, value, context = {}) {
-      let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
+    function setScalarValue(token, value, context2 = {}) {
+      let { afterKey = false, implicitKey = false, inFlow = false, type } = context2;
       let indent = "indent" in token ? token.indent : null;
       if (afterKey && typeof indent === "number")
         indent += 2;
@@ -29659,7 +30483,7 @@ var StdioServerTransport = class {
 
 // node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
-  return (context, next) => {
+  return (context2, next) => {
     let index = -1;
     return dispatch(0);
     async function dispatch(i) {
@@ -29672,31 +30496,31 @@ var compose = (middleware, onError, onNotFound) => {
       let handler;
       if (middleware[i]) {
         handler = middleware[i][0][0];
-        context.req.routeIndex = i;
+        context2.req.routeIndex = i;
       } else {
         handler = i === middleware.length && next || void 0;
       }
       if (handler) {
         try {
-          res = await handler(context, () => dispatch(i + 1));
+          res = await handler(context2, () => dispatch(i + 1));
         } catch (err) {
           if (err instanceof Error && onError) {
-            context.error = err;
-            res = await onError(err, context);
+            context2.error = err;
+            res = await onError(err, context2);
             isError = true;
           } else {
             throw err;
           }
         }
       } else {
-        if (context.finalized === false && onNotFound) {
-          res = await onNotFound(context);
+        if (context2.finalized === false && onNotFound) {
+          res = await onNotFound(context2);
         }
       }
-      if (res && (context.finalized === false || isError)) {
-        context.res = res;
+      if (res && (context2.finalized === false || isError)) {
+        context2.res = res;
       }
-      return context;
+      return context2;
     }
   };
 };
@@ -29923,18 +30747,16 @@ var checkOptionalParameter = (path) => {
   });
   return results.filter((v, i, a) => a.indexOf(v) === i);
 };
+var tryDecodeURIComponent = (str) => str.indexOf("%") !== -1 ? tryDecode(str, decodeURIComponent_) : str;
 var _decodeURI = (value) => {
-  if (!/[%+]/.test(value)) {
-    return value;
-  }
   if (value.indexOf("+") !== -1) {
     value = value.replace(/\+/g, " ");
   }
-  return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
+  return tryDecodeURIComponent(value);
 };
 var _getQueryParam = (url, key, multiple) => {
   let encoded;
-  if (!multiple && key && !/[%+]/.test(key)) {
+  if (!multiple && key && key.indexOf("%") === -1 && key.indexOf("+") === -1) {
     let keyIndex2 = url.indexOf("?", 8);
     if (keyIndex2 === -1) {
       return void 0;
@@ -30006,7 +30828,6 @@ var getQueryParams = (url, key) => {
 var decodeURIComponent_ = decodeURIComponent;
 
 // node_modules/hono/dist/request.js
-var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
 var HonoRequest = class {
   /**
    * `.raw` can get the raw Request object.
@@ -30045,7 +30866,6 @@ var HonoRequest = class {
     this.raw = request;
     this.path = path;
     this.#matchResult = matchResult;
-    this.#validatedData = {};
   }
   param(key) {
     return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
@@ -30053,7 +30873,7 @@ var HonoRequest = class {
   #getDecodedParam(key) {
     const paramKey = this.#matchResult[0][this.routeIndex][1][key];
     const param = this.#getParamValue(paramKey);
-    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
+    return param && tryDecodeURIComponent(param);
   }
   #getAllDecodedParams() {
     const decoded = {};
@@ -30061,7 +30881,7 @@ var HonoRequest = class {
     for (const key of keys) {
       const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
       if (value !== void 0) {
-        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
+        decoded[key] = tryDecodeURIComponent(value);
       }
     }
     return decoded;
@@ -30094,8 +30914,7 @@ var HonoRequest = class {
     if (cachedBody) {
       return cachedBody;
     }
-    const anyCachedKey = Object.keys(bodyCache)[0];
-    if (anyCachedKey) {
+    for (const anyCachedKey in bodyCache) {
       return bodyCache[anyCachedKey].then((body) => {
         if (anyCachedKey === "json") {
           body = JSON.stringify(body);
@@ -30198,10 +31017,11 @@ var HonoRequest = class {
    * @param data - The validated data to add.
    */
   addValidatedData(target, data) {
-    this.#validatedData[target] = data;
+    ;
+    (this.#validatedData ??= {})[target] = data;
   }
   valid(target) {
-    return this.#validatedData[target];
+    return this.#validatedData?.[target];
   }
   /**
    * `.url()` can get the request url strings.
@@ -30300,7 +31120,7 @@ var raw = (value, callbacks) => {
   escapedString.callbacks = callbacks;
   return escapedString;
 };
-var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+var resolveCallback = async (str, phase, preserveCallbacks, context2, buffer) => {
   if (typeof str === "object" && !(str instanceof String)) {
     if (!(str instanceof Promise)) {
       str = str.toString();
@@ -30318,9 +31138,9 @@ var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) =>
   } else {
     buffer = [str];
   }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context: context2 }))).then(
     (res) => Promise.all(
-      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
+      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context2, buffer))
     ).then(() => buffer[0])
   );
   if (preserveCallbacks) {
@@ -30603,11 +31423,11 @@ var Context = class {
     return Object.fromEntries(this.#var);
   }
   #newResponse(data, arg, headers) {
-    const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers();
-    if (typeof arg === "object" && "headers" in arg) {
-      const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
-      for (const [key, value] of argHeaders) {
-        if (key.toLowerCase() === "set-cookie") {
+    let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+    if (typeof arg === "object" && arg.headers) {
+      responseHeaders ??= new Headers();
+      for (const [key, value] of new Headers(arg.headers)) {
+        if (key === "set-cookie") {
           responseHeaders.append(key, value);
         } else {
           responseHeaders.set(key, value);
@@ -30615,19 +31435,34 @@ var Context = class {
       }
     }
     if (headers) {
-      for (const [k, v] of Object.entries(headers)) {
-        if (typeof v === "string") {
-          responseHeaders.set(k, v);
-        } else {
-          responseHeaders.delete(k);
-          for (const v2 of v) {
-            responseHeaders.append(k, v2);
+      if (!responseHeaders) {
+        let count = 0;
+        for (const k in headers) {
+          if (++count > 1 || typeof headers[k] !== "string") {
+            responseHeaders = new Headers();
+            break;
+          }
+        }
+      }
+      if (responseHeaders) {
+        for (const k in headers) {
+          const v = headers[k];
+          if (typeof v === "string") {
+            responseHeaders.set(k, v);
+          } else {
+            responseHeaders.delete(k);
+            for (const v2 of v) {
+              responseHeaders.append(k, v2);
+            }
           }
         }
       }
     }
     const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
-    return createResponseInstance(data, { status, headers: responseHeaders });
+    return createResponseInstance(data, {
+      status,
+      headers: responseHeaders ?? headers
+    });
   }
   newResponse = (...args) => this.#newResponse(...args);
   /**
@@ -30740,7 +31575,7 @@ var Context = class {
 // node_modules/hono/dist/router.js
 var METHOD_NAME_ALL = "ALL";
 var METHOD_NAME_ALL_LOWERCASE = "all";
-var METHODS = ["get", "post", "put", "delete", "options", "patch"];
+var METHODS = ["get", "post", "put", "delete", "options", "patch", "query"];
 var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
 var UnsupportedPathError = class extends Error {
 };
@@ -30767,6 +31602,7 @@ var Hono = class _Hono {
   delete;
   options;
   patch;
+  query;
   all;
   on;
   use;
@@ -31048,13 +31884,13 @@ var Hono = class _Hono {
     const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
-        const context = await composed(c);
-        if (!context.finalized) {
+        const context2 = await composed(c);
+        if (!context2.finalized) {
           throw new Error(
             "Context is not finalized. Did you forget to return a Response object or `await next()`?"
           );
         }
-        return context.res;
+        return context2.res;
       } catch (err) {
         return this.#handleError(err, c);
       }
@@ -31066,8 +31902,8 @@ var Hono = class _Hono {
    * @see {@link https://hono.dev/docs/api/hono#fetch}
    *
    * @param {Request} request - request Object of request
-   * @param {Env} Env - env Object
-   * @param {ExecutionContext} - context of execution
+   * @param {Env} env - env Object
+   * @param {ExecutionContext} executionCtx - context of execution
    * @returns {Response | Promise<Response>} response of request
    *
    */
@@ -31159,7 +31995,7 @@ function compareKey(a, b) {
     return 1;
   }
   if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
-    return 1;
+    return b === TAIL_WILDCARD_REG_EXP_STR ? -1 : 1;
   } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
     return -1;
   }
@@ -31171,76 +32007,75 @@ function compareKey(a, b) {
   return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
 var Node = class _Node {
+  // handler index of a dynamic path, or -1 for a static path terminal
   #index;
   #varIndex;
   #children = /* @__PURE__ */ Object.create(null);
-  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
-    if (tokens.length === 0) {
-      if (this.#index !== void 0) {
-        throw PATH_ERROR;
-      }
-      if (pathErrorCheckOnly) {
-        return;
-      }
-      this.#index = index;
-      return;
-    }
-    const [token, ...restTokens] = tokens;
-    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-    let node;
-    if (pattern) {
-      const name = pattern[1];
-      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-      if (name && pattern[2]) {
-        if (regexpStr === ".*") {
-          throw PATH_ERROR;
-        }
-        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
-        if (/\((?!\?:)/.test(regexpStr)) {
-          throw PATH_ERROR;
-        }
-      }
-      node = this.#children[regexpStr];
-      if (!node) {
-        if (Object.keys(this.#children).some(
-          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
+  insert(tokens, index, paramMap, context2, isStatic) {
+    let node = this;
+    for (let i = 0, len = tokens.length; i < len; i++) {
+      const token = tokens[i];
+      const pattern = token.length === 1 ? token === "*" ? i === len - 1 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : null : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+      let nextNode;
+      if (pattern) {
+        const name = pattern[1];
+        let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+        if (name && pattern[2]) {
+          if (regexpStr === ".*") {
+            throw PATH_ERROR;
+          }
+          regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+          if (/\((?!\?:)/.test(regexpStr)) {
+            throw PATH_ERROR;
+          }
+          if (regexpStr.length === 1 && regExpMetaChars.has(regexpStr)) {
+            throw PATH_ERROR;
+          }
+        }
+        nextNode = node.#children[regexpStr];
+        if (!nextNode) {
+          if (regexpStr !== ONLY_WILDCARD_REG_EXP_STR && regexpStr !== TAIL_WILDCARD_REG_EXP_STR) {
+            for (const k in node.#children) {
+              if (
+                // a single-char pattern coexists with single-char literals as a literal does
+                (regexpStr.length > 1 || k.length > 1) && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+              ) {
+                throw PATH_ERROR;
+              }
+            }
+          }
+          nextNode = node.#children[regexpStr] = new _Node();
         }
-        node = this.#children[regexpStr] = new _Node();
         if (name !== "") {
-          node.#varIndex = context.varIndex++;
+          nextNode.#varIndex ??= context2.varIndex++;
+          paramMap.push([name, nextNode.#varIndex]);
         }
-      }
-      if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.#varIndex]);
-      }
-    } else {
-      node = this.#children[token];
-      if (!node) {
-        if (Object.keys(this.#children).some(
-          (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
+      } else {
+        nextNode = node.#children[token];
+        if (!nextNode) {
+          for (const k in node.#children) {
+            if (k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR) {
+              throw PATH_ERROR;
+            }
+          }
+          nextNode = node.#children[token] = new _Node();
         }
-        node = this.#children[token] = new _Node();
       }
+      node = nextNode;
+    }
+    if (node.#index !== void 0) {
+      throw PATH_ERROR;
     }
-    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+    node.#index = isStatic ? -1 : index;
   }
   buildRegExpStr() {
     const childKeys = Object.keys(this.#children).sort(compareKey);
     const strList = childKeys.map((k) => {
       const c = this.#children[k];
-      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
-    });
-    if (typeof this.#index === "number") {
+      const childStr = c.buildRegExpStr();
+      return childStr === "" ? "" : (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + childStr;
+    }).filter(Boolean);
+    if (typeof this.#index === "number" && this.#index !== -1) {
       strList.unshift(`#${this.#index}`);
     }
     if (strList.length === 0) {
@@ -31257,12 +32092,20 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path, index, pathErrorCheckOnly) {
+  #index = 0;
+  // dynamic path -> [handler index, param assoc]; static paths are not registered
+  paths = /* @__PURE__ */ Object.create(null);
+  insert(path, isStatic) {
+    if (isStatic) {
+      this.#root.insert(path.split(""), 0, [], this.#context, true);
+      return;
+    }
     const paramAssoc = [];
     const groups = [];
+    let markedPath = path;
     for (let i = 0; ; ) {
       let replaced = false;
-      path = path.replace(/\{[^}]+\}/g, (m) => {
+      markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -31273,7 +32116,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j = tokens.length - 1; j >= 0; j--) {
@@ -31283,8 +32126,8 @@ var Trie = class {
         }
       }
     }
-    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
-    return paramAssoc;
+    this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
+    this.paths[path] = [this.#index++, paramAssoc];
   }
   buildRegExp() {
     let regexp = this.#root.buildRegExpStr();
@@ -31310,7 +32153,6 @@ var Trie = class {
 };
 
 // node_modules/hono/dist/router/reg-exp-router/router.js
-var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 function buildWildcardRegExp(path) {
   return wildcardRegExpCache[path] ??= new RegExp(
@@ -31323,63 +32165,6 @@ function buildWildcardRegExp(path) {
 function clearWildcardRegExpCache() {
   wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 }
-function buildMatcherFromPreprocessedRoutes(routes) {
-  const trie = new Trie();
-  const handlerData = [];
-  if (routes.length === 0) {
-    return nullMatcher;
-  }
-  const routesWithStaticPathFlag = routes.map(
-    (route) => [!/\*|\/:/.test(route[0]), ...route]
-  ).sort(
-    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
-  );
-  const staticMap = /* @__PURE__ */ Object.create(null);
-  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
-    if (pathErrorCheckOnly) {
-      staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
-    } else {
-      j++;
-    }
-    let paramAssoc;
-    try {
-      paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
-    } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
-    }
-    if (pathErrorCheckOnly) {
-      continue;
-    }
-    handlerData[j] = handlers.map(([h, paramCount]) => {
-      const paramIndexMap = /* @__PURE__ */ Object.create(null);
-      paramCount -= 1;
-      for (; paramCount >= 0; paramCount--) {
-        const [key, value] = paramAssoc[paramCount];
-        paramIndexMap[key] = value;
-      }
-      return [h, paramIndexMap];
-    });
-  }
-  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-  for (let i = 0, len = handlerData.length; i < len; i++) {
-    for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
-      const map = handlerData[i][j]?.[1];
-      if (!map) {
-        continue;
-      }
-      const keys = Object.keys(map);
-      for (let k = 0, len3 = keys.length; k < len3; k++) {
-        map[keys[k]] = paramReplacementMap[map[keys[k]]];
-      }
-    }
-  }
-  const handlerMap = [];
-  for (const i in indexReplacementMap) {
-    handlerMap[i] = handlerData[indexReplacementMap[i]];
-  }
-  return [regexp, handlerMap, staticMap];
-}
 function findMiddleware(middleware, path) {
   if (!middleware) {
     return void 0;
@@ -31395,9 +32180,18 @@ var RegExpRouter = class {
   name = "RegExpRouter";
   #middleware;
   #routes;
+  #tries;
   constructor() {
     this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
     this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#tries = { [METHOD_NAME_ALL]: new Trie() };
+  }
+  #insertPath(method, path) {
+    try {
+      this.#tries[method].insert(path, !/\*|\/:/.test(path));
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+    }
   }
   add(method, path, handler) {
     const middleware = this.#middleware;
@@ -31406,11 +32200,12 @@ var RegExpRouter = class {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
     if (!middleware[method]) {
-      ;
+      this.#tries[method] = new Trie();
       [middleware, routes].forEach((handlerMap) => {
         handlerMap[method] = /* @__PURE__ */ Object.create(null);
         Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
           handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
+          this.#insertPath(method, p);
         });
       });
     }
@@ -31420,13 +32215,12 @@ var RegExpRouter = class {
     const paramCount = (path.match(/\/:/g) || []).length;
     if (/\*$/.test(path)) {
       const re2 = buildWildcardRegExp(path);
-      if (method === METHOD_NAME_ALL) {
-        Object.keys(middleware).forEach((m) => {
-          middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
-        });
-      } else {
-        middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
-      }
+      Object.keys(middleware).forEach((m) => {
+        if ((method === METHOD_NAME_ALL || method === m) && !middleware[m][path]) {
+          this.#insertPath(m, path);
+          middleware[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+        }
+      });
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
           Object.keys(middleware[m]).forEach((p) => {
@@ -31448,9 +32242,12 @@ var RegExpRouter = class {
       const path2 = paths[i];
       Object.keys(routes).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
-          routes[m][path2] ||= [
-            ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
-          ];
+          if (!routes[m][path2]) {
+            this.#insertPath(m, path2);
+            routes[m][path2] = [
+              ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
+            ];
+          }
           routes[m][path2].push([handler, paramCount - len + i + 1]);
         }
       });
@@ -31462,29 +32259,54 @@ var RegExpRouter = class {
     Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
       matchers[method] ||= this.#buildMatcher(method);
     });
-    this.#middleware = this.#routes = void 0;
+    this.#middleware = this.#routes = this.#tries = void 0;
     clearWildcardRegExpCache();
     return matchers;
   }
   #buildMatcher(method) {
-    const routes = [];
-    let hasOwnRoute = method === METHOD_NAME_ALL;
-    [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
-      if (ownRoute.length !== 0) {
-        hasOwnRoute ||= true;
-        routes.push(...ownRoute);
-      } else if (method !== METHOD_NAME_ALL) {
-        routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]])
-        );
+    const middleware = this.#middleware[method];
+    const routes = this.#routes[method];
+    const trie = this.#tries[method];
+    const staticMap = /* @__PURE__ */ Object.create(null);
+    const handlerData = [];
+    [middleware, routes].forEach((r) => {
+      for (const path in r) {
+        const handlers = r[path];
+        const pathData = trie.paths[path];
+        if (!pathData) {
+          staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+          continue;
+        }
+        const paramAssoc = pathData[1];
+        handlerData[pathData[0]] = handlers.map(([h, paramCount]) => {
+          const paramIndexMap = /* @__PURE__ */ Object.create(null);
+          paramCount -= 1;
+          for (; paramCount >= 0; paramCount--) {
+            const [key, value] = paramAssoc[paramCount];
+            paramIndexMap[key] = value;
+          }
+          return [h, paramIndexMap];
+        });
       }
     });
-    if (!hasOwnRoute) {
-      return null;
-    } else {
-      return buildMatcherFromPreprocessedRoutes(routes);
+    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+    for (let i = 0, len = handlerData.length; i < len; i++) {
+      for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
+        const map = handlerData[i][j]?.[1];
+        if (!map) {
+          continue;
+        }
+        const keys = Object.keys(map);
+        for (let k = 0, len3 = keys.length; k < len3; k++) {
+          map[keys[k]] = paramReplacementMap[map[keys[k]]];
+        }
+      }
+    }
+    const handlerMap = [];
+    for (const i in indexReplacementMap) {
+      handlerMap[i] = handlerData[indexReplacementMap[i]];
     }
+    return [regexp, handlerMap, staticMap];
   }
 };
 
@@ -31688,7 +32510,7 @@ var Node2 = class _Node2 {
               }
               if (hasChildren(child.#children)) {
                 child.#params = params;
-                const componentCount = m[0].match(/\//)?.length ?? 0;
+                const componentCount = m[0].match(/\//g)?.length ?? 0;
                 const targetCurNodes = curNodesQueue[componentCount] ||= [];
                 targetCurNodes.push(child);
               }
@@ -31768,7 +32590,7 @@ var Hono2 = class extends Hono {
 var cors = (options) => {
   const opts = {
     origin: "*",
-    allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
+    allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH", "QUERY"],
     allowHeaders: [],
     exposeHeaders: [],
     ...options
@@ -31824,7 +32646,7 @@ var cors = (options) => {
       if (!headers?.length) {
         const requestHeaders = c.req.header("Access-Control-Request-Headers");
         if (requestHeaders) {
-          headers = requestHeaders.split(/\s*,\s*/);
+          headers = requestHeaders.split(",").map((h) => h.trim());
         }
       }
       if (headers?.length) {
@@ -32066,8 +32888,8 @@ var RateLimiter = class _RateLimiter {
 };
 
 // node_modules/@casys/mcp-server/src/validation/schema-validator.ts
-var import_ajv2 = __toESM(require_ajv(), 1);
-var Ajv2 = import_ajv2.default.default ?? import_ajv2.default;
+var import__ = __toESM(require__(), 1);
+var Ajv2 = import__.default.default ?? import__.default;
 function plural(n, singular, plural2 = `${singular}s`) {
   return `${n} ${n === 1 ? singular : plural2}`;
 }
@@ -32552,19 +33374,19 @@ var BaseContext = class _BaseContext {
    *
    * @param parentContext a context from which to inherit values
    */
-  constructor(parentContext) {
+  constructor(parentContext2) {
     const self2 = this;
-    self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+    self2._currentContext = parentContext2 ? new Map(parentContext2) : /* @__PURE__ */ new Map();
     self2.getValue = (key) => self2._currentContext.get(key);
     self2.setValue = (key, value) => {
-      const context = new _BaseContext(self2._currentContext);
-      context._currentContext.set(key, value);
-      return context;
+      const context2 = new _BaseContext(self2._currentContext);
+      context2._currentContext.set(key, value);
+      return context2;
     };
     self2.deleteValue = (key) => {
-      const context = new _BaseContext(self2._currentContext);
-      context._currentContext.delete(key);
-      return context;
+      const context2 = new _BaseContext(self2._currentContext);
+      context2._currentContext.delete(key);
+      return context2;
     };
   }
 };
@@ -32625,8 +33447,8 @@ var ContextAPI = class _ContextAPI {
    * @param thisArg optional receiver to be used for calling fn
    * @param args optional arguments forwarded to fn
    */
-  with(context, fn, thisArg, ...args) {
-    return this._getContextManager().with(context, fn, thisArg, ...args);
+  with(context2, fn, thisArg, ...args) {
+    return this._getContextManager().with(context2, fn, thisArg, ...args);
   }
   /**
    * Bind a context to a target function or event emitter
@@ -32634,8 +33456,8 @@ var ContextAPI = class _ContextAPI {
    * @param context context to bind to the event emitter or function. Defaults to the currently active context
    * @param target function or event emitter to bind
    */
-  bind(context, target) {
-    return this._getContextManager().bind(context, target);
+  bind(context2, target) {
+    return this._getContextManager().bind(context2, target);
   }
   _getContextManager() {
     return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
@@ -32712,24 +33534,24 @@ var NonRecordingSpan = class {
 
 // node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
 var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
-function getSpan(context) {
-  return context.getValue(SPAN_KEY) || void 0;
+function getSpan(context2) {
+  return context2.getValue(SPAN_KEY) || void 0;
 }
 function getActiveSpan() {
   return getSpan(ContextAPI.getInstance().active());
 }
-function setSpan(context, span) {
-  return context.setValue(SPAN_KEY, span);
+function setSpan(context2, span) {
+  return context2.setValue(SPAN_KEY, span);
 }
-function deleteSpan(context) {
-  return context.deleteValue(SPAN_KEY);
+function deleteSpan(context2) {
+  return context2.deleteValue(SPAN_KEY);
 }
-function setSpanContext(context, spanContext) {
-  return setSpan(context, new NonRecordingSpan(spanContext));
+function setSpanContext(context2, spanContext) {
+  return setSpan(context2, new NonRecordingSpan(spanContext));
 }
-function getSpanContext(context) {
+function getSpanContext(context2) {
   var _a3;
-  return (_a3 = getSpan(context)) === null || _a3 === void 0 ? void 0 : _a3.spanContext();
+  return (_a3 = getSpan(context2)) === null || _a3 === void 0 ? void 0 : _a3.spanContext();
 }
 
 // node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
@@ -32864,12 +33686,12 @@ function wrapSpanContext(spanContext) {
 var contextApi = ContextAPI.getInstance();
 var NoopTracer = class {
   // startSpan starts a noop span.
-  startSpan(name, options, context = contextApi.active()) {
+  startSpan(name, options, context2 = contextApi.active()) {
     const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
     if (root) {
       return new NonRecordingSpan();
     }
-    const parentFromContext = context && getSpanContext(context);
+    const parentFromContext = context2 && getSpanContext(context2);
     if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
       return new NonRecordingSpan(parentFromContext);
     } else {
@@ -32892,9 +33714,9 @@ var NoopTracer = class {
       ctx = arg3;
       fn = arg4;
     }
-    const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
-    const span = this.startSpan(name, opts, parentContext);
-    const contextWithSpanSet = setSpan(parentContext, span);
+    const parentContext2 = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+    const span = this.startSpan(name, opts, parentContext2);
+    const contextWithSpanSet = setSpan(parentContext2, span);
     return contextApi.with(contextWithSpanSet, fn, void 0, span);
   }
 };
@@ -32911,8 +33733,8 @@ var ProxyTracer = class {
     this.version = version2;
     this.options = options;
   }
-  startSpan(name, options, context) {
-    return this._getTracer().startSpan(name, options, context);
+  startSpan(name, options, context2) {
+    return this._getTracer().startSpan(name, options, context2);
   }
   startActiveSpan(_name, _options, _context, _fn) {
     const tracer = this._getTracer();
@@ -32976,6 +33798,9 @@ var SpanStatusCode;
   SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
 })(SpanStatusCode || (SpanStatusCode = {}));
 
+// node_modules/@opentelemetry/api/build/esm/context-api.js
+var context = ContextAPI.getInstance();
+
 // node_modules/@opentelemetry/api/build/esm/api/trace.js
 var API_NAME3 = "trace";
 var TraceAPI = class _TraceAPI {
@@ -33034,15 +33859,101 @@ var trace = TraceAPI.getInstance();
 
 // node_modules/@casys/mcp-server/src/observability/otel.ts
 var serverTracer = null;
+var TRACEPARENT = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})/;
+var TRACEPARENT_PREFIX_LENGTH = 55;
+var INVALID_TRACE_ID = "0".repeat(32);
+var INVALID_SPAN_ID = "0".repeat(16);
+var TRACESTATE_MAX_MEMBERS = 32;
+var TRACESTATE_KEY = /^(?:[a-z][a-z0-9_\-*/]{0,255}|[a-z0-9][a-z0-9_\-*/]{0,240}@[a-z][a-z0-9_\-*/]{0,13})$/;
+var TRACESTATE_VALUE = /^[\x20-\x2B\x2D-\x3C\x3E-\x7E]{0,255}[\x21-\x2B\x2D-\x3C\x3E-\x7E]$/;
+function trimOws(member) {
+  return member.replace(/^[ \t]+/, "").replace(/[ \t]+$/, "");
+}
+var ListTraceState = class _ListTraceState {
+  #entries;
+  constructor(entries) {
+    this.#entries = entries;
+  }
+  static #isValid(key, value) {
+    return TRACESTATE_KEY.test(key) && TRACESTATE_VALUE.test(value);
+  }
+  static parse(raw2) {
+    const seen = /* @__PURE__ */ new Set();
+    const entries = [];
+    for (const member of raw2.split(",")) {
+      const trimmed = trimOws(member);
+      if (trimmed.length === 0) continue;
+      const at = trimmed.indexOf("=");
+      if (at <= 0) continue;
+      const key = trimmed.slice(0, at);
+      const value = trimmed.slice(at + 1);
+      if (seen.has(key)) continue;
+      if (!_ListTraceState.#isValid(key, value)) continue;
+      seen.add(key);
+      entries.push([key, value]);
+      if (entries.length === TRACESTATE_MAX_MEMBERS) break;
+    }
+    return entries.length > 0 ? new _ListTraceState(entries) : void 0;
+  }
+  get(key) {
+    return this.#entries.find(([k]) => k === key)?.[1];
+  }
+  set(key, value) {
+    if (!_ListTraceState.#isValid(key, value)) return this;
+    return new _ListTraceState([
+      [key, value],
+      ...this.#entries.filter(([k]) => k !== key)
+    ].slice(0, TRACESTATE_MAX_MEMBERS));
+  }
+  unset(key) {
+    return new _ListTraceState(this.#entries.filter(([k]) => k !== key));
+  }
+  serialize() {
+    return this.#entries.map(([k, v]) => `${k}=${v}`).join(",");
+  }
+};
+function parseTraceParent(traceparent, tracestate) {
+  if (typeof traceparent !== "string") return void 0;
+  if (traceparent.length < TRACEPARENT_PREFIX_LENGTH) return void 0;
+  const match2 = TRACEPARENT.exec(traceparent);
+  if (!match2) return void 0;
+  const [, version2, traceId, spanId, flags] = match2;
+  if (version2 === "ff") return void 0;
+  if (version2 === "00") {
+    if (traceparent.length !== TRACEPARENT_PREFIX_LENGTH) return void 0;
+  } else if (traceparent.length > TRACEPARENT_PREFIX_LENGTH && traceparent[TRACEPARENT_PREFIX_LENGTH] !== "-") {
+    return void 0;
+  }
+  if (traceId === INVALID_TRACE_ID || spanId === INVALID_SPAN_ID) {
+    return void 0;
+  }
+  const traceState = typeof tracestate === "string" ? ListTraceState.parse(tracestate) : void 0;
+  return {
+    traceId,
+    spanId,
+    // Only the sampled bit is defined; the rest of the byte is reserved.
+    traceFlags: parseInt(flags, 16) & TraceFlags.SAMPLED,
+    isRemote: true,
+    ...traceState ? { traceState } : {}
+  };
+}
+function parentContext(remote) {
+  const active = context.active();
+  return remote ? trace.setSpanContext(active, remote) : active;
+}
 function getServerTracer() {
   if (!serverTracer) {
     serverTracer = trace.getTracer("mcp.server", "0.8.0");
   }
   return serverTracer;
 }
-function startToolCallSpan(toolName, attributes) {
+function startToolCallSpan(toolName, attributes, remoteParent) {
   const tracer = getServerTracer();
-  return tracer.startSpan(`mcp.tool.call ${toolName}`, { attributes });
+  return tracer.startSpan(
+    `mcp.tool.call ${toolName}`,
+    { attributes },
+    parentContext(remoteParent)
+  );
 }
 function endToolCallSpan(span, success, durationMs, error2) {
   span.setAttribute("mcp.tool.duration_ms", durationMs);
@@ -33271,6 +34182,12 @@ function checkUsage(key, usage) {
     throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
   }
 }
+function checkModulusLength(alg, key) {
+  const { modulusLength } = key.algorithm;
+  if (typeof modulusLength !== "number" || modulusLength < 2048) {
+    throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
+  }
+}
 function checkCryptoKey(key, expected, usage) {
   const algorithm = key.algorithm;
   if (algorithm.name !== expected.name) {
@@ -33290,7 +34207,6 @@ function checkCryptoKey(key, expected, usage) {
 
 // node_modules/jose/dist/webapi/lib/invalid_key_input.js
 function message(msg, actual, ...types) {
-  types = types.filter(Boolean);
   if (types.length > 2) {
     const last = types.pop();
     msg += `one of type ${types.join(", ")}, or ${last}.`;
@@ -33426,6 +34342,7 @@ function decodeBase64(encoded) {
 }
 
 // node_modules/jose/dist/webapi/util/base64url.js
+var invalid = "The input to be decoded is not correctly encoded.";
 function decode3(input) {
   if (Uint8Array.fromBase64) {
     try {
@@ -33433,7 +34350,7 @@ function decode3(input) {
         alphabet: "base64url"
       });
     } catch (cause) {
-      throw new TypeError("The input to be decoded is not correctly encoded.", { cause });
+      throw new TypeError(invalid, { cause });
     }
   }
   let encoded = input;
@@ -33441,48 +34358,41 @@ function decode3(input) {
     encoded = decoder.decode(encoded);
   }
   if (encoded.includes("+") || encoded.includes("/")) {
-    throw new TypeError("The input to be decoded is not correctly encoded.");
+    throw new TypeError(invalid);
   }
   encoded = encoded.replace(/-/g, "+").replace(/_/g, "/");
   try {
     return decodeBase64(encoded);
   } catch {
-    throw new TypeError("The input to be decoded is not correctly encoded.");
+    throw new TypeError(invalid);
   }
 }
 
 // node_modules/jose/dist/webapi/lib/type_checks.js
-var isObjectLike = (value) => typeof value === "object" && value !== null;
 function isObject2(input) {
-  if (!isObjectLike(input) || Object.prototype.toString.call(input) !== "[object Object]") {
+  if (typeof input !== "object" || input === null || Object.prototype.toString.call(input) !== "[object Object]") {
     return false;
   }
-  if (Object.getPrototypeOf(input) === null) {
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype === null) {
     return true;
   }
-  let proto = input;
+  let proto = prototype;
   while (Object.getPrototypeOf(proto) !== null) {
     proto = Object.getPrototypeOf(proto);
   }
-  return Object.getPrototypeOf(input) === proto;
+  return prototype === proto;
 }
 function isDisjoint(...headers) {
-  const sources = headers.filter(Boolean);
-  if (sources.length === 0 || sources.length === 1) {
-    return true;
-  }
-  let acc;
-  for (const header of sources) {
-    const parameters = Object.keys(header);
-    if (!acc || acc.size === 0) {
-      acc = new Set(parameters);
+  const parameters = /* @__PURE__ */ new Set();
+  for (const header of headers) {
+    if (!header)
       continue;
-    }
-    for (const parameter of parameters) {
-      if (acc.has(parameter)) {
+    for (const parameter of Object.keys(header)) {
+      if (parameters.has(parameter)) {
         return false;
       }
-      acc.add(parameter);
+      parameters.add(parameter);
     }
   }
   return true;
@@ -33522,26 +34432,21 @@ function parseJoseHeader(b64, ErrorClass, message2) {
 }
 
 // node_modules/jose/dist/webapi/lib/jwk_to_key.js
-var unsupportedAlg = 'Invalid or unsupported JWK "alg" (Algorithm) Parameter value';
-function subtleParams(entry, jwk) {
-  if (!entry.kty.includes(jwk.kty)) {
-    throw new JOSENotSupported(unsupportedAlg);
-  }
-  return entry.subtleFor?.({ kty: jwk.kty, crv: jwk.crv }) ?? entry.subtle;
-}
 async function jwkToKey(entry, jwk) {
   if (jwk.kty === "RSA" && "oth" in jwk && jwk.oth !== void 0) {
     throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
   }
-  const algorithm = subtleParams(entry, jwk);
+  if (!entry.kty.includes(jwk.kty)) {
+    throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+  }
+  const algorithm = entry.resolve?.({ kty: jwk.kty, crv: jwk.crv }) ?? entry.subtle;
   const isPrivate = !!(jwk.d || jwk.priv);
-  const keyUsages = isPrivate ? entry.usages.private : entry.usages.public;
   const keyData = { ...jwk };
   if (keyData.kty !== "AKP") {
     delete keyData.alg;
   }
   delete keyData.use;
-  return crypto.subtle.importKey("jwk", keyData, algorithm, jwk.ext ?? (isPrivate ? false : true), jwk.key_ops ?? keyUsages);
+  return crypto.subtle.importKey("jwk", keyData, algorithm, jwk.ext ?? !isPrivate, jwk.key_ops ?? entry.usages[isPrivate ? 1 : 0]);
 }
 
 // node_modules/jose/dist/webapi/lib/key.js
@@ -33549,17 +34454,7 @@ var tag = (key) => key[Symbol.toStringTag];
 var jwkMatchesOp = (entry, key, usage) => {
   const { alg } = entry;
   if (key.use !== void 0) {
-    let expected;
-    switch (usage) {
-      case "sign":
-      case "verify":
-        expected = "sig";
-        break;
-      case "encrypt":
-      case "decrypt":
-        expected = "enc";
-        break;
-    }
+    const expected = usage === "sign" || usage === "verify" ? "sig" : "enc";
     if (key.use !== expected) {
       throw new TypeError(`Invalid key for this operation, its "use" must be "${expected}" when present`);
     }
@@ -33568,77 +34463,47 @@ var jwkMatchesOp = (entry, key, usage) => {
     throw new TypeError(`Invalid key for this operation, its "alg" must be "${alg}" when present`);
   }
   if (Array.isArray(key.key_ops)) {
-    const expectedKeyOp = usage === "encrypt" || usage === "decrypt" ? entry.keyOps?.[usage] : usage;
-    if (expectedKeyOp && key.key_ops?.includes?.(expectedKeyOp) === false) {
+    const expectedKeyOp = usage === "encrypt" || usage === "decrypt" ? entry.ops?.[usage === "encrypt" ? 0 : 1] : usage;
+    if (expectedKeyOp && !key.key_ops.includes(expectedKeyOp)) {
       throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${expectedKeyOp}" when present`);
     }
   }
-  return true;
-};
-var symmetricTypeCheck = (entry, key, usage) => {
-  const { alg } = entry;
-  if (key instanceof Uint8Array)
-    return { kind: BYTES, key };
-  if (isJWK(key)) {
-    if (isSecretJWK(key) && jwkMatchesOp(entry, key, usage))
-      return { kind: JWK, key };
-    throw new TypeError(`JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present`);
-  }
-  if (!isKeyLike(key)) {
-    throw new TypeError(withAlg(alg, key, "CryptoKey", "KeyObject", "JSON Web Key", "Uint8Array"));
-  }
-  if (key.type !== "secret") {
-    throw new TypeError(`${tag(key)} instances for symmetric algorithms must be of type "secret"`);
-  }
-  return isCryptoKey(key) ? { kind: CRYPTO, key } : { kind: KEYOBJECT, key };
 };
-var asymmetricTypeCheck = (entry, key, usage) => {
-  const { alg } = entry;
+function checkKeyType(entry, key, usage) {
+  const { alg, secret } = entry;
+  const privateKey = usage === "decrypt" || usage === "sign";
+  if (secret && key instanceof Uint8Array)
+    return [BYTES, key];
   if (isJWK(key)) {
-    switch (usage) {
-      case "decrypt":
-      case "sign":
-        if (isPrivateJWK(key) && jwkMatchesOp(entry, key, usage))
-          return { kind: JWK, key };
-        throw new TypeError(`JSON Web Key for this operation must be a private JWK`);
-      case "encrypt":
-      case "verify":
-        if (isPublicJWK(key) && jwkMatchesOp(entry, key, usage))
-          return { kind: JWK, key };
-        throw new TypeError(`JSON Web Key for this operation must be a public JWK`);
+    if (secret ? !isSecretJWK(key) : !(privateKey ? isPrivateJWK(key) : isPublicJWK(key))) {
+      throw new TypeError(secret ? `JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present` : `JSON Web Key for this operation must be a ${privateKey ? "private" : "public"} JWK`);
     }
+    jwkMatchesOp(entry, key, usage);
+    return [JWK, key];
   }
   if (!isKeyLike(key)) {
-    throw new TypeError(withAlg(alg, key, "CryptoKey", "KeyObject", "JSON Web Key"));
-  }
-  if (key.type === "secret") {
-    throw new TypeError(`${tag(key)} instances for asymmetric algorithms must not be of type "secret"`);
+    throw new TypeError(secret ? withAlg(alg, key, "CryptoKey", "KeyObject", "JSON Web Key", "Uint8Array") : withAlg(alg, key, "CryptoKey", "KeyObject", "JSON Web Key"));
   }
-  if (key.type === "public") {
-    switch (usage) {
-      case "sign":
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm signing must be of type "private"`);
-      case "decrypt":
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm decryption must be of type "private"`);
+  if (secret) {
+    if (key.type !== "secret") {
+      throw new TypeError(`${tag(key)} instances for symmetric algorithms must be of type "secret"`);
     }
-  }
-  if (key.type === "private") {
-    switch (usage) {
-      case "verify":
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm verifying must be of type "public"`);
-      case "encrypt":
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm encryption must be of type "public"`);
+  } else {
+    if (key.type === "secret") {
+      throw new TypeError(`${tag(key)} instances for asymmetric algorithms must not be of type "secret"`);
+    }
+    const expectedType = privateKey ? "private" : "public";
+    if ((key.type === "public" || key.type === "private") && key.type !== expectedType) {
+      const operation = usage === "sign" ? "signing" : usage === "verify" ? "verifying" : `${usage.slice(0, -1)}tion`;
+      throw new TypeError(`${tag(key)} instances for asymmetric algorithm ${operation} must be of type "${expectedType}"`);
     }
   }
-  return isCryptoKey(key) ? { kind: CRYPTO, key } : { kind: KEYOBJECT, key };
-};
-var BYTES = Symbol();
-var CRYPTO = Symbol();
-var KEYOBJECT = Symbol();
-var JWK = Symbol();
-function checkKeyType(entry, key, usage) {
-  return entry.symmetric ? symmetricTypeCheck(entry, key, usage) : asymmetricTypeCheck(entry, key, usage);
+  return isCryptoKey(key) ? [CRYPTO, key] : [KEYOBJECT, key];
 }
+var BYTES = 0;
+var CRYPTO = 1;
+var KEYOBJECT = 2;
+var JWK = 3;
 var cache;
 var nist = {
   __proto__: null,
@@ -33646,57 +34511,51 @@ var nist = {
   secp384r1: "P-384",
   secp521r1: "P-521"
 };
-function cached2(key, alg) {
+function cached2(key, alg, value) {
   cache ||= /* @__PURE__ */ new WeakMap();
-  return cache.get(key)?.[alg];
-}
-function store(key, alg, cryptoKey) {
   const entry = cache.get(key);
-  if (entry) {
-    entry[alg] = cryptoKey;
-  } else {
-    cache.set(key, { [alg]: cryptoKey });
+  if (value) {
+    if (entry) {
+      entry[alg] = value;
+    } else {
+      cache.set(key, { __proto__: null, [alg]: value });
+    }
   }
-  return cryptoKey;
+  return value ?? entry?.[alg];
 }
-var handleJWK = async (key, jwk, entry) => {
-  const hit = cached2(key, entry.alg);
-  if (hit)
-    return hit;
-  const cryptoKey = await jwkToKey(entry, { ...jwk, alg: entry.alg });
-  return store(key, entry.alg, cryptoKey);
-};
+var handleJWK = async (key, jwk, entry) => cached2(key, entry.alg) ?? cached2(key, entry.alg, await jwkToKey(entry, { ...jwk, alg: entry.alg }));
 var handleKeyObject = (keyObject, entry) => {
   const hit = cached2(keyObject, entry.alg);
   if (hit)
     return hit;
   const isPublic = keyObject.type === "public";
-  const usages = isPublic ? entry.usages.public : entry.usages.private;
+  const usages = entry.usages[isPublic ? 0 : 1];
   const { asymmetricKeyType } = keyObject;
   const crv = nist[keyObject.asymmetricKeyDetails?.namedCurve];
-  const params = entry.subtleFor?.({ crv, asymmetricKeyType }) ?? entry.subtle;
-  return store(keyObject, entry.alg, keyObject.toCryptoKey(params, isPublic, usages));
+  const params = entry.resolve?.({ crv, asymmetricKeyType }) ?? entry.subtle;
+  return cached2(keyObject, entry.alg, keyObject.toCryptoKey(params, isPublic, usages));
 };
 async function prepareKey(entry, key, usage) {
   const tagged = checkKeyType(entry, key, usage);
-  switch (tagged.kind) {
+  switch (tagged[0]) {
     case BYTES:
     case CRYPTO:
-      return tagged.key;
+      return tagged[1];
     case JWK: {
-      if (tagged.key.k) {
-        return decode3(tagged.key.k);
+      const key2 = tagged[1];
+      if (key2.k) {
+        return decode3(key2.k);
       }
-      if (!Object.isFrozen(tagged.key)) {
-        const { key_ops } = tagged.key;
+      if (!Object.isFrozen(key2)) {
+        const { key_ops } = key2;
         if (Array.isArray(key_ops))
           Object.freeze(key_ops);
-        Object.freeze(tagged.key);
+        Object.freeze(key2);
       }
-      return handleJWK(tagged.key, tagged.key, entry);
+      return handleJWK(key2, key2, entry);
     }
     case KEYOBJECT: {
-      const keyObject = tagged.key;
+      const keyObject = tagged[1];
       if (keyObject.type === "secret") {
         return keyObject.export();
       }
@@ -33711,45 +34570,14 @@ async function prepareKey(entry, key, usage) {
 // node_modules/jose/dist/webapi/lib/key_descriptor.js
 function table(entries) {
   const out = { __proto__: null };
-  for (const alg of Object.keys(entries)) {
+  for (const alg in entries) {
     out[alg] = { ...entries[alg], alg };
   }
   return out;
 }
 
-// node_modules/jose/dist/webapi/lib/signing.js
-function checkModulusLength(alg, key) {
-  const { modulusLength } = key.algorithm;
-  if (typeof modulusLength !== "number" || modulusLength < 2048) {
-    throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
-  }
-}
-function checkSigCryptoKey(entry, key, usage) {
-  checkCryptoKey(key, entry.subtle, usage);
-  if (entry.minModulusLength) {
-    checkModulusLength(entry.alg, key);
-  }
-}
-async function getSigKey(entry, key, usage) {
-  if (key instanceof Uint8Array) {
-    return crypto.subtle.importKey("raw", key, entry.subtle, false, [
-      usage
-    ]);
-  }
-  checkSigCryptoKey(entry, key, usage);
-  return key;
-}
-async function verify(entry, key, signature, data) {
-  const cryptoKey = await getSigKey(entry, key, "verify");
-  try {
-    return await crypto.subtle.verify(entry.operation, cryptoKey, signature, data);
-  } catch {
-    return false;
-  }
-}
-
 // node_modules/jose/dist/webapi/lib/options.js
-var JWS_RECOGNIZED = /* @__PURE__ */ new Map([["b64", true]]);
+var JWS_RECOGNIZED = { __proto__: null, b64: true };
 function validateAlgorithms(option, algorithms) {
   if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== "string"))) {
     throw new TypeError(`"${option}" option must be an array of strings`);
@@ -33764,45 +34592,62 @@ function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader,
     throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
   }
   if (!protectedHeader || protectedHeader.crit === void 0) {
-    return /* @__PURE__ */ new Set();
+    return [];
   }
   if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input !== "string" || input.length === 0)) {
     throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
   }
-  let recognized;
-  if (recognizedOption !== void 0) {
-    recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
-  } else {
-    recognized = recognizedDefault;
-  }
+  const recognized = recognizedOption === void 0 ? recognizedDefault : { __proto__: null, ...recognizedOption, ...recognizedDefault };
   for (const parameter of protectedHeader.crit) {
-    if (!recognized.has(parameter)) {
+    if (!(parameter in recognized)) {
       throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
     }
-    if (joseHeader[parameter] === void 0) {
+    if (!Object.hasOwn(joseHeader, parameter) || joseHeader[parameter] === void 0) {
       throw new Err(`Extension Header Parameter "${parameter}" is missing`);
     }
-    if (recognized.get(parameter) && protectedHeader[parameter] === void 0) {
+    if (recognized[parameter] && (!Object.hasOwn(protectedHeader, parameter) || protectedHeader[parameter] === void 0)) {
       throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
     }
   }
-  return new Set(protectedHeader.crit);
+  return protectedHeader.crit;
+}
+
+// node_modules/jose/dist/webapi/lib/signing.js
+async function getSigKey(entry, key, usage) {
+  if (key instanceof Uint8Array) {
+    return crypto.subtle.importKey("raw", key, entry.subtle, false, [
+      usage
+    ]);
+  }
+  checkCryptoKey(key, entry.subtle, usage);
+  if (entry.minRsaBits)
+    checkModulusLength(entry.alg, key);
+  return key;
+}
+async function verify(entry, key, signature, data) {
+  const cryptoKey = await getSigKey(entry, key, "verify");
+  try {
+    return await crypto.subtle.verify(entry.signing, cryptoKey, signature, data);
+  } catch {
+    return false;
+  }
 }
 
 // node_modules/jose/dist/webapi/lib/jws_algorithms.js
-var sig = { public: ["verify"], private: ["sign"] };
+var sig = [["verify"], ["sign"]];
 function hmac(bits) {
   const subtle = { name: "HMAC", hash: `SHA-${bits}` };
-  return { kty: ["oct"], symmetric: true, subtle, operation: subtle, usages: sig };
+  return { kty: ["oct"], secret: true, subtle, signing: subtle, usages: sig };
 }
-function rsa(name, bits, saltLength) {
+function rsa(bits, saltLength) {
+  const name = saltLength ? "RSA-PSS" : "RSASSA-PKCS1-v1_5";
   const subtle = { name, hash: `SHA-${bits}` };
   return {
     kty: ["RSA"],
     subtle,
-    operation: saltLength ? { ...subtle, saltLength } : subtle,
+    signing: saltLength ? { ...subtle, saltLength } : subtle,
     usages: sig,
-    minModulusLength: 2048
+    minRsaBits: 2048
   };
 }
 function ecdsa(crv, bits) {
@@ -33810,7 +34655,7 @@ function ecdsa(crv, bits) {
     kty: ["EC"],
     crv,
     subtle: { name: "ECDSA", namedCurve: crv },
-    operation: { name: "ECDSA", hash: `SHA-${bits}` },
+    signing: { name: "ECDSA", hash: `SHA-${bits}` },
     usages: sig
   };
 }
@@ -33820,16 +34665,17 @@ function eddsa() {
     kty: ["OKP"],
     crv: "Ed25519",
     subtle,
-    operation: subtle,
+    signing: subtle,
     usages: sig
   };
 }
-function mldsa(name) {
+function mldsa(bits) {
+  const name = `ML-DSA-${bits}`;
   const subtle = { name };
   return {
     kty: ["AKP"],
     subtle,
-    operation: subtle,
+    signing: subtle,
     usages: sig
   };
 }
@@ -33837,56 +34683,51 @@ var JWS = table({
   HS256: hmac(256),
   HS384: hmac(384),
   HS512: hmac(512),
-  RS256: rsa("RSASSA-PKCS1-v1_5", 256),
-  RS384: rsa("RSASSA-PKCS1-v1_5", 384),
-  RS512: rsa("RSASSA-PKCS1-v1_5", 512),
-  PS256: rsa("RSA-PSS", 256, 32),
-  PS384: rsa("RSA-PSS", 384, 48),
-  PS512: rsa("RSA-PSS", 512, 64),
+  RS256: rsa(256),
+  RS384: rsa(384),
+  RS512: rsa(512),
+  PS256: rsa(256, 32),
+  PS384: rsa(384, 48),
+  PS512: rsa(512, 64),
   ES256: ecdsa("P-256", 256),
   ES384: ecdsa("P-384", 384),
   ES512: ecdsa("P-521", 512),
   EdDSA: eddsa(),
   Ed25519: eddsa(),
-  "ML-DSA-44": mldsa("ML-DSA-44"),
-  "ML-DSA-65": mldsa("ML-DSA-65"),
-  "ML-DSA-87": mldsa("ML-DSA-87")
+  "ML-DSA-44": mldsa(44),
+  "ML-DSA-65": mldsa(65),
+  "ML-DSA-87": mldsa(87)
 });
 function jwsAlgorithm(alg) {
-  const entry = JWS[alg];
+  const entry = typeof alg === "string" ? JWS[alg] : void 0;
   if (!entry) {
     throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
   }
   return entry;
 }
-function maybeJWSAlgorithm(alg) {
-  return JWS[alg];
-}
 
 // node_modules/jose/dist/webapi/lib/jws_verify.js
 function prepareVerify(options) {
-  return {
-    algorithms: options && validateAlgorithms("algorithms", options.algorithms),
-    crit: options?.crit
-  };
+  return [options && validateAlgorithms("algorithms", options.algorithms), options?.crit];
 }
 async function verifySignature(jws, shared, key) {
+  const { protected: encodedProtected, header, payload: inputPayload } = jws;
   let parsedProt = {};
-  if (jws.protected) {
-    parsedProt = parseJoseHeader(jws.protected, JWSInvalid, "JWS Protected Header is invalid");
+  if (encodedProtected) {
+    parsedProt = parseJoseHeader(encodedProtected, JWSInvalid, "JWS Protected Header is invalid");
   }
   let joseHeader;
-  if (jws.header !== void 0) {
-    if (!isDisjoint(parsedProt, jws.header)) {
+  if (header !== void 0) {
+    if (!isDisjoint(parsedProt, header)) {
       throw new JWSInvalid("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");
     }
-    joseHeader = { ...parsedProt, ...jws.header };
+    joseHeader = { ...parsedProt, ...header };
   } else {
     joseHeader = parsedProt;
   }
-  const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, shared.crit, parsedProt, joseHeader);
+  const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, shared[1], parsedProt, joseHeader);
   let b64 = true;
-  if (extensions.has("b64")) {
+  if (extensions.includes("b64")) {
     b64 = parsedProt.b64;
     if (typeof b64 !== "boolean") {
       throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
@@ -33896,14 +34737,14 @@ async function verifySignature(jws, shared, key) {
   if (typeof alg !== "string" || !alg) {
     throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
   }
-  if (shared.algorithms && !shared.algorithms.has(alg)) {
+  if (shared[0] && !shared[0].has(alg)) {
     throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
   }
   if (b64) {
-    if (typeof jws.payload !== "string") {
+    if (typeof inputPayload !== "string") {
       throw new JWSInvalid("JWS Payload must be a string");
     }
-  } else if (typeof jws.payload !== "string" && !(jws.payload instanceof Uint8Array)) {
+  } else if (typeof inputPayload !== "string" && !(inputPayload instanceof Uint8Array)) {
     throw new JWSInvalid("JWS Payload must be a string or an Uint8Array instance");
   }
   let resolvedKey = false;
@@ -33912,7 +34753,7 @@ async function verifySignature(jws, shared, key) {
     resolvedKey = true;
   }
   const entry = jwsAlgorithm(alg);
-  const data = concat(jws.protected !== void 0 ? encode3(jws.protected) : new Uint8Array(), encode3("."), typeof jws.payload === "string" ? b64 ? shared.b64p ??= encodeBase64url(jws.payload, "payload", JWSInvalid) : encoder.encode(jws.payload) : jws.payload);
+  const data = concat(encodedProtected !== void 0 ? encode3(encodedProtected) : new Uint8Array(), encode3("."), typeof inputPayload === "string" ? b64 ? shared[2] ??= encodeBase64url(inputPayload, "payload", JWSInvalid) : encoder.encode(inputPayload) : inputPayload);
   const signature = decodeBase64url(jws.signature, "signature", JWSInvalid);
   const k = await prepareKey(entry, key, "verify");
   const verified = await verify(entry, k, signature, data);
@@ -33921,13 +34762,13 @@ async function verifySignature(jws, shared, key) {
   }
   let payload;
   if (b64) {
-    payload = decodeBase64url(jws.payload, "payload", JWSInvalid);
-  } else if (typeof jws.payload === "string") {
-    payload = encoder.encode(jws.payload);
+    payload = decodeBase64url(inputPayload, "payload", JWSInvalid);
+  } else if (typeof inputPayload === "string") {
+    payload = encoder.encode(inputPayload);
   } else {
-    payload = jws.payload;
+    payload = inputPayload;
   }
-  return { payload, parsedProt, b64, key: k, resolvedKey };
+  return [payload, parsedProt, b64, k, resolvedKey];
 }
 async function verifyCompact(jws, shared, key) {
   if (jws instanceof Uint8Array) {
@@ -33945,56 +34786,23 @@ async function verifyCompact(jws, shared, key) {
 
 // node_modules/jose/dist/webapi/lib/jwt_claims_set.js
 var epoch = (date3) => Math.floor(date3.getTime() / 1e3);
-var minute = 60;
-var hour = minute * 60;
-var day = hour * 24;
-var week = day * 7;
-var year = day * 365.25;
+var multipliers = {
+  s: 1,
+  m: 60,
+  h: 3600,
+  d: 86400,
+  w: 604800,
+  y: 31557600
+};
 var REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
+var checkFailed = "check_failed";
 function secs(str) {
   const matched = REGEX.exec(str);
   if (!matched || matched[4] && matched[1]) {
     throw new TypeError("Invalid time period format");
   }
   const value = parseFloat(matched[2]);
-  const unit = matched[3].toLowerCase();
-  let numericDate;
-  switch (unit) {
-    case "sec":
-    case "secs":
-    case "second":
-    case "seconds":
-    case "s":
-      numericDate = Math.round(value);
-      break;
-    case "minute":
-    case "minutes":
-    case "min":
-    case "mins":
-    case "m":
-      numericDate = Math.round(value * minute);
-      break;
-    case "hour":
-    case "hours":
-    case "hr":
-    case "hrs":
-    case "h":
-      numericDate = Math.round(value * hour);
-      break;
-    case "day":
-    case "days":
-    case "d":
-      numericDate = Math.round(value * day);
-      break;
-    case "week":
-    case "weeks":
-    case "w":
-      numericDate = Math.round(value * week);
-      break;
-    default:
-      numericDate = Math.round(value * year);
-      break;
-  }
+  const numericDate = Math.round(value * multipliers[matched[3][0].toLowerCase()]);
   if (matched[1] === "-" || matched[4] === "ago") {
     return -numericDate;
   }
@@ -34017,10 +34825,22 @@ var checkAudiencePresence = (audPayload, audOption) => {
     return audOption.includes(audPayload);
   }
   if (Array.isArray(audPayload)) {
-    return audOption.some(Set.prototype.has.bind(new Set(audPayload)));
+    return audOption.some((aud) => audPayload.includes(aud));
   }
   return false;
 };
+function validateNumericDate(payload, claim, required2 = false) {
+  const value = payload[claim];
+  if (value === void 0 && !required2)
+    return void 0;
+  if (typeof value !== "number") {
+    throw new JWTClaimValidationFailed(`"${claim}" claim must be a number`, payload, claim, "invalid");
+  }
+  return value;
+}
+function unexpectedClaim(payload, claim) {
+  throw new JWTClaimValidationFailed(`unexpected "${claim}" claim value`, payload, claim, checkFailed);
+}
 function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
   let payload;
   try {
@@ -34032,7 +34852,7 @@ function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
   }
   const { typ } = options;
   if (typ && (typeof protectedHeader.typ !== "string" || normalizeTyp(protectedHeader.typ) !== normalizeTyp(typ))) {
-    throw new JWTClaimValidationFailed('unexpected "typ" JWT header value', payload, "typ", "check_failed");
+    throw new JWTClaimValidationFailed('unexpected "typ" JWT header value', payload, "typ", checkFailed);
   }
   const { requiredClaims = [], issuer, subject, audience, maxTokenAge } = options;
   const presenceCheck = [...requiredClaims];
@@ -34045,63 +34865,53 @@ function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
   if (issuer !== void 0)
     presenceCheck.push("iss");
   for (const claim of new Set(presenceCheck.reverse())) {
-    if (!(claim in payload)) {
+    if (!Object.hasOwn(payload, claim)) {
       throw new JWTClaimValidationFailed(`missing required "${claim}" claim`, payload, claim, "missing");
     }
   }
   if (issuer !== void 0 && !(Array.isArray(issuer) ? issuer : [issuer]).includes(payload.iss)) {
-    throw new JWTClaimValidationFailed('unexpected "iss" claim value', payload, "iss", "check_failed");
+    unexpectedClaim(payload, "iss");
   }
   if (subject !== void 0 && payload.sub !== subject) {
-    throw new JWTClaimValidationFailed('unexpected "sub" claim value', payload, "sub", "check_failed");
+    unexpectedClaim(payload, "sub");
   }
   if (audience !== void 0 && !checkAudiencePresence(payload.aud, typeof audience === "string" ? [audience] : audience)) {
-    throw new JWTClaimValidationFailed('unexpected "aud" claim value', payload, "aud", "check_failed");
-  }
-  let tolerance;
-  switch (typeof options.clockTolerance) {
-    case "string":
-      tolerance = secs(options.clockTolerance);
-      break;
-    case "number":
-      tolerance = options.clockTolerance;
-      break;
-    case "undefined":
-      tolerance = 0;
-      break;
-    default:
+    unexpectedClaim(payload, "aud");
+  }
+  const { clockTolerance } = options;
+  let tolerance = 0;
+  if (typeof clockTolerance === "string") {
+    tolerance = secs(clockTolerance);
+  } else if (clockTolerance !== void 0) {
+    if (typeof clockTolerance !== "number") {
       throw new TypeError("Invalid clockTolerance option type");
+    }
+    tolerance = clockTolerance;
   }
   validateInput("clockTolerance option", tolerance);
   const { currentDate } = options;
   const now = validateInput("currentDate option", epoch(currentDate || /* @__PURE__ */ new Date()));
-  if ((payload.iat !== void 0 || maxTokenAge !== void 0) && typeof payload.iat !== "number") {
-    throw new JWTClaimValidationFailed('"iat" claim must be a number', payload, "iat", "invalid");
-  }
-  if (payload.nbf !== void 0) {
-    if (typeof payload.nbf !== "number") {
-      throw new JWTClaimValidationFailed('"nbf" claim must be a number', payload, "nbf", "invalid");
-    }
-    if (payload.nbf > now + tolerance) {
-      throw new JWTClaimValidationFailed('"nbf" claim timestamp check failed', payload, "nbf", "check_failed");
+  const iat = validateNumericDate(payload, "iat", maxTokenAge !== void 0);
+  const nbf = validateNumericDate(payload, "nbf");
+  if (nbf !== void 0) {
+    if (nbf > now + tolerance) {
+      throw new JWTClaimValidationFailed('"nbf" claim timestamp check failed', payload, "nbf", checkFailed);
     }
   }
-  if (payload.exp !== void 0) {
-    if (typeof payload.exp !== "number") {
-      throw new JWTClaimValidationFailed('"exp" claim must be a number', payload, "exp", "invalid");
-    }
-    if (payload.exp <= now - tolerance) {
-      throw new JWTExpired('"exp" claim timestamp check failed', payload, "exp", "check_failed");
+  const exp = validateNumericDate(payload, "exp");
+  if (exp !== void 0) {
+    if (exp <= now - tolerance) {
+      throw new JWTExpired('"exp" claim timestamp check failed', payload, "exp", checkFailed);
     }
   }
   if (maxTokenAge !== void 0) {
-    const age = now - payload.iat;
+    const age = now - iat;
     const max = typeof maxTokenAge === "number" ? maxTokenAge : secs(maxTokenAge);
     if (age - tolerance > max) {
-      throw new JWTExpired('"iat" claim timestamp check failed (too far in the past)', payload, "iat", "check_failed");
+      throw new JWTExpired('"iat" claim timestamp check failed (too far in the past)', payload, "iat", checkFailed);
     }
     if (age < 0 - tolerance) {
-      throw new JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', payload, "iat", "check_failed");
+      throw new JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', payload, "iat", checkFailed);
     }
   }
   return payload;
@@ -34110,21 +34920,21 @@ function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
 // node_modules/jose/dist/webapi/jwt/verify.js
 async function jwtVerify(jwt, key, options) {
   const verified = await verifyCompact(jwt, prepareVerify(options), key);
-  if (!verified.b64) {
+  if (!verified[2]) {
     throw new JWTInvalid("JWTs MUST NOT use unencoded payload");
   }
-  const payload = validateClaimsSet(verified.parsedProt, verified.payload, options);
-  const result = { payload, protectedHeader: verified.parsedProt };
+  const payload = validateClaimsSet(verified[1], verified[0], options);
+  const result = { payload, protectedHeader: verified[1] };
   if (typeof key === "function") {
-    return { ...result, key: verified.key };
+    return { ...result, key: verified[3] };
   }
   return result;
 }
 
 // node_modules/jose/dist/webapi/jwks/local.js
 function signatureAlgorithm(alg) {
-  const entry = typeof alg === "string" ? maybeJWSAlgorithm(alg) : void 0;
-  if (!entry || entry.symmetric) {
+  const entry = typeof alg === "string" ? JWS[alg] : void 0;
+  if (!entry || entry.secret) {
     throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
   }
   return entry;
@@ -34134,10 +34944,7 @@ function isJWKSLike(jwks) {
     return false;
   }
   const { keys } = jwks;
-  return Array.isArray(keys) && keys.every(isJWKLike);
-}
-function isJWKLike(key) {
-  return isObject2(key);
+  return Array.isArray(keys) && keys.every(isObject2);
 }
 var LocalJWKSetImpl = class {
   #jwks;
@@ -34154,25 +34961,7 @@ var LocalJWKSetImpl = class {
   async getKey(protectedHeader, token) {
     const { alg, kid } = { ...protectedHeader, ...token?.header };
     const entry = signatureAlgorithm(alg);
-    const candidates = this.#jwks.keys.filter((jwk2) => {
-      let candidate = entry.kty.includes(jwk2.kty);
-      if (candidate && typeof kid === "string") {
-        candidate = kid === jwk2.kid;
-      }
-      if (candidate && (typeof jwk2.alg === "string" || jwk2.kty === "AKP")) {
-        candidate = alg === jwk2.alg;
-      }
-      if (candidate && typeof jwk2.use === "string") {
-        candidate = jwk2.use === "sig";
-      }
-      if (candidate && Array.isArray(jwk2.key_ops)) {
-        candidate = jwk2.key_ops.includes("verify");
-      }
-      if (candidate && entry.crv) {
-        candidate = jwk2.crv === entry.crv;
-      }
-      return candidate;
-    });
+    const candidates = this.#jwks.keys.filter((jwk2) => entry.kty.includes(jwk2.kty) && (typeof kid !== "string" || kid === jwk2.kid) && (!(typeof jwk2.alg === "string" || jwk2.kty === "AKP") || alg === jwk2.alg) && (typeof jwk2.use !== "string" || jwk2.use === "sig") && (!Array.isArray(jwk2.key_ops) || jwk2.key_ops.includes("verify")) && (!entry.crv || jwk2.crv === entry.crv));
     const { 0: jwk, length } = candidates;
     if (length === 0) {
       throw new JWKSNoMatchingKey();
@@ -34194,7 +34983,7 @@ var LocalJWKSetImpl = class {
   }
 };
 async function importWithAlgCache(cache2, jwk, entry) {
-  const cached3 = cache2.get(jwk) || cache2.set(jwk, {}).get(jwk);
+  const cached3 = cache2.get(jwk) || cache2.set(jwk, { __proto__: null }).get(jwk);
   if (cached3[entry.alg] === void 0) {
     const key = await jwkToKey(entry, { ...jwk, alg: entry.alg, ext: true });
     if (key.type !== "public") {
@@ -34207,13 +34996,8 @@ async function importWithAlgCache(cache2, jwk, entry) {
 function createLocalJWKSet(jwks) {
   const set = new LocalJWKSetImpl(jwks);
   const localJWKSet = async (protectedHeader, token) => set.getKey(protectedHeader, token);
-  Object.defineProperties(localJWKSet, {
-    jwks: {
-      value: () => structuredClone(set.jwks()),
-      enumerable: false,
-      configurable: false,
-      writable: false
-    }
+  Object.defineProperty(localJWKSet, "jwks", {
+    value: () => structuredClone(set.jwks())
   });
   return localJWKSet;
 }
@@ -34225,7 +35009,7 @@ function isCloudflareWorkers() {
 var USER_AGENT;
 if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) {
   const NAME = "jose";
-  const VERSION2 = "v6.2.5";
+  const VERSION2 = "v6.2.8";
   USER_AGENT = `${NAME}/${VERSION2}`;
 }
 var customFetch = Symbol();
@@ -34279,10 +35063,11 @@ var RemoteJWKSetImpl = class {
       throw new TypeError("url must be an instance of URL");
     }
     this.#url = new URL(url.href);
-    this.#timeoutDuration = typeof options?.timeoutDuration === "number" ? options?.timeoutDuration : 5e3;
-    this.#cooldownDuration = typeof options?.cooldownDuration === "number" ? options?.cooldownDuration : 3e4;
-    this.#cacheMaxAge = typeof options?.cacheMaxAge === "number" ? options?.cacheMaxAge : 6e5;
-    this.#headers = new Headers(options?.headers);
+    const opts = options ?? {};
+    this.#timeoutDuration = typeof opts.timeoutDuration === "number" ? opts.timeoutDuration : 5e3;
+    this.#cooldownDuration = typeof opts.cooldownDuration === "number" ? opts.cooldownDuration : 3e4;
+    this.#cacheMaxAge = typeof opts.cacheMaxAge === "number" ? opts.cacheMaxAge : 6e5;
+    this.#headers = new Headers(opts.headers);
     if (USER_AGENT && !this.#headers.has("User-Agent")) {
       this.#headers.set("User-Agent", USER_AGENT);
     }
@@ -34290,10 +35075,11 @@ var RemoteJWKSetImpl = class {
       this.#headers.set("accept", "application/json");
       this.#headers.append("accept", "application/jwk-set+json");
     }
-    this.#customFetch = options?.[customFetch];
-    if (options?.[jwksCache] !== void 0) {
-      this.#cache = options?.[jwksCache];
-      if (isFreshJwksCache(options?.[jwksCache], this.#cacheMaxAge)) {
+    this.#customFetch = opts[customFetch];
+    const cache2 = opts[jwksCache];
+    if (cache2 !== void 0) {
+      this.#cache = cache2;
+      if (isFreshJwksCache(cache2, this.#cacheMaxAge)) {
         this.#jwksTimestamp = this.#cache.uat;
         this.#local = createLocalJWKSet(this.#cache.jwks);
       }
@@ -34302,11 +35088,14 @@ var RemoteJWKSetImpl = class {
   pendingFetch() {
     return !!this.#pendingFetch;
   }
+  #validFor(duration3) {
+    return typeof this.#jwksTimestamp === "number" && Date.now() < this.#jwksTimestamp + duration3;
+  }
   coolingDown() {
-    return typeof this.#jwksTimestamp === "number" ? Date.now() < this.#jwksTimestamp + this.#cooldownDuration : false;
+    return this.#validFor(this.#cooldownDuration);
   }
   fresh() {
-    return typeof this.#jwksTimestamp === "number" ? Date.now() < this.#jwksTimestamp + this.#cacheMaxAge : false;
+    return this.#validFor(this.#cacheMaxAge);
   }
   jwks() {
     return this.#local?.jwks();
@@ -34338,10 +35127,8 @@ var RemoteJWKSetImpl = class {
         this.#cache.jwks = json;
       }
       this.#jwksTimestamp = Date.now();
+    }).finally(() => {
       this.#pendingFetch = void 0;
-    }).catch((err) => {
-      this.#pendingFetch = void 0;
-      throw err;
     });
     await this.#pendingFetch;
   }
@@ -34352,30 +35139,23 @@ function createRemoteJWKSet(url, options) {
   Object.defineProperties(remoteJWKSet, {
     coolingDown: {
       get: () => set.coolingDown(),
-      enumerable: true,
-      configurable: false
+      enumerable: true
     },
     fresh: {
       get: () => set.fresh(),
-      enumerable: true,
-      configurable: false
+      enumerable: true
     },
     reload: {
       value: () => set.reload(),
-      enumerable: true,
-      configurable: false,
-      writable: false
+      enumerable: true
     },
     reloading: {
       get: () => set.pendingFetch(),
-      enumerable: true,
-      configurable: false
+      enumerable: true
     },
     jwks: {
       value: () => set.jwks(),
-      enumerable: true,
-      configurable: false,
-      writable: false
+      enumerable: true
     }
   });
   return remoteJWKSet;
@@ -36697,6 +37477,8 @@ var STATELESS_SUPPORTED_VERSIONS = [
 ];
 var STATELESS_SERVER_INFO_KEY = "io.modelcontextprotocol/serverInfo";
 var STATELESS_LOG_LEVEL_KEY = "io.modelcontextprotocol/logLevel";
+var TRACEPARENT_KEY = "traceparent";
+var TRACESTATE_KEY2 = "tracestate";
 var SPEC_2026_07_28 = "2026-07-28";
 var TASKS_EXTENSION_ID = "io.modelcontextprotocol/tasks";
 var STATELESS_FALLBACK_VERSION = "2026-07-28";
@@ -36704,6 +37486,13 @@ var JSONRPC_INVALID_PARAMS = ErrorCode.InvalidParams;
 var MCP_HEADER_MISMATCH = -32020;
 var MCP_MISSING_REQUIRED_CLIENT_CAPABILITY = -32021;
 var MCP_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+function readTraceContext(meta2) {
+  const traceContext = parseTraceParent(
+    meta2[TRACEPARENT_KEY],
+    meta2[TRACESTATE_KEY2]
+  );
+  return traceContext ? { traceContext } : {};
+}
 var MCP_LOG_LEVELS = [
   "debug",
   "info",
@@ -36998,15 +37787,63 @@ var McpApp = class {
       async (request) => {
         const toolName = request.params.name;
         const args = request.params.arguments || {};
+        const meta2 = request.params._meta;
+        const clientMeta = isRecord5(meta2) ? {
+          ...readTraceContext(meta2),
+          ...readLogLevel(meta2) !== void 0 ? { logLevel: readLogLevel(meta2) } : {}
+        } : void 0;
         let result;
         try {
-          result = await this.executeToolCall(toolName, args);
+          result = await this.executeToolCall(
+            toolName,
+            args,
+            void 0,
+            void 0,
+            void 0,
+            clientMeta
+          );
         } catch (error2) {
           return this.handleToolError(error2, toolName);
         }
         return this.buildToolCallResult(toolName, result);
       }
     );
+    server.fallbackRequestHandler = (request) => {
+      if (request.method !== "server/discover") {
+        throw new McpError(ErrorCode.MethodNotFound, "Method not found");
+      }
+      return Promise.resolve(this.buildDiscoverResult());
+    };
+  }
+  /**
+   * The `server/discover` result (spec 2026-07-28, SEP-2575).
+   *
+   * Single source of truth for both transports. They used to be one inline
+   * object on the HTTP path; a stdio copy would have been the second place to
+   * forget `instructions` or a new capability.
+   *
+   * Always stamped as 2026-07-28 regardless of what the transport negotiated.
+   * That is deliberate but not free: nothing gates the method, so a peer that
+   * negotiated `2025-11-25` over stdio can call it and receive an envelope it
+   * never agreed to. The alternative is worse — stamping the negotiated version
+   * would make the probe answer "2025" to the client asking whether this server
+   * speaks 2026, which is the one question it exists to answer. Treat
+   * `server/discover` as a cross-version exception: its result describes what
+   * the server supports, not what the current transport negotiated.
+   */
+  buildDiscoverResult() {
+    return this.stampResult(
+      this.withCacheHints({
+        supportedVersions: [...STATELESS_SUPPORTED_VERSIONS],
+        capabilities: this.buildServerCapabilities(),
+        serverInfo: {
+          name: this.options.name,
+          version: this.options.version
+        },
+        ...this.options.instructions ? { instructions: this.options.instructions } : {}
+      }, SPEC_2026_07_28),
+      SPEC_2026_07_28
+    );
   }
   /**
    * Register tools with their handlers
@@ -37054,15 +37891,15 @@ var McpApp = class {
    * leave a half-registered tool behind.
    */
   indexMirroredParams(tool) {
-    const invalid = [];
+    const invalid2 = [];
     const mirrored = collectMirroredParams(
       tool.inputSchema,
-      (reason) => invalid.push(reason)
+      (reason) => invalid2.push(reason)
     );
-    if (invalid.length > 0) {
+    if (invalid2.length > 0) {
       throw new Error(
         `[McpApp] Tool "${tool.name}" has invalid x-mcp-header annotations:
-` + invalid.map((r) => `  - ${r}`).join("\n")
+` + invalid2.map((r) => `  - ${r}`).join("\n")
       );
     }
     if (mirrored.length > 0) this.mirroredParams.set(tool.name, mirrored);
@@ -37262,12 +38099,16 @@ var McpApp = class {
       ...mrtr?.inputResponses !== void 0 ? { inputResponses: mrtr.inputResponses } : {},
       ...mrtr?.retryVerified !== void 0 ? { retryVerified: mrtr.retryVerified } : {}
     };
-    const span = startToolCallSpan(toolName, {
-      "mcp.tool.name": toolName,
-      "mcp.server.name": this.options.name,
-      "mcp.transport": request ? "http" : "stdio",
-      "mcp.session.id": sessionId
-    });
+    const span = startToolCallSpan(
+      toolName,
+      {
+        "mcp.tool.name": toolName,
+        "mcp.server.name": this.options.name,
+        "mcp.transport": request ? "http" : "stdio",
+        "mcp.session.id": sessionId
+      },
+      clientMeta?.traceContext
+    );
     const queueMetrics = this.requestQueue.getMetrics();
     this.serverMetrics.setGauges({
       activeRequests: queueMetrics.inFlight,
@@ -37715,14 +38556,14 @@ var McpApp = class {
         return { allowed: true, retryAfterMs: 0 };
       }
       const ip = getClientIpFromHeaders(request.headers);
-      const context = {
+      const context2 = {
         ip,
         method: request.method,
         path: new URL(request.url).pathname,
         headers: overrideHeaders ?? request.headers,
         sessionId
       };
-      const key = httpRateLimit.keyExtractor?.(context) ?? ip;
+      const key = httpRateLimit.keyExtractor?.(context2) ?? ip;
       const behavior = httpRateLimit.onLimitExceeded ?? "reject";
       if (behavior === "wait") {
         try {
@@ -37920,18 +38761,7 @@ var McpApp = class {
           return c.json({
             jsonrpc: "2.0",
             id,
-            result: this.stampResult(
-              this.withCacheHints({
-                supportedVersions: [...STATELESS_SUPPORTED_VERSIONS],
-                capabilities: this.buildServerCapabilities(),
-                serverInfo: {
-                  name: this.options.name,
-                  version: this.options.version
-                },
-                ...this.options.instructions ? { instructions: this.options.instructions } : {}
-              }, statelessVersion),
-              statelessVersion
-            )
+            result: this.buildDiscoverResult()
           });
         }
         if (method === "initialize") {
@@ -37969,7 +38799,8 @@ var McpApp = class {
           const statelessClientMeta = isRecord5(params) && isRecord5(params["_meta"]) ? {
             clientInfo: params["_meta"][STATELESS_CLIENT_INFO_KEY],
             clientCapabilities: params["_meta"][STATELESS_CLIENT_CAPABILITIES_KEY],
-            logLevel: readLogLevel(params["_meta"])
+            logLevel: readLogLevel(params["_meta"]),
+            ...readTraceContext(params["_meta"])
           } : void 0;
           const mrtrEnabled = true;
           const ingressDigest = mrtrEnabled ? await paramsDigest({ arguments: args, name: toolName }) : "";
@@ -38545,7 +39376,7 @@ var McpApp = class {
               400
             );
           }
-          const store2 = this.taskStore;
+          const store = this.taskStore;
           const guard = this.requireTasksCapability(
             isRecord5(params) && isRecord5(params["_meta"]) ? params["_meta"][STATELESS_CLIENT_CAPABILITIES_KEY] : void 0,
             id
@@ -38585,7 +39416,7 @@ var McpApp = class {
             );
           }
           if (method === "tasks/get") {
-            const task = store2.get(taskId, caller);
+            const task = store.get(taskId, caller);
             if (task === null) {
               return c.json({
                 jsonrpc: "2.0",
@@ -38617,7 +39448,7 @@ var McpApp = class {
                 400
               );
             }
-            if (!store2.update(taskId, responses, caller)) {
+            if (!store.update(taskId, responses, caller)) {
               return c.json({
                 jsonrpc: "2.0",
                 id,
@@ -38633,7 +39464,7 @@ var McpApp = class {
               result: this.stampResult({}, statelessVersion)
             });
           }
-          if (!store2.cancel(taskId, caller)) {
+          if (!store.cancel(taskId, caller)) {
             return c.json({
               jsonrpc: "2.0",
               id,
@@ -39110,7 +39941,7 @@ var McpApp = class {
    * A violation is the server author's bug, so it surfaces as `-32603` rather
    * than being emitted as an invalid MRTR result for the client to puzzle over.
    */
-  async buildInputRequiredResult(signal, context) {
+  async buildInputRequiredResult(signal, context2) {
     const requests = signal.inputRequests;
     if (requests !== void 0 && !isRecord5(requests)) {
       return {
@@ -39131,7 +39962,7 @@ var McpApp = class {
     if (hasRequests) {
       const check = checkInputRequestCapabilities(
         requests,
-        context.clientCapabilities
+        context2.clientCapabilities
       );
       if (!check.ok) {
         if (check.kind === "malformed") {
@@ -39177,9 +40008,9 @@ var McpApp = class {
     if (key !== null) {
       const ttl = this.options.mrtr?.defaultTtlSecs ?? 300;
       requestState = await sealRequestState({
-        sub: context.principal,
-        method: context.method,
-        paramsDigest: context.paramsDigest,
+        sub: context2.principal,
+        method: context2.method,
+        paramsDigest: context2.paramsDigest,
         exp: Math.floor(Date.now() / 1e3) + ttl,
         nonce: bytesToHexLocal(crypto.getRandomValues(new Uint8Array(16)))
       }, key);
@@ -48064,8 +48895,8 @@ function getToolByName(name) {
 function linkDisambiguationRequestKey(inputPath) {
   return `link-disambiguation:${inputPath}`;
 }
-function supportsElicitation(context) {
-  return context?.clientCapabilities?.elicitation !== void 0;
+function supportsElicitation(context2) {
+  return context2?.clientCapabilities?.elicitation !== void 0;
 }
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -48099,16 +48930,16 @@ function buildInputRequiredSignal(ambiguity, inputPath) {
     }
   };
 }
-function selectedRecordId(ambiguity, inputPath, context) {
-  const hasRetryContext = context?.inputResponses !== void 0 || context?.retryVerified !== void 0;
+function selectedRecordId(ambiguity, inputPath, context2) {
+  const hasRetryContext = context2?.inputResponses !== void 0 || context2?.retryVerified !== void 0;
   if (!hasRetryContext) return void 0;
-  if (context?.retryVerified !== true) {
+  if (context2?.retryVerified !== true) {
     throw new Error(
       "[link-disambiguation] Refusing to use an unverified MRTR response."
     );
   }
   const key = linkDisambiguationRequestKey(inputPath);
-  const response = context.inputResponses?.[key];
+  const response = context2.inputResponses?.[key];
   if (!isRecord6(response)) {
     throw new Error(
       `[link-disambiguation] Missing or invalid response for "${key}".`