alus-ui-mcp 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,12 +1,964 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  __commonJS,
+  __export,
+  __toESM
+} from "./chunk-NSPRIPOP.js";
 
-// ../../node_modules/.pnpm/@tmcp+adapter-valibot@0.1.6_tmcp@1.19.4_typescript@5.9.3__valibot@1.4.1_typescript@5.9.3_/node_modules/@tmcp/adapter-valibot/src/index.js
-import { JsonSchemaAdapter } from "tmcp/adapter";
+// ../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/models.js
+var require_models = __commonJS({
+  "../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/models.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createJSONRPCNotification = exports.createJSONRPCRequest = exports.createJSONRPCSuccessResponse = exports.createJSONRPCErrorResponse = exports.JSONRPCErrorCode = exports.JSONRPCErrorException = exports.isJSONRPCResponses = exports.isJSONRPCResponse = exports.isJSONRPCRequests = exports.isJSONRPCRequest = exports.isJSONRPCID = exports.JSONRPC = void 0;
+    exports.JSONRPC = "2.0";
+    var isJSONRPCID = function(id) {
+      return typeof id === "string" || typeof id === "number" || id === null;
+    };
+    exports.isJSONRPCID = isJSONRPCID;
+    var isJSONRPCRequest = function(payload) {
+      return payload.jsonrpc === exports.JSONRPC && payload.method !== void 0 && payload.result === void 0 && payload.error === void 0;
+    };
+    exports.isJSONRPCRequest = isJSONRPCRequest;
+    var isJSONRPCRequests = function(payload) {
+      return Array.isArray(payload) && payload.every(exports.isJSONRPCRequest);
+    };
+    exports.isJSONRPCRequests = isJSONRPCRequests;
+    var isJSONRPCResponse = function(payload) {
+      return payload.jsonrpc === exports.JSONRPC && payload.id !== void 0 && (payload.result !== void 0 || payload.error !== void 0);
+    };
+    exports.isJSONRPCResponse = isJSONRPCResponse;
+    var isJSONRPCResponses = function(payload) {
+      return Array.isArray(payload) && payload.every(exports.isJSONRPCResponse);
+    };
+    exports.isJSONRPCResponses = isJSONRPCResponses;
+    var createJSONRPCError = function(code, message, data) {
+      var error = { code, message };
+      if (data != null) {
+        error.data = data;
+      }
+      return error;
+    };
+    var JSONRPCErrorException = (
+      /** @class */
+      (function(_super) {
+        __extends(JSONRPCErrorException2, _super);
+        function JSONRPCErrorException2(message, code, data) {
+          var _this = _super.call(this, message) || this;
+          Object.setPrototypeOf(_this, JSONRPCErrorException2.prototype);
+          _this.code = code;
+          _this.data = data;
+          return _this;
+        }
+        JSONRPCErrorException2.prototype.toObject = function() {
+          return createJSONRPCError(this.code, this.message, this.data);
+        };
+        return JSONRPCErrorException2;
+      })(Error)
+    );
+    exports.JSONRPCErrorException = JSONRPCErrorException;
+    var JSONRPCErrorCode;
+    (function(JSONRPCErrorCode2) {
+      JSONRPCErrorCode2[JSONRPCErrorCode2["ParseError"] = -32700] = "ParseError";
+      JSONRPCErrorCode2[JSONRPCErrorCode2["InvalidRequest"] = -32600] = "InvalidRequest";
+      JSONRPCErrorCode2[JSONRPCErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound";
+      JSONRPCErrorCode2[JSONRPCErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
+      JSONRPCErrorCode2[JSONRPCErrorCode2["InternalError"] = -32603] = "InternalError";
+    })(JSONRPCErrorCode = exports.JSONRPCErrorCode || (exports.JSONRPCErrorCode = {}));
+    var createJSONRPCErrorResponse = function(id, code, message, data) {
+      return {
+        jsonrpc: exports.JSONRPC,
+        id,
+        error: createJSONRPCError(code, message, data)
+      };
+    };
+    exports.createJSONRPCErrorResponse = createJSONRPCErrorResponse;
+    var createJSONRPCSuccessResponse = function(id, result) {
+      return {
+        jsonrpc: exports.JSONRPC,
+        id,
+        result: result !== null && result !== void 0 ? result : null
+      };
+    };
+    exports.createJSONRPCSuccessResponse = createJSONRPCSuccessResponse;
+    var createJSONRPCRequest = function(id, method, params) {
+      return {
+        jsonrpc: exports.JSONRPC,
+        id,
+        method,
+        params
+      };
+    };
+    exports.createJSONRPCRequest = createJSONRPCRequest;
+    var createJSONRPCNotification = function(method, params) {
+      return {
+        jsonrpc: exports.JSONRPC,
+        method,
+        params
+      };
+    };
+    exports.createJSONRPCNotification = createJSONRPCNotification;
+  }
+});
+
+// ../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/internal.js
+var require_internal = __commonJS({
+  "../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/internal.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DefaultErrorCode = void 0;
+    exports.DefaultErrorCode = 0;
+  }
+});
+
+// ../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/client.js
+var require_client = __commonJS({
+  "../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/client.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve2, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JSONRPCClient = void 0;
+    var models_1 = require_models();
+    var internal_1 = require_internal();
+    var JSONRPCClient2 = (
+      /** @class */
+      (function() {
+        function JSONRPCClient3(_send, createID) {
+          this._send = _send;
+          this.createID = createID;
+          this.idToResolveMap = /* @__PURE__ */ new Map();
+          this.id = 0;
+        }
+        JSONRPCClient3.prototype._createID = function() {
+          if (this.createID) {
+            return this.createID();
+          } else {
+            return ++this.id;
+          }
+        };
+        JSONRPCClient3.prototype.timeout = function(delay, overrideCreateJSONRPCErrorResponse) {
+          var _this = this;
+          if (overrideCreateJSONRPCErrorResponse === void 0) {
+            overrideCreateJSONRPCErrorResponse = function(id) {
+              return (0, models_1.createJSONRPCErrorResponse)(id, internal_1.DefaultErrorCode, "Request timeout");
+            };
+          }
+          var timeoutRequest = function(ids, request) {
+            var timeoutID = setTimeout(function() {
+              ids.forEach(function(id) {
+                var resolve2 = _this.idToResolveMap.get(id);
+                if (resolve2) {
+                  _this.idToResolveMap.delete(id);
+                  resolve2(overrideCreateJSONRPCErrorResponse(id));
+                }
+              });
+            }, delay);
+            return request().then(function(result) {
+              clearTimeout(timeoutID);
+              return result;
+            }, function(error) {
+              clearTimeout(timeoutID);
+              return Promise.reject(error);
+            });
+          };
+          var requestAdvanced = function(request, clientParams) {
+            var ids = (!Array.isArray(request) ? [request] : request).map(function(request2) {
+              return request2.id;
+            }).filter(isDefinedAndNonNull);
+            return timeoutRequest(ids, function() {
+              return _this.requestAdvanced(request, clientParams);
+            });
+          };
+          return {
+            request: function(method, params, clientParams) {
+              var id = _this._createID();
+              return timeoutRequest([id], function() {
+                return _this.requestWithID(method, params, clientParams, id);
+              });
+            },
+            requestAdvanced: function(request, clientParams) {
+              return requestAdvanced(request, clientParams);
+            }
+          };
+        };
+        JSONRPCClient3.prototype.request = function(method, params, clientParams) {
+          return this.requestWithID(method, params, clientParams, this._createID());
+        };
+        JSONRPCClient3.prototype.requestWithID = function(method, params, clientParams, id) {
+          return __awaiter(this, void 0, void 0, function() {
+            var request, response;
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  request = (0, models_1.createJSONRPCRequest)(id, method, params);
+                  return [4, this.requestAdvanced(request, clientParams)];
+                case 1:
+                  response = _a.sent();
+                  if (response.result !== void 0 && !response.error) {
+                    return [2, response.result];
+                  } else if (response.result === void 0 && response.error) {
+                    return [2, Promise.reject(new models_1.JSONRPCErrorException(response.error.message, response.error.code, response.error.data))];
+                  } else {
+                    return [2, Promise.reject(new Error("An unexpected error occurred"))];
+                  }
+                  return [
+                    2
+                    /*return*/
+                  ];
+              }
+            });
+          });
+        };
+        JSONRPCClient3.prototype.requestAdvanced = function(requests, clientParams) {
+          var _this = this;
+          var areRequestsOriginallyArray = Array.isArray(requests);
+          if (!Array.isArray(requests)) {
+            requests = [requests];
+          }
+          var requestsWithID = requests.filter(function(request) {
+            return isDefinedAndNonNull(request.id);
+          });
+          var promises = requestsWithID.map(function(request) {
+            return new Promise(function(resolve2) {
+              return _this.idToResolveMap.set(request.id, resolve2);
+            });
+          });
+          var promise = Promise.all(promises).then(function(responses) {
+            if (areRequestsOriginallyArray || !responses.length) {
+              return responses;
+            } else {
+              return responses[0];
+            }
+          });
+          return this.send(areRequestsOriginallyArray ? requests : requests[0], clientParams).then(function() {
+            return promise;
+          }, function(error) {
+            requestsWithID.forEach(function(request) {
+              _this.receive((0, models_1.createJSONRPCErrorResponse)(request.id, internal_1.DefaultErrorCode, error && error.message || "Failed to send a request"));
+            });
+            return promise;
+          });
+        };
+        JSONRPCClient3.prototype.notify = function(method, params, clientParams) {
+          var request = (0, models_1.createJSONRPCNotification)(method, params);
+          this.send(request, clientParams).then(void 0, function() {
+            return void 0;
+          });
+        };
+        JSONRPCClient3.prototype.send = function(payload, clientParams) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this._send(payload, clientParams)];
+            });
+          });
+        };
+        JSONRPCClient3.prototype.rejectAllPendingRequests = function(message) {
+          this.idToResolveMap.forEach(function(resolve2, id) {
+            return resolve2((0, models_1.createJSONRPCErrorResponse)(id, internal_1.DefaultErrorCode, message));
+          });
+          this.idToResolveMap.clear();
+        };
+        JSONRPCClient3.prototype.receive = function(responses) {
+          var _this = this;
+          if (!Array.isArray(responses)) {
+            responses = [responses];
+          }
+          responses.forEach(function(response) {
+            var resolve2 = _this.idToResolveMap.get(response.id);
+            if (resolve2) {
+              _this.idToResolveMap.delete(response.id);
+              resolve2(response);
+            }
+          });
+        };
+        return JSONRPCClient3;
+      })()
+    );
+    exports.JSONRPCClient = JSONRPCClient2;
+    var isDefinedAndNonNull = function(value) {
+      return value !== void 0 && value !== null;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/interfaces.js
+var require_interfaces = __commonJS({
+  "../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/interfaces.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/server.js
+var require_server = __commonJS({
+  "../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/server.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve2, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JSONRPCServer = void 0;
+    var models_1 = require_models();
+    var internal_1 = require_internal();
+    var createParseErrorResponse = function() {
+      return (0, models_1.createJSONRPCErrorResponse)(null, models_1.JSONRPCErrorCode.ParseError, "Parse error");
+    };
+    var createInvalidRequestResponse = function(request) {
+      return (0, models_1.createJSONRPCErrorResponse)((0, models_1.isJSONRPCID)(request.id) ? request.id : null, models_1.JSONRPCErrorCode.InvalidRequest, "Invalid Request");
+    };
+    var createMethodNotFoundResponse = function(id) {
+      return (0, models_1.createJSONRPCErrorResponse)(id, models_1.JSONRPCErrorCode.MethodNotFound, "Method not found");
+    };
+    var JSONRPCServer2 = (
+      /** @class */
+      (function() {
+        function JSONRPCServer3(options) {
+          if (options === void 0) {
+            options = {};
+          }
+          var _a;
+          this.mapErrorToJSONRPCErrorResponse = defaultMapErrorToJSONRPCErrorResponse;
+          this.nameToMethodDictionary = {};
+          this.middleware = null;
+          this.errorListener = (_a = options.errorListener) !== null && _a !== void 0 ? _a : console.warn;
+        }
+        JSONRPCServer3.prototype.hasMethod = function(name) {
+          return !!this.nameToMethodDictionary[name];
+        };
+        JSONRPCServer3.prototype.addMethod = function(name, method) {
+          this.addMethodAdvanced(name, this.toJSONRPCMethod(method));
+        };
+        JSONRPCServer3.prototype.removeMethod = function(name) {
+          delete this.nameToMethodDictionary[name];
+        };
+        JSONRPCServer3.prototype.toJSONRPCMethod = function(method) {
+          return function(request, serverParams) {
+            var response = method(request.params, serverParams);
+            return Promise.resolve(response).then(function(result) {
+              return mapResultToJSONRPCResponse(request.id, result);
+            });
+          };
+        };
+        JSONRPCServer3.prototype.addMethodAdvanced = function(name, method) {
+          var _a;
+          this.nameToMethodDictionary = __assign(__assign({}, this.nameToMethodDictionary), (_a = {}, _a[name] = method, _a));
+        };
+        JSONRPCServer3.prototype.receiveJSON = function(json, serverParams) {
+          var request = this.tryParseRequestJSON(json);
+          if (request) {
+            return this.receive(request, serverParams);
+          } else {
+            return Promise.resolve(createParseErrorResponse());
+          }
+        };
+        JSONRPCServer3.prototype.tryParseRequestJSON = function(json) {
+          try {
+            return JSON.parse(json);
+          } catch (_a) {
+            return null;
+          }
+        };
+        JSONRPCServer3.prototype.receive = function(request, serverParams) {
+          if (Array.isArray(request)) {
+            return this.receiveMultiple(request, serverParams);
+          } else {
+            return this.receiveSingle(request, serverParams);
+          }
+        };
+        JSONRPCServer3.prototype.receiveMultiple = function(requests, serverParams) {
+          return __awaiter(this, void 0, void 0, function() {
+            var responses;
+            var _this = this;
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  return [4, Promise.all(requests.map(function(request) {
+                    return _this.receiveSingle(request, serverParams);
+                  }))];
+                case 1:
+                  responses = _a.sent().filter(isNonNull);
+                  if (responses.length === 1) {
+                    return [2, responses[0]];
+                  } else if (responses.length) {
+                    return [2, responses];
+                  } else {
+                    return [2, null];
+                  }
+                  return [
+                    2
+                    /*return*/
+                  ];
+              }
+            });
+          });
+        };
+        JSONRPCServer3.prototype.receiveSingle = function(request, serverParams) {
+          return __awaiter(this, void 0, void 0, function() {
+            var method, response;
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  method = this.nameToMethodDictionary[request.method];
+                  if (!!(0, models_1.isJSONRPCRequest)(request)) return [3, 1];
+                  return [2, createInvalidRequestResponse(request)];
+                case 1:
+                  return [4, this.callMethod(method, request, serverParams)];
+                case 2:
+                  response = _a.sent();
+                  return [2, mapResponse(request, response)];
+              }
+            });
+          });
+        };
+        JSONRPCServer3.prototype.applyMiddleware = function() {
+          var middlewares = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            middlewares[_i] = arguments[_i];
+          }
+          if (this.middleware) {
+            this.middleware = this.combineMiddlewares(__spreadArray([
+              this.middleware
+            ], middlewares, true));
+          } else {
+            this.middleware = this.combineMiddlewares(middlewares);
+          }
+        };
+        JSONRPCServer3.prototype.combineMiddlewares = function(middlewares) {
+          if (!middlewares.length) {
+            return null;
+          } else {
+            return middlewares.reduce(this.middlewareReducer);
+          }
+        };
+        JSONRPCServer3.prototype.middlewareReducer = function(prevMiddleware, nextMiddleware) {
+          return function(next, request, serverParams) {
+            return prevMiddleware(function(request2, serverParams2) {
+              return nextMiddleware(next, request2, serverParams2);
+            }, request, serverParams);
+          };
+        };
+        JSONRPCServer3.prototype.callMethod = function(method, request, serverParams) {
+          var _this = this;
+          var callMethod = function(request2, serverParams2) {
+            if (method) {
+              return method(request2, serverParams2);
+            } else if (request2.id !== void 0) {
+              return Promise.resolve(createMethodNotFoundResponse(request2.id));
+            } else {
+              return Promise.resolve(null);
+            }
+          };
+          var onError = function(error) {
+            _this.errorListener('An unexpected error occurred while executing "'.concat(request.method, '" JSON-RPC method:'), error);
+            return Promise.resolve(_this.mapErrorToJSONRPCErrorResponseIfNecessary(request.id, error));
+          };
+          try {
+            return (this.middleware || noopMiddleware)(callMethod, request, serverParams).then(void 0, onError);
+          } catch (error) {
+            return onError(error);
+          }
+        };
+        JSONRPCServer3.prototype.mapErrorToJSONRPCErrorResponseIfNecessary = function(id, error) {
+          if (id !== void 0) {
+            return this.mapErrorToJSONRPCErrorResponse(id, error);
+          } else {
+            return null;
+          }
+        };
+        return JSONRPCServer3;
+      })()
+    );
+    exports.JSONRPCServer = JSONRPCServer2;
+    var isNonNull = function(value) {
+      return value !== null;
+    };
+    var noopMiddleware = function(next, request, serverParams) {
+      return next(request, serverParams);
+    };
+    var mapResultToJSONRPCResponse = function(id, result) {
+      if (id !== void 0) {
+        return (0, models_1.createJSONRPCSuccessResponse)(id, result);
+      } else {
+        return null;
+      }
+    };
+    var defaultMapErrorToJSONRPCErrorResponse = function(id, error) {
+      var _a;
+      var message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : "An unexpected error occurred";
+      var code = internal_1.DefaultErrorCode;
+      var data;
+      if (error instanceof models_1.JSONRPCErrorException) {
+        code = error.code;
+        data = error.data;
+      }
+      return (0, models_1.createJSONRPCErrorResponse)(id, code, message, data);
+    };
+    var mapResponse = function(request, response) {
+      if (response) {
+        return response;
+      } else if (request.id !== void 0) {
+        return (0, models_1.createJSONRPCErrorResponse)(request.id, models_1.JSONRPCErrorCode.InternalError, "Internal error");
+      } else {
+        return null;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/server-and-client.js
+var require_server_and_client = __commonJS({
+  "../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/server-and-client.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve2, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JSONRPCServerAndClient = void 0;
+    var models_1 = require_models();
+    var JSONRPCServerAndClient = (
+      /** @class */
+      (function() {
+        function JSONRPCServerAndClient2(server2, client, options) {
+          if (options === void 0) {
+            options = {};
+          }
+          var _a;
+          this.server = server2;
+          this.client = client;
+          this.errorListener = (_a = options.errorListener) !== null && _a !== void 0 ? _a : console.warn;
+        }
+        JSONRPCServerAndClient2.prototype.applyServerMiddleware = function() {
+          var _a;
+          var middlewares = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            middlewares[_i] = arguments[_i];
+          }
+          (_a = this.server).applyMiddleware.apply(_a, middlewares);
+        };
+        JSONRPCServerAndClient2.prototype.hasMethod = function(name) {
+          return this.server.hasMethod(name);
+        };
+        JSONRPCServerAndClient2.prototype.addMethod = function(name, method) {
+          this.server.addMethod(name, method);
+        };
+        JSONRPCServerAndClient2.prototype.addMethodAdvanced = function(name, method) {
+          this.server.addMethodAdvanced(name, method);
+        };
+        JSONRPCServerAndClient2.prototype.removeMethod = function(name) {
+          this.server.removeMethod(name);
+        };
+        JSONRPCServerAndClient2.prototype.timeout = function(delay) {
+          return this.client.timeout(delay);
+        };
+        JSONRPCServerAndClient2.prototype.request = function(method, params, clientParams) {
+          return this.client.request(method, params, clientParams);
+        };
+        JSONRPCServerAndClient2.prototype.requestAdvanced = function(jsonRPCRequest, clientParams) {
+          return this.client.requestAdvanced(jsonRPCRequest, clientParams);
+        };
+        JSONRPCServerAndClient2.prototype.notify = function(method, params, clientParams) {
+          this.client.notify(method, params, clientParams);
+        };
+        JSONRPCServerAndClient2.prototype.rejectAllPendingRequests = function(message) {
+          this.client.rejectAllPendingRequests(message);
+        };
+        JSONRPCServerAndClient2.prototype.receiveAndSend = function(payload, serverParams, clientParams) {
+          return __awaiter(this, void 0, void 0, function() {
+            var response, message;
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  if (!((0, models_1.isJSONRPCResponse)(payload) || (0, models_1.isJSONRPCResponses)(payload))) return [3, 1];
+                  this.client.receive(payload);
+                  return [3, 4];
+                case 1:
+                  if (!((0, models_1.isJSONRPCRequest)(payload) || (0, models_1.isJSONRPCRequests)(payload))) return [3, 3];
+                  return [4, this.server.receive(payload, serverParams)];
+                case 2:
+                  response = _a.sent();
+                  if (response) {
+                    return [2, this.client.send(response, clientParams)];
+                  }
+                  return [3, 4];
+                case 3:
+                  message = "Received an invalid JSON-RPC message";
+                  this.errorListener(message, payload);
+                  return [2, Promise.reject(new Error(message))];
+                case 4:
+                  return [
+                    2
+                    /*return*/
+                  ];
+              }
+            });
+          });
+        };
+        return JSONRPCServerAndClient2;
+      })()
+    );
+    exports.JSONRPCServerAndClient = JSONRPCServerAndClient;
+  }
+});
+
+// ../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/json-rpc-2.0@1.7.1/node_modules/json-rpc-2.0/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_client(), exports);
+    __exportStar(require_interfaces(), exports);
+    __exportStar(require_models(), exports);
+    __exportStar(require_server(), exports);
+    __exportStar(require_server_and_client(), exports);
+  }
+});
+
+// ../../node_modules/.pnpm/tmcp@1.19.4_typescript@5.9.3/node_modules/tmcp/src/adapter.js
+var JsonSchemaAdapter = class {
+  /**
+   * @param {TSchema} schema
+   * @returns {Promise<JSONSchema7>}
+   */
+  toJsonSchema(schema6) {
+    throw new Error("toJsonSchema method not implemented");
+  }
+};
 
 // ../../node_modules/.pnpm/@valibot+to-json-schema@1.7.0_valibot@1.4.1_typescript@5.9.3_/node_modules/@valibot/to-json-schema/dist/index.mjs
 function addError(errors, message) {
@@ -503,71 +1455,570 @@ var ValibotJsonSchemaAdapter = class extends JsonSchemaAdapter {
   }
 };
 
-// ../mcp-server/src/mcp/index.ts
-import { McpServer } from "tmcp";
-
-// ../mcp-server/src/mcp/handlers/tools/index.ts
-var tools_exports = {};
-__export(tools_exports, {
-  get_component: () => get_component,
-  get_component_demo: () => get_component_demo,
-  get_utils: () => get_utils,
-  list_components: () => list_components,
-  list_exports: () => list_exports,
-  search_components: () => search_components
-});
+// ../../node_modules/.pnpm/tmcp@1.19.4_typescript@5.9.3/node_modules/tmcp/src/index.js
+var import_json_rpc_2 = __toESM(require_dist(), 1);
+import { AsyncLocalStorage } from "async_hooks";
 
-// ../../node_modules/.pnpm/valibot@1.4.1_typescript@5.9.3/node_modules/valibot/dist/index.mjs
-var store$4;
-var DEFAULT_CONFIG = {
-  lang: void 0,
-  message: void 0,
-  abortEarly: void 0,
-  abortPipeEarly: void 0
-};
-// @__NO_SIDE_EFFECTS__
-function getGlobalConfig(config$1) {
-  if (!config$1 && !store$4) return DEFAULT_CONFIG;
+// ../../node_modules/.pnpm/uri-template-matcher@1.1.2/node_modules/uri-template-matcher/src/parser.js
+function parse_template(template) {
+  const parts = [];
+  let current_literal = "";
+  let i = 0;
+  while (i < template.length) {
+    const char = template[i];
+    if (char === "{") {
+      if (current_literal) {
+        parts.push({ type: "literal", value: current_literal });
+        current_literal = "";
+      }
+      const expression_start = i + 1;
+      let expression_end = expression_start;
+      let brace_count = 1;
+      while (expression_end < template.length && brace_count > 0) {
+        if (template[expression_end] === "{") {
+          brace_count++;
+        } else if (template[expression_end] === "}") {
+          brace_count--;
+        }
+        expression_end++;
+      }
+      if (brace_count > 0) {
+        throw new Error(`Unclosed expression in template: ${template}`);
+      }
+      const expression_content = template.slice(
+        expression_start,
+        expression_end - 1
+      );
+      const parsed_expression = parse_expression(expression_content);
+      parts.push(parsed_expression);
+      i = expression_end;
+    } else {
+      current_literal += char;
+      i++;
+    }
+  }
+  if (current_literal) {
+    parts.push({ type: "literal", value: current_literal });
+  }
+  return { template, parts };
+}
+function parse_expression(content) {
+  if (!content.trim()) {
+    throw new Error("Empty expression");
+  }
+  const first_char = content[0];
+  const operators = ["+", "#", ".", "/", ";", "?", "&"];
+  let operator = void 0;
+  let variables_part = content;
+  if (operators.includes(first_char)) {
+    operator = first_char;
+    variables_part = content.slice(1);
+  }
+  const variable_names = split_variables(variables_part);
+  const expressions = variable_names.map(parse_variable);
   return {
-    lang: config$1?.lang ?? store$4?.lang,
-    message: config$1?.message,
-    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
-    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+    type: "expression",
+    expressions,
+    operator
   };
 }
-var store$3;
-// @__NO_SIDE_EFFECTS__
-function getGlobalMessage(lang) {
-  return store$3?.get(lang);
+function split_variables(variables) {
+  const result = [];
+  let current = "";
+  let i = 0;
+  while (i < variables.length) {
+    const char = variables[i];
+    if (char === ",") {
+      if (current.trim()) {
+        result.push(current.trim());
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+    i++;
+  }
+  if (current.trim()) {
+    result.push(current.trim());
+  }
+  return result;
 }
-var store$2;
-// @__NO_SIDE_EFFECTS__
-function getSchemaMessage(lang) {
-  return store$2?.get(lang);
+function parse_variable(variable) {
+  let name = variable;
+  let prefix = void 0;
+  let explode = false;
+  if (name.endsWith("*")) {
+    explode = true;
+    name = name.slice(0, -1);
+  }
+  const colon_index = name.indexOf(":");
+  if (colon_index !== -1) {
+    const prefix_str = name.slice(colon_index + 1);
+    prefix = parseInt(prefix_str, 10);
+    if (isNaN(prefix) || prefix < 0) {
+      throw new Error(`Invalid prefix length: ${prefix_str}`);
+    }
+    name = name.slice(0, colon_index);
+  }
+  if (!name) {
+    throw new Error("Empty variable name");
+  }
+  return { name, prefix, explode };
 }
-var store$1;
-// @__NO_SIDE_EFFECTS__
-function getSpecificMessage(reference, lang) {
-  return store$1?.get(reference)?.get(lang);
+function match_uri(uri, parsed_template) {
+  const params = {};
+  const result = match_parts(uri, 0, parsed_template.parts, 0, params);
+  if (!result || result.uri_index !== uri.length) {
+    return null;
+  }
+  return params;
 }
-// @__NO_SIDE_EFFECTS__
-function _stringify(input) {
-  const type = typeof input;
-  if (type === "string") return `"${input}"`;
-  if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
-  if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-  return type;
+function match_parts(uri, uri_index, parts, part_index, params) {
+  if (part_index >= parts.length) {
+    return { uri_index };
+  }
+  const part = parts[part_index];
+  if (part.type === "literal") {
+    if (!uri.slice(uri_index).startsWith(part.value)) {
+      return null;
+    }
+    return match_parts(
+      uri,
+      uri_index + part.value.length,
+      parts,
+      part_index + 1,
+      params
+    );
+  } else {
+    const next_part = parts[part_index + 1];
+    const boundaries = find_expression_boundaries(
+      uri,
+      uri_index,
+      next_part
+    );
+    const sorted_boundaries = boundaries.sort((a, b) => {
+      if (next_part && next_part.type === "expression" && !next_part.operator) {
+        return b - a;
+      }
+      return a - b;
+    });
+    for (const boundary of sorted_boundaries) {
+      const segment = uri.slice(uri_index, boundary);
+      const temp_params = { ...params };
+      const match_result = match_simple_expression(
+        segment,
+        part,
+        temp_params,
+        uri,
+        uri_index
+      );
+      if (match_result) {
+        const rest_result = match_parts(
+          uri,
+          boundary,
+          parts,
+          part_index + 1,
+          temp_params
+        );
+        if (rest_result) {
+          Object.assign(params, temp_params);
+          return rest_result;
+        }
+      }
+    }
+    return null;
+  }
 }
-function _addIssue(context, label, dataset, config$1, other) {
-  const input = other && "input" in other ? other.input : dataset.value;
-  const expected = other?.expected ?? context.expects ?? null;
-  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
-  const issue = {
-    kind: context.kind,
-    type: context.type,
-    input,
-    expected,
-    received,
+function find_expression_boundaries(uri, start_index, next_part) {
+  const boundaries = [];
+  if (next_part && next_part.type === "literal") {
+    let search_index = start_index;
+    while (search_index < uri.length) {
+      const found_index = uri.indexOf(next_part.value, search_index);
+      if (found_index === -1) break;
+      boundaries.push(found_index);
+      search_index = found_index + 1;
+    }
+    if (boundaries.length === 0) {
+      return [];
+    }
+  } else if (next_part && next_part.type === "expression") {
+    const next_expr = (
+      /** @type {ExpressionPart} */
+      next_part
+    );
+    if (next_expr.operator === ".") {
+      for (let i = start_index; i < uri.length; i++) {
+        if (uri[i] === ".") {
+          boundaries.push(i);
+        }
+      }
+      boundaries.push(uri.length);
+    } else if (next_expr.operator === "/") {
+      for (let i = start_index; i < uri.length; i++) {
+        if (uri[i] === "/") {
+          boundaries.push(i);
+        }
+      }
+    } else {
+      for (let i = start_index; i <= uri.length; i++) {
+        boundaries.push(i);
+      }
+    }
+  } else {
+    boundaries.push(uri.length);
+  }
+  return boundaries.sort((a, b) => a - b);
+}
+function match_simple_expression(segment, expression, params, uri, uri_index) {
+  if (expression.type !== "expression") {
+    return false;
+  }
+  const operator = expression.operator;
+  switch (operator) {
+    case "+":
+      return handle_reserved_match(segment, expression, params);
+    case "#":
+      return handle_fragment_match(segment, expression, params);
+    case ".":
+      return handle_dot_match(segment, expression, params);
+    case "/":
+      return handle_path_match(segment, expression, params);
+    case ";":
+      return handle_semicolon_match(segment, expression, params);
+    case "?":
+    case "&":
+      return handle_query_match(segment, expression, params);
+    default:
+      return handle_simple_match(
+        segment,
+        expression,
+        params,
+        uri,
+        uri_index
+      );
+  }
+}
+function handle_fragment_match(segment, expression, params) {
+  if (expression.type !== "expression") {
+    return false;
+  }
+  if (!segment.startsWith("#")) {
+    for (const expr of expression.expressions) {
+      params[expr.name] = "";
+    }
+    return segment === "";
+  }
+  const fragment_content = segment.slice(1);
+  if (expression.expressions.length === 1) {
+    const expr = expression.expressions[0];
+    let value = fragment_content;
+    if (expr.prefix && value.length > expr.prefix) {
+      value = value.slice(0, expr.prefix);
+    }
+    params[expr.name] = decodeURIComponent(value);
+    return true;
+  } else {
+    const values = fragment_content.split(",");
+    for (let i = 0; i < expression.expressions.length; i++) {
+      const expr = expression.expressions[i];
+      let value = values[i] || "";
+      if (expr.prefix && value.length > expr.prefix) {
+        value = value.slice(0, expr.prefix);
+      }
+      params[expr.name] = decodeURIComponent(value);
+    }
+    return true;
+  }
+}
+function handle_reserved_match(segment, expression, params) {
+  if (expression.type !== "expression") {
+    return false;
+  }
+  if (expression.expressions.length === 1) {
+    const expr = expression.expressions[0];
+    let value = segment;
+    if (expr.prefix && value.length > expr.prefix) {
+      value = value.slice(0, expr.prefix);
+    }
+    params[expr.name] = decodeURIComponent(value);
+    return true;
+  } else {
+    const values = segment.split(",");
+    for (let i = 0; i < expression.expressions.length; i++) {
+      const expr = expression.expressions[i];
+      let value = values[i] || "";
+      if (expr.prefix && value.length > expr.prefix) {
+        value = value.slice(0, expr.prefix);
+      }
+      params[expr.name] = decodeURIComponent(value);
+    }
+    return true;
+  }
+}
+function handle_simple_match(segment, expression, params, uri, uri_index) {
+  if (expression.type !== "expression") {
+    return false;
+  }
+  if (expression.expressions.length === 1) {
+    const expr = expression.expressions[0];
+    let value = segment;
+    if (value.includes("/")) {
+      return false;
+    }
+    if (value === "" && uri_index + segment.length === uri.length && uri.endsWith("/")) {
+      return false;
+    }
+    if (expr.prefix && value.length > expr.prefix) {
+      value = value.slice(0, expr.prefix);
+    }
+    params[expr.name] = decodeURIComponent(value);
+    return true;
+  } else {
+    const values = segment.split(",");
+    for (let i = 0; i < expression.expressions.length; i++) {
+      const expr = expression.expressions[i];
+      let value = values[i] || "";
+      if (value.includes("/")) {
+        return false;
+      }
+      if (expr.prefix && value.length > expr.prefix) {
+        value = value.slice(0, expr.prefix);
+      }
+      params[expr.name] = decodeURIComponent(value);
+    }
+    return true;
+  }
+}
+function handle_dot_match(segment, expression, params) {
+  if (expression.type !== "expression") {
+    return false;
+  }
+  if (segment === "") {
+    for (const expr of expression.expressions) {
+      params[expr.name] = "";
+    }
+    return true;
+  }
+  const clean_segment = segment.startsWith(".") ? segment.slice(1) : segment;
+  if (expression.expressions.length === 1) {
+    const expr = expression.expressions[0];
+    if (expr.explode) {
+      const values = clean_segment.split(".");
+      params[expr.name] = values.map((v) => decodeURIComponent(v));
+    } else {
+      params[expr.name] = decodeURIComponent(clean_segment);
+    }
+    return true;
+  } else {
+    const values = clean_segment.split(".");
+    for (let i = 0; i < expression.expressions.length; i++) {
+      const expr = expression.expressions[i];
+      let value = values[i] || "";
+      if (expr.prefix && value.length > expr.prefix) {
+        value = value.slice(0, expr.prefix);
+      }
+      params[expr.name] = decodeURIComponent(value);
+    }
+    return true;
+  }
+}
+function handle_path_match(segment, expression, params) {
+  if (expression.type !== "expression") {
+    return false;
+  }
+  const clean_segment = segment.startsWith("/") ? segment.slice(1) : segment;
+  if (expression.expressions.length === 1) {
+    const expr = expression.expressions[0];
+    params[expr.name] = decodeURIComponent(clean_segment);
+    return true;
+  } else {
+    const values = clean_segment.split(",");
+    for (let i = 0; i < expression.expressions.length; i++) {
+      const expr = expression.expressions[i];
+      let value = values[i] || "";
+      if (expr.prefix && value.length > expr.prefix) {
+        value = value.slice(0, expr.prefix);
+      }
+      params[expr.name] = decodeURIComponent(value);
+    }
+    return true;
+  }
+}
+function handle_semicolon_match(segment, expression, params) {
+  if (expression.type !== "expression") {
+    return false;
+  }
+  const parts = segment.split(";").filter((p) => p);
+  for (const part of parts) {
+    const eq_index = part.indexOf("=");
+    if (eq_index !== -1) {
+      const key = part.slice(0, eq_index);
+      const value = part.slice(eq_index + 1);
+      const expr = expression.expressions.find((e) => e.name === key);
+      if (expr) {
+        params[expr.name] = decodeURIComponent(value);
+      }
+    }
+  }
+  return true;
+}
+function handle_query_match(segment, expression, params) {
+  if (expression.type !== "expression") {
+    return false;
+  }
+  const clean_segment = segment.replace(/^[?&]/, "");
+  if (expression.expressions.length === 1) {
+    const expr = expression.expressions[0];
+    if (expr.explode) {
+      const values = clean_segment.split("&");
+      params[expr.name] = values.map((v) => decodeURIComponent(v));
+    } else {
+      const parts = clean_segment.split("&");
+      for (const part of parts) {
+        const eq_index = part.indexOf("=");
+        if (eq_index !== -1) {
+          const key = part.slice(0, eq_index);
+          const value = part.slice(eq_index + 1);
+          if (key === expr.name) {
+            params[expr.name] = decodeURIComponent(value);
+          }
+        }
+      }
+    }
+  } else {
+    const parts = clean_segment.split("&");
+    for (const part of parts) {
+      const eq_index = part.indexOf("=");
+      if (eq_index !== -1) {
+        const key = part.slice(0, eq_index);
+        const value = part.slice(eq_index + 1);
+        const expr = expression.expressions.find((e) => e.name === key);
+        if (expr) {
+          params[expr.name] = decodeURIComponent(value);
+        }
+      }
+    }
+  }
+  return true;
+}
+
+// ../../node_modules/.pnpm/uri-template-matcher@1.1.2/node_modules/uri-template-matcher/src/matcher.js
+var UriTemplateMatcher = class {
+  /**
+   * Create a new UriTemplateMatcher instance
+   */
+  constructor() {
+    this.templates = [];
+  }
+  /**
+   * Add a URI template to the matcher
+   * @param {string} template - The URI template string to add
+   * @throws {Error} If template is invalid
+   */
+  add(template) {
+    if (typeof template !== "string") {
+      throw new Error("Template must be a string");
+    }
+    if (template !== "" && template.trim() === "") {
+      throw new Error("Template cannot be empty");
+    }
+    try {
+      const parsed = parse_template(template);
+      this.templates.push(parsed);
+    } catch (error) {
+      throw new Error(
+        `Invalid template: ${template} - ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Match a URI against all registered templates
+   * @param {string} uri - The URI to match
+   * @returns {MatchResult | null} Match result or null if no match found
+   * @throws {Error} If URI is invalid
+   */
+  match(uri) {
+    if (typeof uri !== "string") {
+      throw new Error("URI must be a string");
+    }
+    for (const template of this.templates) {
+      const params = match_uri(uri, template);
+      if (params !== null) {
+        return {
+          template: template.template,
+          params
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * Clear all registered templates
+   */
+  clear() {
+    this.templates = [];
+  }
+  /**
+   * Get all registered template strings
+   * @returns {string[]} Array of template strings
+   */
+  all() {
+    return this.templates.map((t) => t.template);
+  }
+};
+
+// ../../node_modules/.pnpm/valibot@1.4.1_typescript@5.9.3/node_modules/valibot/dist/index.mjs
+var store$4;
+var DEFAULT_CONFIG = {
+  lang: void 0,
+  message: void 0,
+  abortEarly: void 0,
+  abortPipeEarly: void 0
+};
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig(config$1) {
+  if (!config$1 && !store$4) return DEFAULT_CONFIG;
+  return {
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+  };
+}
+var store$3;
+// @__NO_SIDE_EFFECTS__
+function getGlobalMessage(lang) {
+  return store$3?.get(lang);
+}
+var store$2;
+// @__NO_SIDE_EFFECTS__
+function getSchemaMessage(lang) {
+  return store$2?.get(lang);
+}
+var store$1;
+// @__NO_SIDE_EFFECTS__
+function getSpecificMessage(reference, lang) {
+  return store$1?.get(reference)?.get(lang);
+}
+// @__NO_SIDE_EFFECTS__
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") return `"${input}"`;
+  if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+  if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  return type;
+}
+function _addIssue(context, label, dataset, config$1, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
     message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
     requirement: context.requirement,
     path: other?.path,
@@ -600,13 +2051,62 @@ function _getStandardProps(context) {
   return cached;
 }
 // @__NO_SIDE_EFFECTS__
+function _isValidObjectKey(object$1, key) {
+  return Object.prototype.hasOwnProperty.call(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+// @__NO_SIDE_EFFECTS__
 function _joinExpects(values$1, separator) {
   const list = [...new Set(values$1)];
   if (list.length > 1) return `(${list.join(` ${separator} `)})`;
   return list[0] ?? "never";
 }
+var ValiError = class extends Error {
+  /**
+  * Creates a Valibot error with useful information.
+  *
+  * @param issues The error issues.
+  */
+  constructor(issues) {
+    super(issues[0].message);
+    this.name = "ValiError";
+    this.issues = issues;
+  }
+};
+var BASE64_REGEX = /^(?:[\da-z+/]{4})*(?:[\da-z+/]{2}==|[\da-z+/]{3}=)?$/iu;
 var EMOJI_REGEX = new RegExp("^(?:[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|(?![\\p{Emoji_Modifier_Base}\\u{1F1E6}-\\u{1F1FF}])\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|(?![\\p{Emoji_Modifier_Base}\\u{1F1E6}-\\u{1F1FF}])\\p{Emoji_Presentation}))*)+$", "u");
 // @__NO_SIDE_EFFECTS__
+function base64(message$1) {
+  return {
+    kind: "validation",
+    type: "base64",
+    reference: base64,
+    async: false,
+    expects: null,
+    requirement: BASE64_REGEX,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "Base64", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function check(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "check",
+    reference: check,
+    async: false,
+    expects: null,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "input", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
 function description(description_) {
   return {
     kind: "metadata",
@@ -632,6 +2132,22 @@ function integer(message$1) {
   };
 }
 // @__NO_SIDE_EFFECTS__
+function maxLength(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "max_length",
+    reference: maxLength,
+    async: false,
+    expects: `<=${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && dataset.value.length > this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
 function maxValue(requirement, message$1) {
   return {
     kind: "validation",
@@ -680,6 +2196,39 @@ function minValue(requirement, message$1) {
   };
 }
 // @__NO_SIDE_EFFECTS__
+function regex(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "regex",
+    reference: regex,
+    async: false,
+    expects: `${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "format", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function startsWith(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "starts_with",
+    reference: startsWith,
+    async: false,
+    expects: `"${requirement}"`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !dataset.value.startsWith(this.requirement)) _addIssue(this, "start", dataset, config$1, { received: `"${dataset.value.slice(0, this.requirement.length)}"` });
+      return dataset;
+    }
+  };
+}
+var ABORT_EARLY_CONFIG = { abortEarly: true };
+// @__NO_SIDE_EFFECTS__
 function getFallback(schema6, dataset, config$1) {
   return typeof schema6.fallback === "function" ? schema6.fallback(dataset, config$1) : schema6.fallback;
 }
@@ -688,30 +2237,98 @@ function getDefault(schema6, dataset, config$1) {
   return typeof schema6.default === "function" ? schema6.default(dataset, config$1) : schema6.default;
 }
 // @__NO_SIDE_EFFECTS__
-function number(message$1) {
+function array(item, message$1) {
   return {
     kind: "schema",
-    type: "number",
-    reference: number,
-    expects: "number",
+    type: "array",
+    reference: array,
+    expects: "Array",
     async: false,
+    item,
     message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
     "~run"(dataset, config$1) {
-      if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0; key < input.length; key++) {
+          const value$1 = input[key];
+          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value$1
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path) issue.path.unshift(pathItem);
+              else issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = itemDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed) dataset.typed = false;
+          dataset.value.push(itemDataset.value);
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function boolean(message$1) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "boolean") dataset.typed = true;
       else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function object(entries$1, message$1) {
+function literal(literal_, message$1) {
   return {
     kind: "schema",
-    type: "object",
-    reference: object,
+    type: "literal",
+    reference: literal,
+    expects: /* @__PURE__ */ _stringify(literal_),
+    async: false,
+    literal: literal_,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === this.literal) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function looseObject(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "loose_object",
+    reference: looseObject,
     expects: "Object",
     async: false,
     entries: entries$1,
@@ -766,98 +2383,2745 @@ function object(entries$1, message$1) {
             if (config$1.abortEarly) break;
           }
         }
+        if (!dataset.issues || !config$1.abortEarly) {
+          for (const key in input) if (/* @__PURE__ */ _isValidObjectKey(input, key) && !(key in this.entries)) dataset.value[key] = input[key];
+        }
       } else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function optional(wrapped, default_) {
-  return {
-    kind: "schema",
-    type: "optional",
-    reference: optional,
-    expects: `(${wrapped.expects} | undefined)`,
-    async: false,
-    wrapped,
-    default: default_,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (dataset.value === void 0) {
-        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
-        if (dataset.value === void 0) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped["~run"](dataset, config$1);
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function number(message$1) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) issue.path.unshift(pathItem);
+                else issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly) break;
+          }
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function picklist(options, message$1) {
+  return {
+    kind: "schema",
+    type: "picklist",
+    reference: picklist,
+    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (this.options.includes(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function record(key, value$1, message$1) {
+  return {
+    kind: "schema",
+    type: "record",
+    reference: record,
+    expects: "Object",
+    async: false,
+    key,
+    value: value$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+          const entryValue = input[entryKey];
+          const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
+          if (keyDataset.issues) {
+            const pathItem = {
+              type: "object",
+              origin: "key",
+              input,
+              key: entryKey,
+              value: entryValue
+            };
+            for (const issue of keyDataset.issues) {
+              issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = keyDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
+          if (valueDataset.issues) {
+            const pathItem = {
+              type: "object",
+              origin: "value",
+              input,
+              key: entryKey,
+              value: entryValue
+            };
+            for (const issue of valueDataset.issues) {
+              if (issue.path) issue.path.unshift(pathItem);
+              else issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = valueDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
+          if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function strictObject(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "strict_object",
+    reference: strictObject,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) issue.path.unshift(pathItem);
+                else issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly) break;
+          }
+        }
+        if (!dataset.issues || !config$1.abortEarly) {
+          for (const key in input) if (!(key in this.entries)) {
+            _addIssue(this, "key", dataset, config$1, {
+              input: key,
+              expected: "never",
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            break;
+          }
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function string(message$1) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string") dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _subIssues(datasets) {
+  let issues;
+  if (datasets) for (const dataset of datasets) if (issues) for (const issue of dataset.issues) issues.push(issue);
+  else issues = dataset.issues;
+  return issues;
+}
+// @__NO_SIDE_EFFECTS__
+function union(options, message$1) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema6 of this.options) {
+        const optionDataset = schema6["~run"]({ value: dataset.value }, config$1);
+        if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+        else typedDatasets = [optionDataset];
+        else {
+          validDataset = optionDataset;
+          break;
+        }
+        else if (untypedDatasets) untypedDatasets.push(optionDataset);
+        else untypedDatasets = [optionDataset];
+      }
+      if (validDataset) return validDataset;
+      if (typedDatasets) {
+        if (typedDatasets.length === 1) return typedDatasets[0];
+        _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+        dataset.typed = true;
+      } else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+      else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function unknown() {
+  return {
+    kind: "schema",
+    type: "unknown",
+    reference: unknown,
+    expects: "unknown",
+    async: false,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset) {
+      dataset.typed = true;
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function variant(key, options, message$1) {
+  return {
+    kind: "schema",
+    type: "variant",
+    reference: variant,
+    expects: "Object",
+    async: false,
+    key,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        let outputDataset;
+        let maxDiscriminatorPriority = 0;
+        let invalidDiscriminatorKey = this.key;
+        let expectedDiscriminators = [];
+        const parseOptions = (variant$1, allKeys) => {
+          for (const schema6 of variant$1.options) {
+            if (schema6.type === "variant") parseOptions(schema6, new Set(allKeys).add(schema6.key));
+            else {
+              let keysAreValid = true;
+              let currentPriority = 0;
+              for (const currentKey of allKeys) {
+                const discriminatorSchema = schema6.entries[currentKey];
+                if (currentKey in input ? discriminatorSchema["~run"]({
+                  typed: false,
+                  value: input[currentKey]
+                }, ABORT_EARLY_CONFIG).issues : discriminatorSchema.type !== "exact_optional" && discriminatorSchema.type !== "optional" && discriminatorSchema.type !== "nullish") {
+                  keysAreValid = false;
+                  if (invalidDiscriminatorKey !== currentKey && (maxDiscriminatorPriority < currentPriority || maxDiscriminatorPriority === currentPriority && currentKey in input && !(invalidDiscriminatorKey in input))) {
+                    maxDiscriminatorPriority = currentPriority;
+                    invalidDiscriminatorKey = currentKey;
+                    expectedDiscriminators = [];
+                  }
+                  if (invalidDiscriminatorKey === currentKey) expectedDiscriminators.push(schema6.entries[currentKey].expects);
+                  break;
+                }
+                currentPriority++;
+              }
+              if (keysAreValid) {
+                const optionDataset = schema6["~run"]({ value: input }, config$1);
+                if (!outputDataset || !outputDataset.typed && optionDataset.typed) outputDataset = optionDataset;
+              }
+            }
+            if (outputDataset && !outputDataset.issues) break;
+          }
+        };
+        parseOptions(this, /* @__PURE__ */ new Set([this.key]));
+        if (outputDataset) return outputDataset;
+        _addIssue(this, "type", dataset, config$1, {
+          input: input[invalidDiscriminatorKey],
+          expected: /* @__PURE__ */ _joinExpects(expectedDiscriminators, "|"),
+          path: [{
+            type: "object",
+            origin: "value",
+            input,
+            key: invalidDiscriminatorKey,
+            value: input[invalidDiscriminatorKey]
+          }]
+        });
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function parse(schema6, input, config$1) {
+  const dataset = schema6["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  if (dataset.issues) throw new ValiError(dataset.issues);
+  return dataset.value;
+}
+// @__NO_SIDE_EFFECTS__
+function pipe(...pipe$1) {
+  return {
+    ...pipe$1[0],
+    pipe: pipe$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      for (const item of pipe$1) if (item.kind !== "metadata") {
+        if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+          dataset.typed = false;
+          break;
+        }
+        if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function safeParse(schema6, input, config$1) {
+  const dataset = schema6["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+
+// ../../node_modules/.pnpm/tmcp@1.19.4_typescript@5.9.3/node_modules/tmcp/src/validation/index.js
+var JSONRPC_VERSION = "2.0";
+var McpError = class extends Error {
+  /**
+   * @param {number} code
+   * @param {string} message
+   */
+  constructor(code, message) {
+    super(`MCP error ${code}: ${message}`);
+    this.name = "McpError";
+  }
+};
+var ProgressTokenSchema = union([
+  string(),
+  pipe(number(), integer())
+]);
+var CursorSchema = string();
+var RequestMetaSchema = looseObject({
+  /**
+   * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+   */
+  progressToken: optional(ProgressTokenSchema)
+});
+var BaseRequestParamsSchema = looseObject({
+  _meta: optional(RequestMetaSchema)
+});
+var RequestSchema = object({
+  method: string(),
+  params: optional(BaseRequestParamsSchema)
+});
+var BaseNotificationParamsSchema = looseObject({
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({}))
+});
+var NotificationSchema = object({
+  method: string(),
+  params: optional(BaseNotificationParamsSchema)
+});
+var ResultSchema = looseObject({
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({}))
+});
+var RequestIdSchema = union([
+  string(),
+  pipe(number(), integer())
+]);
+var JSONRPCRequestSchema = object({
+  jsonrpc: literal(JSONRPC_VERSION),
+  id: RequestIdSchema,
+  ...RequestSchema.entries
+});
+var JSONRPCNotificationSchema = object({
+  jsonrpc: literal(JSONRPC_VERSION),
+  ...NotificationSchema.entries
+});
+var JSONRPCResponseSchema = strictObject({
+  jsonrpc: literal(JSONRPC_VERSION),
+  id: RequestIdSchema,
+  result: ResultSchema
+});
+var JSONRPCErrorSchema = strictObject({
+  jsonrpc: literal(JSONRPC_VERSION),
+  id: RequestIdSchema,
+  error: object({
+    /**
+     * The error type that occurred.
+     */
+    code: pipe(number(), integer()),
+    /**
+     * A short description of the error. The message SHOULD be limited to a concise single sentence.
+     */
+    message: string(),
+    /**
+     * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
+     */
+    data: optional(unknown())
+  })
+});
+var JSONRPCMessageSchema = union([
+  JSONRPCRequestSchema,
+  JSONRPCNotificationSchema,
+  JSONRPCResponseSchema,
+  JSONRPCErrorSchema
+]);
+var EmptyResultSchema = strictObject({ ...ResultSchema.entries });
+var CancelledNotificationSchema = object({
+  ...NotificationSchema.entries,
+  method: literal("notifications/cancelled"),
+  params: object({
+    ...BaseNotificationParamsSchema.entries,
+    /**
+     * The ID of the request to cancel.
+     *
+     * This MUST correspond to the ID of a request previously issued in the same direction.
+     */
+    requestId: RequestIdSchema,
+    /**
+     * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.
+     */
+    reason: optional(string())
+  })
+});
+var BaseMetadataSchema = object({
+  /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
+  name: string(),
+  /**
+   * Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
+   * even by those unfamiliar with domain-specific terminology.
+   *
+   * If not provided, the name should be used for display (except for Tool,
+   * where `annotations.title` should be given precedence over using `name`,
+   * if present).
+   */
+  title: optional(string())
+});
+var IconSchema = object({
+  /**
+   * URL or data URI for the icon.
+   */
+  src: string(),
+  /**
+   * Optional MIME type for the icon.
+   */
+  mimeType: optional(string()),
+  /**
+   * Optional array of strings that specify sizes at which the icon can be used.
+   * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
+   *
+   * If not provided, the client should assume that the icon can be used at any size.
+   */
+  sizes: optional(array(string()))
+});
+var IconsSchema = object({
+  /**
+   * Optional set of sized icons that the client can display in a user interface.
+   *
+   * Clients that support rendering icons MUST support at least the following MIME types:
+   * - `image/png` - PNG images (safe, universal compatibility)
+   * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
+   *
+   * Clients that support rendering icons SHOULD also support:
+   * - `image/svg+xml` - SVG images (scalable but requires security precautions)
+   * - `image/webp` - WebP images (modern, efficient format)
+   */
+  icons: optional(array(IconSchema))
+});
+var ImplementationSchema = object({
+  ...BaseMetadataSchema.entries,
+  version: string(),
+  websiteUrl: optional(string()),
+  ...IconsSchema.entries
+});
+var ClientCapabilitiesSchema = looseObject({
+  /**
+   * Experimental, non-standard capabilities that the client supports.
+   */
+  experimental: optional(object({})),
+  /**
+   * Present if the client supports sampling from an LLM.
+   */
+  sampling: optional(object({})),
+  /**
+   * Present if the client supports eliciting user input.
+   */
+  elicitation: optional(object({})),
+  /**
+   * Present if the client supports listing roots.
+   */
+  roots: optional(
+    object({
+      /**
+       * Whether the client supports issuing notifications for changes to the roots list.
+       */
+      listChanged: optional(boolean())
+    })
+  )
+});
+var InitializeRequestParamsSchema = object({
+  ...BaseRequestParamsSchema.entries,
+  /**
+   * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well.
+   */
+  protocolVersion: string(),
+  capabilities: ClientCapabilitiesSchema,
+  clientInfo: ImplementationSchema
+});
+var InitializeRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("initialize"),
+  params: InitializeRequestParamsSchema
+});
+var ServerCapabilitiesSchema = object({
+  /**
+   * Experimental, non-standard capabilities that the server supports.
+   */
+  experimental: optional(object({})),
+  /**
+   * Present if the server supports sending log messages to the client.
+   */
+  logging: optional(object({})),
+  /**
+   * Present if the server supports sending completions to the client.
+   */
+  completions: optional(object({})),
+  /**
+   * Present if the server offers any prompt templates.
+   */
+  prompts: optional(
+    object({
+      /**
+       * Whether this server supports issuing notifications for changes to the prompt list.
+       */
+      listChanged: optional(boolean())
+    })
+  ),
+  /**
+   * Present if the server offers any resources to read.
+   */
+  resources: optional(
+    object({
+      /**
+       * Whether this server supports clients subscribing to resource updates.
+       */
+      subscribe: optional(boolean()),
+      /**
+       * Whether this server supports issuing notifications for changes to the resource list.
+       */
+      listChanged: optional(boolean())
+    })
+  ),
+  /**
+   * Present if the server offers any tools to call.
+   */
+  tools: optional(
+    object({
+      /**
+       * Whether this server supports issuing notifications for changes to the tool list.
+       */
+      listChanged: optional(boolean())
+    })
+  )
+});
+var InitializeResultSchema = object({
+  ...ResultSchema.entries,
+  /**
+   * The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect.
+   */
+  protocolVersion: string(),
+  capabilities: ServerCapabilitiesSchema,
+  serverInfo: ImplementationSchema,
+  /**
+   * Instructions describing how to use the server and its features.
+   *
+   * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt.
+   */
+  instructions: optional(string())
+});
+var InitializedNotificationSchema = object({
+  ...NotificationSchema.entries,
+  method: literal("notifications/initialized")
+});
+var PingRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("ping")
+});
+var ProgressSchema = object({
+  /**
+   * The progress thus far. This should increase every time progress is made, even if the total is unknown.
+   */
+  progress: number(),
+  /**
+   * Total number of items to process (or total progress required), if known.
+   */
+  total: optional(number()),
+  /**
+   * An optional message describing the current progress.
+   */
+  message: optional(string())
+});
+var ProgressNotificationSchema = object({
+  ...NotificationSchema.entries,
+  method: literal("notifications/progress"),
+  params: object({
+    ...BaseNotificationParamsSchema.entries,
+    ...ProgressSchema.entries,
+    /**
+     * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
+     */
+    progressToken: ProgressTokenSchema
+  })
+});
+var PaginatedRequestSchema = object({
+  ...RequestSchema.entries,
+  params: optional(
+    object({
+      ...BaseRequestParamsSchema.entries,
+      /**
+       * An opaque token representing the current pagination position.
+       * If provided, the server should return results starting after this cursor.
+       */
+      cursor: optional(CursorSchema)
+    })
+  )
+});
+var PaginatedResultSchema = object({
+  ...ResultSchema.entries,
+  /**
+   * An opaque token representing the pagination position after the last returned result.
+   * If present, there may be more results available.
+   */
+  nextCursor: optional(CursorSchema)
+});
+var ResourceContentsSchema = object({
+  /**
+   * The URI of this resource.
+   */
+  uri: string(),
+  /**
+   * The MIME type of this resource, if known.
+   */
+  mimeType: optional(string()),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({}))
+});
+var TextResourceContentsSchema = object({
+  ...ResourceContentsSchema.entries,
+  /**
+   * The text of the item. This must only be set if the item can actually be represented as text (not binary data).
+   */
+  text: string()
+});
+var BlobResourceContentsSchema = object({
+  ...ResourceContentsSchema.entries,
+  /**
+   * A base64-encoded string representing the binary data of the item.
+   */
+  blob: pipe(string(), base64())
+});
+var ResourceSchema = object({
+  ...BaseMetadataSchema.entries,
+  /**
+   * The URI of this resource.
+   */
+  uri: string(),
+  /**
+   * A description of what this resource represents.
+   *
+   * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
+   */
+  description: optional(string()),
+  /**
+   * The MIME type of this resource, if known.
+   */
+  mimeType: optional(string()),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({})),
+  ...IconsSchema.entries
+});
+var ResourceTemplateSchema = object({
+  ...BaseMetadataSchema.entries,
+  /**
+   * A URI template (according to RFC 6570) that can be used to construct resource URIs.
+   */
+  uriTemplate: string(),
+  /**
+   * A description of what this template is for.
+   *
+   * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
+   */
+  description: optional(string()),
+  /**
+   * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type.
+   */
+  mimeType: optional(string()),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({})),
+  ...IconsSchema.entries
+});
+var ListResourcesRequestSchema = object({
+  ...PaginatedRequestSchema.entries,
+  method: literal("resources/list")
+});
+var ListResourcesResultSchema = object({
+  ...PaginatedResultSchema.entries,
+  resources: array(ResourceSchema)
+});
+var ListResourceTemplatesRequestSchema = object({
+  ...PaginatedRequestSchema.entries,
+  method: literal("resources/templates/list")
+});
+var ListResourceTemplatesResultSchema = object({
+  ...PaginatedResultSchema.entries,
+  resourceTemplates: array(ResourceTemplateSchema)
+});
+var ReadResourceRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("resources/read"),
+  params: object({
+    ...BaseRequestParamsSchema.entries,
+    /**
+     * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it.
+     */
+    uri: string()
+  })
+});
+var ReadResourceResultSchema = object({
+  ...ResultSchema.entries,
+  contents: array(
+    union([TextResourceContentsSchema, BlobResourceContentsSchema])
+  )
+});
+var ResourceListChangedNotificationSchema = object({
+  ...NotificationSchema.entries,
+  method: literal("notifications/resources/list_changed")
+});
+var SubscribeRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("resources/subscribe"),
+  params: object({
+    ...BaseRequestParamsSchema.entries,
+    /**
+     * The URI of the resource to subscribe to. The URI can use any protocol; it is up to the server how to interpret it.
+     */
+    uri: string()
+  })
+});
+var UnsubscribeRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("resources/unsubscribe"),
+  params: object({
+    ...BaseRequestParamsSchema.entries,
+    /**
+     * The URI of the resource to unsubscribe from.
+     */
+    uri: string()
+  })
+});
+var ResourceUpdatedNotificationSchema = object({
+  ...NotificationSchema.entries,
+  method: literal("notifications/resources/updated"),
+  params: object({
+    ...BaseNotificationParamsSchema.entries,
+    /**
+     * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.
+     */
+    uri: string()
+  })
+});
+var PromptArgumentSchema = object({
+  /**
+   * The name of the argument.
+   */
+  name: string(),
+  /**
+   * A human-readable description of the argument.
+   */
+  description: optional(string()),
+  /**
+   * Whether this argument must be provided.
+   */
+  required: optional(boolean())
+});
+var PromptSchema = object({
+  ...BaseMetadataSchema.entries,
+  /**
+   * An optional description of what this prompt provides
+   */
+  description: optional(string()),
+  /**
+   * A list of arguments to use for templating the prompt.
+   */
+  arguments: optional(array(PromptArgumentSchema)),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({})),
+  ...IconsSchema.entries
+});
+var ListPromptsRequestSchema = object({
+  ...PaginatedRequestSchema.entries,
+  method: literal("prompts/list")
+});
+var ListPromptsResultSchema = object({
+  ...PaginatedResultSchema.entries,
+  prompts: array(PromptSchema)
+});
+var GetPromptRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("prompts/get"),
+  params: object({
+    ...BaseRequestParamsSchema.entries,
+    /**
+     * The name of the prompt or prompt template.
+     */
+    name: string(),
+    /**
+     * Arguments to use for templating the prompt.
+     */
+    arguments: optional(record(string(), string()))
+  })
+});
+var TextContentSchema = object({
+  type: literal("text"),
+  /**
+   * The text content of the message.
+   */
+  text: string(),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({}))
+});
+var ImageContentSchema = object({
+  type: literal("image"),
+  /**
+   * The base64-encoded image data.
+   */
+  data: pipe(string(), base64()),
+  /**
+   * The MIME type of the image. Different providers may support different image types.
+   */
+  mimeType: string(),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({}))
+});
+var AudioContentSchema = object({
+  type: literal("audio"),
+  /**
+   * The base64-encoded audio data.
+   */
+  data: pipe(string(), base64()),
+  /**
+   * The MIME type of the audio. Different providers may support different audio types.
+   */
+  mimeType: string(),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({}))
+});
+var EmbeddedResourceSchema = object({
+  type: literal("resource"),
+  resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({}))
+});
+var ResourceLinkSchema = object({
+  ...ResourceSchema.entries,
+  type: literal("resource_link")
+});
+var ContentBlockSchema = union([
+  TextContentSchema,
+  ImageContentSchema,
+  AudioContentSchema,
+  ResourceLinkSchema,
+  EmbeddedResourceSchema
+]);
+var PromptMessageSchema = object({
+  role: picklist(["user", "assistant"]),
+  content: ContentBlockSchema
+});
+var GetPromptResultSchema = object({
+  ...ResultSchema.entries,
+  /**
+   * An optional description for the prompt.
+   */
+  description: optional(string()),
+  messages: array(PromptMessageSchema)
+});
+var PromptListChangedNotificationSchema = object({
+  ...NotificationSchema.entries,
+  method: literal("notifications/prompts/list_changed")
+});
+var ToolAnnotationsSchema = object({
+  /**
+   * A human-readable title for the tool.
+   */
+  title: optional(string()),
+  /**
+   * If true, the tool does not modify its environment.
+   *
+   * Default: false
+   */
+  readOnlyHint: optional(boolean()),
+  /**
+   * If true, the tool may perform destructive updates to its environment.
+   * If false, the tool performs only additive updates.
+   *
+   * (This property is meaningful only when `readOnlyHint == false`)
+   *
+   * Default: true
+   */
+  destructiveHint: optional(boolean()),
+  /**
+   * If true, calling the tool repeatedly with the same arguments
+   * will have no additional effect on the its environment.
+   *
+   * (This property is meaningful only when `readOnlyHint == false`)
+   *
+   * Default: false
+   */
+  idempotentHint: optional(boolean()),
+  /**
+   * If true, this tool may interact with an "open world" of external
+   * entities. If false, the tool's domain of interaction is closed.
+   * For example, the world of a web search tool is open, whereas that
+   * of a memory tool is not.
+   *
+   * Default: true
+   */
+  openWorldHint: optional(boolean())
+});
+var ToolSchema = object({
+  ...BaseMetadataSchema.entries,
+  /**
+   * A human-readable description of the tool.
+   */
+  description: optional(string()),
+  /**
+   * A JSON Schema object defining the expected parameters for the tool.
+   */
+  inputSchema: object({
+    type: literal("object"),
+    properties: optional(object({})),
+    required: optional(array(string()))
+  }),
+  /**
+   * An optional JSON Schema object defining the structure of the tool's output returned in
+   * the structuredContent field of a CallToolResult.
+   */
+  outputSchema: optional(
+    object({
+      type: literal("object"),
+      properties: optional(object({})),
+      required: optional(array(string()))
+    })
+  ),
+  /**
+   * Optional additional tool information.
+   */
+  annotations: optional(ToolAnnotationsSchema),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({})),
+  ...IconsSchema.entries
+});
+var ListToolsRequestSchema = object({
+  ...PaginatedRequestSchema.entries,
+  method: literal("tools/list")
+});
+var ListToolsResultSchema = object({
+  ...PaginatedResultSchema.entries,
+  tools: array(ToolSchema)
+});
+var CallToolResultSchema = object({
+  ...ResultSchema.entries,
+  /**
+   * A list of content objects that represent the result of the tool call.
+   *
+   * If the Tool does not define an outputSchema, this field MUST be present in the result.
+   * For backwards compatibility, this field is always present, but it may be empty.
+   */
+  content: optional(array(ContentBlockSchema), []),
+  /**
+   * An object containing structured tool output.
+   *
+   * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
+   */
+  structuredContent: optional(looseObject({})),
+  /**
+   * Whether the tool call ended in an error.
+   *
+   * If not set, this is assumed to be false (the call was successful).
+   *
+   * Any errors that originate from the tool SHOULD be reported inside the result
+   * object, with `isError` set to true, _not_ as an MCP protocol-level error
+   * response. Otherwise, the LLM would not be able to see that an error occurred
+   * and self-correct.
+   *
+   * However, any errors in _finding_ the tool, an error indicating that the
+   * server does not support tool calls, or any other exceptional conditions,
+   * should be reported as an MCP error response.
+   */
+  isError: optional(boolean())
+});
+var CompatibilityCallToolResultSchema = union([
+  CallToolResultSchema,
+  object({ ...ResultSchema.entries, toolResult: unknown() })
+]);
+var CallToolRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("tools/call"),
+  params: object({
+    ...BaseRequestParamsSchema.entries,
+    name: string(),
+    arguments: optional(record(string(), unknown()))
+  })
+});
+var ToolListChangedNotificationSchema = object({
+  ...NotificationSchema.entries,
+  method: literal("notifications/tools/list_changed")
+});
+var LoggingLevelSchema = picklist([
+  "debug",
+  "info",
+  "notice",
+  "warning",
+  "error",
+  "critical",
+  "alert",
+  "emergency"
+]);
+var SetLevelRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("logging/setLevel"),
+  params: object({
+    ...BaseRequestParamsSchema.entries,
+    /**
+     * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message.
+     */
+    level: LoggingLevelSchema
+  })
+});
+var LoggingMessageNotificationSchema = object({
+  ...NotificationSchema.entries,
+  method: literal("notifications/message"),
+  params: object({
+    ...BaseNotificationParamsSchema.entries,
+    /**
+     * The severity of this log message.
+     */
+    level: LoggingLevelSchema,
+    /**
+     * An optional name of the logger issuing this message.
+     */
+    logger: optional(string()),
+    /**
+     * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.
+     */
+    data: unknown()
+  })
+});
+var ModelHintSchema = object({
+  /**
+   * A hint for a model name.
+   */
+  name: optional(string())
+});
+var ModelPreferencesSchema = object({
+  /**
+   * Optional hints to use for model selection.
+   */
+  hints: optional(array(ModelHintSchema)),
+  /**
+   * How much to prioritize cost when selecting a model.
+   */
+  costPriority: optional(pipe(number(), minValue(0), maxValue(1))),
+  /**
+   * How much to prioritize sampling speed (latency) when selecting a model.
+   */
+  speedPriority: optional(pipe(number(), minValue(0), maxValue(1))),
+  /**
+   * How much to prioritize intelligence and capabilities when selecting a model.
+   */
+  intelligencePriority: optional(
+    pipe(number(), minValue(0), maxValue(1))
+  )
+});
+var SamplingMessageSchema = object({
+  role: picklist(["user", "assistant"]),
+  content: union([
+    TextContentSchema,
+    ImageContentSchema,
+    AudioContentSchema
+  ])
+});
+var CreateMessageRequestParamsSchema = object({
+  ...BaseRequestParamsSchema.entries,
+  messages: array(SamplingMessageSchema),
+  /**
+   * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt.
+   */
+  systemPrompt: optional(string()),
+  /**
+   * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. The client MAY ignore this request.
+   */
+  includeContext: optional(
+    picklist(["none", "thisServer", "allServers"])
+  ),
+  temperature: optional(number()),
+  /**
+   * The maximum number of tokens to sample, as requested by the server. The client MAY choose to sample fewer tokens than requested.
+   */
+  maxTokens: pipe(number(), integer()),
+  stopSequences: optional(array(string())),
+  /**
+   * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
+   */
+  metadata: optional(object({})),
+  /**
+   * The server's preferences for which model to select.
+   */
+  modelPreferences: optional(ModelPreferencesSchema)
+});
+var CreateMessageRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("sampling/createMessage"),
+  params: CreateMessageRequestParamsSchema
+});
+var CreateMessageResultSchema = object({
+  ...ResultSchema.entries,
+  /**
+   * The name of the model that generated the message.
+   */
+  model: string(),
+  /**
+   * The reason why sampling stopped.
+   */
+  stopReason: optional(
+    union([
+      picklist(["endTurn", "stopSequence", "maxTokens"]),
+      string()
+    ])
+  ),
+  role: picklist(["user", "assistant"]),
+  content: variant("type", [
+    TextContentSchema,
+    ImageContentSchema,
+    AudioContentSchema
+  ])
+});
+var BooleanSchemaSchema = object({
+  type: literal("boolean"),
+  title: optional(string()),
+  description: optional(string()),
+  default: optional(boolean())
+});
+var StringSchemaSchema = object({
+  type: literal("string"),
+  title: optional(string()),
+  description: optional(string()),
+  minLength: optional(number()),
+  maxLength: optional(number()),
+  format: optional(picklist(["email", "uri", "date", "date-time"]))
+});
+var NumberSchemaSchema = object({
+  type: picklist(["number", "integer"]),
+  title: optional(string()),
+  description: optional(string()),
+  minimum: optional(number()),
+  maximum: optional(number())
+});
+var EnumSchemaSchema = object({
+  type: literal("string"),
+  title: optional(string()),
+  description: optional(string()),
+  enum: array(string()),
+  enumNames: optional(array(string()))
+});
+var PrimitiveSchemaDefinitionSchema = union([
+  BooleanSchemaSchema,
+  StringSchemaSchema,
+  NumberSchemaSchema,
+  EnumSchemaSchema
+]);
+var ElicitRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("elicitation/create"),
+  params: object({
+    ...BaseRequestParamsSchema.entries,
+    /**
+     * The message to present to the user.
+     */
+    message: string(),
+    /**
+     * The schema for the requested user input.
+     */
+    requestedSchema: object({
+      type: literal("object"),
+      properties: record(string(), PrimitiveSchemaDefinitionSchema),
+      required: optional(array(string()))
+    })
+  })
+});
+var ElicitResultSchema = object({
+  ...ResultSchema.entries,
+  /**
+   * The user's response action.
+   */
+  action: picklist(["accept", "decline", "cancel"]),
+  /**
+   * The collected user input content (only present if action is "accept").
+   */
+  content: optional(record(string(), unknown()))
+});
+var ResourceTemplateReferenceSchema = object({
+  type: literal("ref/resource"),
+  /**
+   * The URI or URI template of the resource.
+   */
+  uri: string()
+});
+var PromptReferenceSchema = object({
+  type: literal("ref/prompt"),
+  /**
+   * The name of the prompt or prompt template
+   */
+  name: string()
+});
+var CompleteRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("completion/complete"),
+  params: object({
+    ...BaseRequestParamsSchema.entries,
+    ref: union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
+    /**
+     * The argument's information
+     */
+    argument: object({
+      /**
+       * The name of the argument
+       */
+      name: string(),
+      /**
+       * The value of the argument to use for completion matching.
+       */
+      value: string()
+    }),
+    context: optional(
+      object({
+        /**
+         * Previously-resolved variables in a URI template or prompt.
+         */
+        arguments: optional(record(string(), string()))
+      })
+    )
+  })
+});
+var CompleteResultSchema = object({
+  ...ResultSchema.entries,
+  completion: object({
+    /**
+     * An array of completion values. Must not exceed 100 items.
+     */
+    values: pipe(array(string()), maxLength(100)),
+    /**
+     * The total number of completion options available. This can exceed the number of values actually sent in the response.
+     */
+    total: optional(pipe(number(), integer())),
+    /**
+     * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
+     */
+    hasMore: optional(boolean())
+  })
+});
+var RootSchema = object({
+  /**
+   * The URI identifying the root. This *must* start with file:// for now.
+   */
+  uri: pipe(string(), startsWith("file://")),
+  /**
+   * An optional name for the root.
+   */
+  name: optional(string()),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: optional(looseObject({}))
+});
+var ListRootsRequestSchema = object({
+  ...RequestSchema.entries,
+  method: literal("roots/list")
+});
+var ListRootsResultSchema = object({
+  ...ResultSchema.entries,
+  roots: array(RootSchema)
+});
+var RootsListChangedNotificationSchema = object({
+  ...NotificationSchema.entries,
+  method: literal("notifications/roots/list_changed")
+});
+var ClientRequestSchema = union([
+  PingRequestSchema,
+  InitializeRequestSchema,
+  CompleteRequestSchema,
+  SetLevelRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ReadResourceRequestSchema,
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema,
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+]);
+var ClientNotificationSchema = union([
+  CancelledNotificationSchema,
+  ProgressNotificationSchema,
+  InitializedNotificationSchema,
+  RootsListChangedNotificationSchema
+]);
+var ClientResultSchema = union([
+  EmptyResultSchema,
+  CreateMessageResultSchema,
+  ElicitResultSchema,
+  ListRootsResultSchema
+]);
+var ServerRequestSchema = union([
+  PingRequestSchema,
+  CreateMessageRequestSchema,
+  ElicitRequestSchema,
+  ListRootsRequestSchema
+]);
+var ServerNotificationSchema = union([
+  CancelledNotificationSchema,
+  ProgressNotificationSchema,
+  LoggingMessageNotificationSchema,
+  ResourceUpdatedNotificationSchema,
+  ResourceListChangedNotificationSchema,
+  ToolListChangedNotificationSchema,
+  PromptListChangedNotificationSchema
+]);
+var ServerResultSchema = union([
+  EmptyResultSchema,
+  InitializeResultSchema,
+  CompleteResultSchema,
+  GetPromptResultSchema,
+  ListPromptsResultSchema,
+  ListResourcesResultSchema,
+  ListResourceTemplatesResultSchema,
+  ReadResourceResultSchema,
+  CallToolResultSchema,
+  ListToolsResultSchema
+]);
+
+// ../../node_modules/.pnpm/tmcp@1.19.4_typescript@5.9.3/node_modules/tmcp/src/validation/version.js
+var SUPPORTED_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+var LATEST_PROTOCOL_VERSION = SUPPORTED_VERSIONS[0];
+var ProtocolVersionSchema = pipe(
+  string(),
+  regex(
+    /^\d{4}-\d{2}-\d{2}$/,
+    "Protocol version must be in YYYY-MM-DD format"
+  )
+);
+var SupportedProtocolVersionSchema = pipe(
+  ProtocolVersionSchema,
+  check(
+    (version) => SUPPORTED_VERSIONS.includes(version),
+    "Unsupported protocol version"
+  )
+);
+function is_supported_version(version) {
+  return SUPPORTED_VERSIONS.includes(version);
+}
+function get_latest_version() {
+  return LATEST_PROTOCOL_VERSION;
+}
+function get_supported_versions() {
+  return [...SUPPORTED_VERSIONS];
+}
+function negotiate_protocol_version(client_version) {
+  if (is_supported_version(client_version)) {
+    return client_version;
+  }
+  return get_latest_version();
+}
+function should_version_negotiation_fail(client_version) {
+  try {
+    const date = new Date(client_version);
+    const regex2 = /^\d{4}-\d{2}-\d{2}$/;
+    return !regex2.test(client_version) || isNaN(date.getTime());
+  } catch {
+    return true;
+  }
+}
+
+// ../../node_modules/.pnpm/tmcp@1.19.4_typescript@5.9.3/node_modules/tmcp/src/internal/utils.js
+function event(type, detail) {
+  return new CustomEvent(type, { detail });
+}
+
+// ../../node_modules/.pnpm/tmcp@1.19.4_typescript@5.9.3/node_modules/tmcp/src/index.js
+var Sqids;
+async function get_sqids() {
+  if (!Sqids) {
+    Sqids = new (await import("./sqids-5NZI6U3E.js")).default();
+  }
+  return Sqids;
+}
+async function encode_cursor(offset) {
+  return (await get_sqids()).encode([offset]);
+}
+async function decode_cursor(cursor) {
+  const [decoded] = (await get_sqids()).decode(cursor);
+  return decoded;
+}
+async function safe_enabled(enabled) {
+  try {
+    return await enabled();
+  } catch {
+    return false;
+  }
+}
+var McpServer = class {
+  #server = new import_json_rpc_2.JSONRPCServer();
+  /**
+   * @type {JSONRPCClient<"broadcast" | "standalone"> | undefined}
+   */
+  #client;
+  #options;
+  /**
+   * @type {Map<string, Tool<any, any>>}
+   */
+  #tools = /* @__PURE__ */ new Map();
+  /**
+   * @type {Map<string, Prompt<any>>}
+   */
+  #prompts = /* @__PURE__ */ new Map();
+  /**
+   * @type {Map<string, StoredResource>}
+   */
+  #resources = /* @__PURE__ */ new Map();
+  #templates = new UriTemplateMatcher();
+  /**
+   * @type {Array<{uri: string, name?: string}>}
+   */
+  roots = [];
+  /**
+   * @type {{ [ref: string]: Map<string, Partial<Record<string, Completion>>> }}
+   */
+  #completions = {
+    "ref/prompt": /* @__PURE__ */ new Map(),
+    "ref/resource": /* @__PURE__ */ new Map()
+  };
+  #event_target = new EventTarget();
+  /**
+   * @type {AsyncLocalStorage<Context<CustomContext> & { progress_token?: string }>}
+   */
+  #ctx_storage = new AsyncLocalStorage();
+  /**
+   * @param {ServerInfo} server_info
+   * @param {ServerOptions<StandardSchema>} options
+   */
+  constructor(server_info, options) {
+    this.#options = options;
+    this.#server.addMethod("initialize", (initialize_request) => {
+      try {
+        const validated_initialize = parse(
+          InitializeRequestParamsSchema,
+          initialize_request
+        );
+        if (should_version_negotiation_fail(
+          validated_initialize.protocolVersion
+        )) {
+          const error = new McpError(
+            -32602,
+            "Invalid protocol version format"
+          );
+          throw error;
+        }
+        const negotiated_version = negotiate_protocol_version(
+          validated_initialize.protocolVersion
+        );
+        this.#event_target.dispatchEvent(
+          event("initialize", validated_initialize)
+        );
+        return {
+          protocolVersion: negotiated_version,
+          ...options,
+          serverInfo: server_info
+        };
+      } catch (error) {
+        if (error instanceof McpError) {
+          throw error;
+        }
+        if (
+          /** @type {Error} */
+          error.message?.includes(
+            "Protocol version"
+          )
+        ) {
+          const rpc_error2 = new McpError(
+            -32602,
+            `Protocol version validation failed: ${/** @type {Error} */
+            error.message}. Server supports: ${get_supported_versions().join(", ")}`
+          );
+          throw rpc_error2;
+        }
+        const rpc_error = new McpError(
+          -32603,
+          `Initialization failed: ${/** @type {Error} */
+          error.message}`
+        );
+        throw rpc_error;
+      }
+    });
+    this.#server.addMethod("ping", () => {
+      return {};
+    });
+    this.#server.addMethod("notifications/initialized", () => {
+      return null;
+    });
+    this.#init_tools();
+    this.#init_prompts();
+    this.#init_resources();
+    this.#init_roots();
+    this.#init_completion();
+    this.#init_logging();
+  }
+  /**
+   * Utility method to specify the type of the custom context for this server instance without the need to specify the standard schema type.
+   * @example
+   * const server = new McpServer({ ... }, { ... }).withContext<{ name: string }>();
+   * @template {Record<string, unknown>} TCustom
+   * @returns {McpServer<StandardSchema, TCustom>}
+   */
+  withContext() {
+    return (
+      /** @type {McpServer<StandardSchema, TCustom>} */
+      /** @type {unknown} */
+      this
+    );
+  }
+  get #progress_token() {
+    return this.#ctx_storage.getStore()?.progress_token;
+  }
+  /**
+   * The context of the current request, include the session ID, any auth information, and custom data.
+   * @type {Context<CustomContext>}
+   */
+  get ctx() {
+    const { progress_token, ...rest } = this.#ctx_storage.getStore() ?? {};
+    return rest;
+  }
+  get #client_capabilities() {
+    return this.#ctx_storage.getStore()?.sessionInfo?.clientCapabilities;
+  }
+  /**
+   * Get the client information (name, version, etc.) of the client that initiated the current request...useful if you want to do something different based on the client.
+   * @deprecated Use `server.ctx.sessionInfo.clientInfo` instead.
+   */
+  currentClientInfo() {
+    return this.#ctx_storage.getStore()?.sessionInfo?.clientInfo;
+  }
+  /**
+   * Get the client capabilities of the client that initiated the current request, you can use this to verify the client support something before invoking the respective method.
+   * @deprecated Use `server.ctx.sessionInfo.clientCapabilities` instead.
+   */
+  currentClientCapabilities() {
+    return this.#client_capabilities;
+  }
+  #lazyily_create_client() {
+    if (!this.#client) {
+      this.#client = new import_json_rpc_2.JSONRPCClient((payload, kind) => {
+        if (kind === "broadcast") {
+          this.#event_target.dispatchEvent(
+            event("broadcast", { request: payload })
+          );
+          return;
+        }
+        this.#event_target.dispatchEvent(
+          event("send", { request: payload })
+        );
+      });
+    }
+  }
+  /**
+   * @template {keyof McpEvents} TEvent
+   * @param {TEvent} event
+   * @param {McpEvents[TEvent]} callback
+   * @param {AddEventListenerOptions} [options]
+   */
+  on(event2, callback, options) {
+    if (event2 === "send" || event2 === "broadcast") {
+      this.#lazyily_create_client();
+    }
+    const listener = (e) => {
+      callback(
+        /** @type {CustomEvent} */
+        e.detail
+      );
+    };
+    this.#event_target.addEventListener(event2, listener, options);
+    return () => {
+      this.#event_target.removeEventListener(event2, listener, options);
+    };
+  }
+  /**
+   * @param {string} method
+   * @param {JSONRPCParams} [params]
+   * @param {"broadcast" | "standalone"} [kind]
+   */
+  #notify(method, params, kind = "standalone") {
+    this.#client?.notify(method, params, kind);
+  }
+  /**
+   *
+   */
+  #init_tools() {
+    if (!this.#options.capabilities?.tools) return;
+    this.#server.addMethod("tools/list", async ({ cursor } = {}) => {
+      const all_tools = (await Promise.all(
+        [...this.#tools].map(async ([name, tool2]) => {
+          if (tool2.enabled != null && await safe_enabled(tool2.enabled) === false)
+            return null;
+          return {
+            name,
+            title: tool2.title || tool2.description,
+            description: tool2.description,
+            icons: tool2.icons,
+            _meta: tool2._meta,
+            inputSchema: tool2.schema && this.#options.adapter ? await this.#options.adapter.toJsonSchema(
+              tool2.schema
+            ) : { type: "object", properties: {} },
+            ...tool2.outputSchema && this.#options.adapter ? {
+              outputSchema: await this.#options.adapter.toJsonSchema(
+                tool2.outputSchema
+              )
+            } : {},
+            ...tool2.annotations ? {
+              annotations: tool2.annotations
+            } : {}
+          };
+        })
+      )).filter((tool2) => tool2 !== null);
+      const pagination_options = this.#options.pagination?.tools;
+      if (!pagination_options || pagination_options.size == null) {
+        return { tools: all_tools };
+      }
+      const page_length = pagination_options.size;
+      const offset = cursor ? await decode_cursor(cursor) : 0;
+      const start_index = offset;
+      const end_index = start_index + page_length;
+      const tools = all_tools.slice(start_index, end_index);
+      const has_next = end_index < all_tools.length;
+      const next_cursor = has_next ? await encode_cursor(end_index) : null;
+      return {
+        tools,
+        ...next_cursor && { nextCursor: next_cursor }
+      };
+    });
+    this.#server.addMethod(
+      "tools/call",
+      async ({ name, arguments: args }) => {
+        const tool2 = this.#tools.get(name);
+        if (!tool2) {
+          return (
+            /** @type {CallToolResult<any>} */
+            {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: `Tool ${name} not found`
+                }
+              ]
+            }
+          );
+        }
+        let validated_args = args;
+        if (tool2.schema) {
+          let validation_result = tool2.schema["~standard"].validate(args);
+          if (validation_result instanceof Promise)
+            validation_result = await validation_result;
+          if (validation_result.issues) {
+            return (
+              /** @type {CallToolResult<any>} */
+              {
+                isError: true,
+                content: [
+                  {
+                    type: "text",
+                    text: `Invalid arguments for tool ${name}: ${JSON.stringify(validation_result.issues)}`
+                  }
+                ]
+              }
+            );
+          }
+          validated_args = validation_result.value;
+        }
+        const tool_result = tool2.schema ? await tool2.execute(validated_args) : await tool2.execute();
+        const parsed_result = parse(
+          CallToolResultSchema,
+          tool_result
+        );
+        if (tool2.outputSchema && parsed_result.structuredContent !== void 0) {
+          let output_validation = tool2.outputSchema["~standard"].validate(parsed_result.structuredContent);
+          if (output_validation instanceof Promise)
+            output_validation = await output_validation;
+          if (output_validation.issues) {
+            return (
+              /** @type {CallToolResult<any>} */
+              {
+                isError: true,
+                content: [
+                  {
+                    type: "text",
+                    text: `Tool ${name} returned invalid structured content: ${JSON.stringify(output_validation.issues)}`
+                  }
+                ]
+              }
+            );
+          }
+          parsed_result.structuredContent = output_validation.value;
+        }
+        return parsed_result;
+      }
+    );
+  }
+  /**
+   *
+   */
+  #init_prompts() {
+    if (!this.#options.capabilities?.prompts) return;
+    this.#server.addMethod("prompts/list", async ({ cursor } = {}) => {
+      const all_prompts = (await Promise.all(
+        [...this.#prompts].map(async ([name, prompt]) => {
+          if (prompt.enabled != null && await safe_enabled(prompt.enabled) === false)
+            return null;
+          const arguments_schema = prompt.schema && this.#options.adapter ? await this.#options.adapter.toJsonSchema(
+            prompt.schema
+          ) : {
+            type: "object",
+            properties: (
+              /** @type {Record<string, {description: string}>} */
+              {}
+            ),
+            required: []
+          };
+          const keys = Object.keys(
+            arguments_schema.properties ?? {}
+          );
+          const required = arguments_schema.required ?? [];
+          return {
+            name,
+            title: prompt.title || prompt.description,
+            icons: prompt.icons,
+            description: prompt.description,
+            arguments: keys.map((key) => {
+              const property = arguments_schema.properties?.[key];
+              const description2 = property && property !== true ? property.description : key;
+              return {
+                name: key,
+                required: required.includes(key),
+                description: description2
+              };
+            })
+          };
+        })
+      )).filter((prompt) => prompt !== null);
+      const pagination_options = this.#options.pagination?.prompts;
+      if (!pagination_options || pagination_options.size == null) {
+        return { prompts: all_prompts };
+      }
+      const page_length = pagination_options.size;
+      const offset = cursor ? await decode_cursor(cursor) : 0;
+      const start_index = offset;
+      const end_index = start_index + page_length;
+      const prompts = all_prompts.slice(start_index, end_index);
+      const has_next = end_index < all_prompts.length;
+      const next_cursor = has_next ? await encode_cursor(end_index) : null;
+      return {
+        prompts,
+        ...next_cursor && { nextCursor: next_cursor }
+      };
+    });
+    this.#server.addMethod(
+      "prompts/get",
+      async ({ name, arguments: args }) => {
+        const prompt = this.#prompts.get(name);
+        if (!prompt) {
+          throw new McpError(-32601, `Prompt ${name} not found`);
+        }
+        if (!prompt.schema) {
+          return parse(
+            GetPromptResultSchema,
+            await prompt.execute()
+          );
+        }
+        let validated_args = prompt.schema["~standard"].validate(args);
+        if (validated_args instanceof Promise)
+          validated_args = await validated_args;
+        if (validated_args.issues) {
+          throw new McpError(
+            -32602,
+            `Invalid arguments for prompt ${name}: ${JSON.stringify(validated_args.issues)}`
+          );
+        }
+        return parse(
+          GetPromptResultSchema,
+          await prompt.execute(validated_args.value)
+        );
+      }
+    );
+  }
+  /**
+   *
+   */
+  #init_resources() {
+    if (!this.#options.capabilities?.resources) return;
+    if (this.#options.capabilities?.resources?.subscribe) {
+      this.#server.addMethod("resources/subscribe", async ({ uri }) => {
+        this.#event_target.dispatchEvent(
+          event("subscription", { uri, action: "add" })
+        );
+        return {};
+      });
+      this.#server.addMethod("resources/unsubscribe", async ({ uri }) => {
+        this.#event_target.dispatchEvent(
+          event("subscription", { uri, action: "remove" })
+        );
+        return {};
+      });
+    }
+    this.#server.addMethod("resources/list", async ({ cursor } = {}) => {
+      const all_resources = [];
+      for (const [uri, resource] of this.#resources) {
+        if (!resource.template) {
+          if (resource.enabled != null && await safe_enabled(resource.enabled) === false)
+            continue;
+          all_resources.push({
+            name: resource.name,
+            title: resource.title || resource.description,
+            description: resource.description,
+            uri,
+            mimeType: resource.mimeType,
+            icons: resource.icons
+          });
+        } else if (resource.list_resources) {
+          if (resource.enabled != null && await safe_enabled(resource.enabled) === false)
+            continue;
+          const template_resources = await resource.list_resources();
+          all_resources.push(...template_resources);
+        }
+      }
+      const pagination_options = this.#options.pagination?.resources;
+      if (!pagination_options || pagination_options.size == null) {
+        return { resources: all_resources };
+      }
+      const page_length = pagination_options.size;
+      const offset = cursor ? await decode_cursor(cursor) : 0;
+      const start_index = offset;
+      const end_index = start_index + page_length;
+      const resources = all_resources.slice(start_index, end_index);
+      const has_next = end_index < all_resources.length;
+      const next_cursor = has_next ? await encode_cursor(end_index) : null;
+      return {
+        resources,
+        ...next_cursor && { nextCursor: next_cursor }
+      };
+    });
+    this.#server.addMethod("resources/templates/list", async () => {
+      return {
+        resourceTemplates: (await Promise.all(
+          [...this.#resources].map(async ([uri, resource]) => {
+            if (!resource.template) return null;
+            if (resource.enabled != null && await safe_enabled(resource.enabled) === false)
+              return null;
+            return {
+              name: resource.name,
+              icons: resource.icons,
+              title: resource.title || resource.description,
+              description: resource.description,
+              mimeType: resource.mimeType,
+              uriTemplate: uri
+            };
+          })
+        )).filter((resource) => resource != null)
+      };
+    });
+    this.#server.addMethod("resources/read", async ({ uri }) => {
+      let resource = this.#resources.get(uri);
+      let params;
+      if (!resource) {
+        const match = this.#templates.match(uri);
+        if (match) {
+          resource = this.#resources.get(match.template);
+          params = match.params;
+        }
+        if (!resource) {
+          throw new McpError(-32601, `Resource ${uri} not found`);
+        }
+      }
+      if (resource.template) {
+        if (!params)
+          throw new McpError(
+            -32602,
+            "Missing parameters for template resource"
+          );
+        return parse(
+          ReadResourceResultSchema,
+          await resource.execute(uri, params)
+        );
+      }
+      return parse(
+        ReadResourceResultSchema,
+        await resource.execute(uri)
+      );
+    });
+  }
+  /**
+   *
+   */
+  #init_roots() {
+    this.#server.addMethod("notifications/roots/list_changed", () => {
+      this.#refresh_roots();
+      return null;
+    });
+  }
+  /**
+   * Request roots list from client
+   */
+  async #refresh_roots() {
+    if (!this.#client_capabilities?.roots) return;
+    this.#lazyily_create_client();
+    try {
+      const response = await this.#client?.request(
+        "roots/list",
+        void 0,
+        "standalone"
+      );
+      this.roots = response?.roots || [];
+    } catch {
+      this.roots = [];
+    }
+  }
+  #init_completion() {
+    this.#server.addMethod(
+      "completion/complete",
+      async ({ argument, ref, context }) => {
+        const completions = this.#completions[ref.type];
+        if (!completions) return null;
+        const complete = completions.get(ref.uri ?? ref.name);
+        if (!complete) return null;
+        const actual_complete = complete[argument.name];
+        if (!actual_complete) return null;
+        return parse(
+          CompleteResultSchema,
+          await actual_complete(argument.value, context)
+        );
+      }
+    );
+  }
+  #init_logging() {
+    if (!this.#options.capabilities?.logging) return;
+    this.#server.addMethod("logging/setLevel", ({ level }) => {
+      this.#event_target.dispatchEvent(
+        event("loglevelchange", { level })
+      );
+      return {};
+    });
+  }
+  #notify_tools_list_changed() {
+    if (this.#options.capabilities?.tools?.listChanged) {
+      this.#notify("notifications/tools/list_changed", {}, "broadcast");
+    }
+  }
+  #notify_prompts_list_changed() {
+    if (this.#options.capabilities?.prompts?.listChanged) {
+      this.#notify("notifications/prompts/list_changed", {}, "broadcast");
+    }
+  }
+  #notify_resources_list_changed() {
+    if (this.#options.capabilities?.resources?.listChanged) {
+      this.#notify(
+        "notifications/resources/list_changed",
+        {},
+        "broadcast"
+      );
+    }
+  }
+  /**
+   * Use the `defineTool` utility to create a reusable tool and pass it to this method to add it to the server.
+   * @template {Array<CreatedTool<any, any>>} T
+   * @template {T extends Array<CreatedTool<infer TSchema, infer TOutputSchema>> ? AllSame<TSchema, StandardSchema | undefined> extends true ? AllSame<TOutputSchema, StandardSchema | undefined> extends true ? T : never : never : never} U
+   * @param {T & NoInfer<U>} tools
+   */
+  tools(tools) {
+    for (const tool2 of tools) {
+      this.tool(tool2);
+    }
+  }
+  /**
+   * Use the `definePrompt` utility to create a reusable tool and pass it to this method to add it to the server.
+   * @template {Array<CreatedPrompt<any>>} T
+   * @template {T extends Array<CreatedPrompt<infer TSchema>> ? AllSame<TSchema, StandardSchema | undefined> extends true ?  T : never : never} U
+   * @param {T & NoInfer<U>} prompts
+   */
+  prompts(prompts) {
+    for (const prompt of prompts) {
+      this.prompt(prompt);
+    }
+  }
+  /**
+   * Use the `defineResource` utility to create a reusable resource and pass it to this method to add it to the server.
+   *
+   * @param {CreatedResource[]} resources
+   */
+  resources(resources) {
+    for (const resource of resources) {
+      this.resource(resource);
+    }
+  }
+  /**
+   * Use the `defineTemplate` utility to create a reusable template and pass it to this method to add it to the server.
+   *
+   * @param {CreatedTemplate<any>[]} templates
+   */
+  templates(templates) {
+    for (const template of templates) {
+      this.template(template);
+    }
+  }
+  /**
+   * Add a tool to the server. If you want to receive any input you need to provide a schema. The schema needs to be a valid Standard Schema V1 schema and needs to be an Object with the properties you need,
+   * Use the description and title to help the LLM to understand what the tool does and when to use it. If you provide an outputSchema, you need to return a structuredContent that matches the schema.
+   *
+   * Tools will be invoked by the LLM when it thinks it needs to use them, you can use the annotations to provide additional information about the tool, like what it does, how to use it, etc.
+   * @template {StandardSchema | undefined} [TSchema=undefined]
+   * @template {StandardSchema | undefined} [TOutputSchema=undefined]
+   * @overload
+   * @param {CreatedTool<TSchema, TOutputSchema>} tool_or_options
+   * @returns {void}
+   */
+  /**
+   * Add a tool to the server. If you want to receive any input you need to provide a schema. The schema needs to be a valid Standard Schema V1 schema and needs to be an Object with the properties you need,
+   * Use the description and title to help the LLM to understand what the tool does and when to use it. If you provide an outputSchema, you need to return a structuredContent that matches the schema.
+   *
+   * Tools will be invoked by the LLM when it thinks it needs to use them, you can use the annotations to provide additional information about the tool, like what it does, how to use it, etc.
+   * @template {StandardSchema | undefined} [TSchema=undefined]
+   * @template {StandardSchema | undefined} [TOutputSchema=undefined]
+   * @overload
+   * @param {ToolOptions<TSchema, TOutputSchema>} tool_or_options
+   * @param {TSchema extends undefined ? (()=>Promise<CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>> | CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>) : ((input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>> | CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>)} execute
+   * @returns {void}
+   * */
+  /**
+   * Add a tool to the server. If you want to receive any input you need to provide a schema. The schema needs to be a valid Standard Schema V1 schema and needs to be an Object with the properties you need,
+   * Use the description and title to help the LLM to understand what the tool does and when to use it. If you provide an outputSchema, you need to return a structuredContent that matches the schema.
+   *
+   * Tools will be invoked by the LLM when it thinks it needs to use them, you can use the annotations to provide additional information about the tool, like what it does, how to use it, etc.
+   * @template {StandardSchema | undefined} [TSchema=undefined]
+   * @template {StandardSchema | undefined} [TOutputSchema=undefined]
+   * @param {CreatedTool<TSchema, TOutputSchema> | ToolOptions<TSchema, TOutputSchema>} tool_or_options
+   * @param {undefined | TSchema extends undefined ? (()=>Promise<CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>> | CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>) : ((input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>> | CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>)} [execute]
+   */
+  tool(tool_or_options, execute) {
+    if ("execute" in tool_or_options) {
+      execute = tool_or_options.execute;
     }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function picklist(options, message$1) {
-  return {
-    kind: "schema",
-    type: "picklist",
-    reference: picklist,
-    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
-    async: false,
-    options,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (this.options.includes(dataset.value)) dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
+    this.#notify_tools_list_changed();
+    const stored_tool = (
+      /** @type {Tool<any, any>} */
+      tool_or_options
+    );
+    stored_tool.execute = /** @type {NonNullable<typeof execute>} */
+    execute;
+    this.#tools.set(tool_or_options.name, stored_tool);
+  }
+  /**
+   * Add a prompt to the server. Prompts are used to provide the user with pre-defined messages that adds context to the LLM.
+   * Use the description and title to help the user to understand what the prompt does and when to use it.
+   *
+   * A prompt can also have a schema that defines the input it expects, the user will be prompted to enter the inputs you request. It can also have a complete function
+   * for each input that will be used to provide completions for the user.
+   * @template {StandardSchema | undefined} [TSchema=undefined]
+   * @overload
+   * @param {CreatedPrompt<TSchema>} prompt_or_options
+   * @returns {void}
+   */
+  /**
+   * Add a prompt to the server. Prompts are used to provide the user with pre-defined messages that adds context to the LLM.
+   * Use the description and title to help the user to understand what the prompt does and when to use it.
+   *
+   * A prompt can also have a schema that defines the input it expects, the user will be prompted to enter the inputs you request. It can also have a complete function
+   * for each input that will be used to provide completions for the user.
+   * @template {StandardSchema | undefined} [TSchema=undefined]
+   * @overload
+   * @param {PromptOptions<TSchema>} prompt_or_options
+   * @param {TSchema extends undefined ? (()=>Promise<GetPromptResult> | GetPromptResult) : (input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<GetPromptResult> | GetPromptResult} execute
+   * @returns {void}
+   * */
+  /**
+   * Add a prompt to the server. Prompts are used to provide the user with pre-defined messages that adds context to the LLM.
+   * Use the description and title to help the user to understand what the prompt does and when to use it.
+   *
+   * A prompt can also have a schema that defines the input it expects, the user will be prompted to enter the inputs you request. It can also have a complete function
+   * for each input that will be used to provide completions for the user.
+   * @template {StandardSchema | undefined} [TSchema=undefined]
+   * @param {CreatedPrompt<TSchema> | PromptOptions<TSchema>} prompt_or_options
+   * @param {TSchema extends undefined ? (()=>Promise<GetPromptResult> | GetPromptResult) : (input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<GetPromptResult> | GetPromptResult} [execute]
+   */
+  prompt(prompt_or_options, execute) {
+    if ("execute" in prompt_or_options) {
+      execute = /** @type {NonNullable<typeof execute>} */
+      prompt_or_options.execute;
     }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function string(message$1) {
-  return {
-    kind: "schema",
-    type: "string",
-    reference: string,
-    expects: "string",
-    async: false,
-    message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      if (typeof dataset.value === "string") dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
+    if (prompt_or_options.complete) {
+      this.#completions["ref/prompt"].set(
+        prompt_or_options.name,
+        prompt_or_options.complete
+      );
     }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function pipe(...pipe$1) {
-  return {
-    ...pipe$1[0],
-    pipe: pipe$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config$1) {
-      for (const item of pipe$1) if (item.kind !== "metadata") {
-        if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
-          dataset.typed = false;
-          break;
-        }
-        if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
-      }
-      return dataset;
+    this.#notify_prompts_list_changed();
+    const stored_prompt = (
+      /** @type {Prompt<any>} */
+      prompt_or_options
+    );
+    stored_prompt.execute = /** @type {NonNullable<typeof execute>} */
+    execute;
+    this.#prompts.set(prompt_or_options.name, stored_prompt);
+  }
+  /**
+   * @type {(resource: StoredResource & { uri: string })=> void}
+   */
+  #resource(resource) {
+    if (resource.template && resource.complete) {
+      this.#completions["ref/resource"].set(
+        resource.uri,
+        resource.complete
+      );
     }
-  };
-}
+    if (resource.template) {
+      this.#templates.add(resource.uri);
+    }
+    this.#notify_resources_list_changed();
+    this.#resources.set(resource.uri, resource);
+  }
+  /**
+   * Add a resource to the server. Resources are added manually to the context by the user to provide the LLM with additional context.
+   * Use the description and title to help the user to understand what the resource is.
+   * @overload
+   * @param {CreatedResource} resource_or_options
+   * @returns {void}
+   */
+  /**
+   * Add a resource to the server. Resources are added manually to the context by the user to provide the LLM with additional context.
+   * Use the description and title to help the user to understand what the resource is.
+   * @overload
+   * @param {ResourceOptions} resource_or_options
+   * @param {(uri: string) => Promise<ReadResourceResult> | ReadResourceResult} execute
+   * @returns {void}
+   */
+  /**
+   * Add a resource to the server. Resources are added manually to the context by the user to provide the LLM with additional context.
+   * Use the description and title to help the user to understand what the resource is.
+   * @param {CreatedResource | ResourceOptions} resource_or_options
+   * @param {(uri: string) => Promise<ReadResourceResult> | ReadResourceResult} [execute]
+   */
+  resource(resource_or_options, execute) {
+    if ("execute" in resource_or_options) {
+      execute = resource_or_options.execute;
+    }
+    const stored_resource = (
+      /** @type {StoredResource & { uri: string }} */
+      resource_or_options
+    );
+    stored_resource.execute = /** @type {NonNullable<typeof execute>} */
+    execute;
+    stored_resource.template = false;
+    this.#resource(stored_resource);
+  }
+  /**
+   * Add a resource template to the server. Resources are added manually to the context by the user to provide the LLM with additional context.
+   * Resource templates are used to create resources dynamically based on a URI template. The URI template should be a valid URI template as defined in RFC 6570.
+   * Resource templates can have a list method that returns a list of resources that match the template and a complete method that returns a list of resources given one of the template variables, this method will
+   * be invoked to provide completions for the template variables to the user.
+   * Use the description and title to help the user to understand what the resource is.
+   * @template {string} TUri
+   * @template {ExtractURITemplateVariables<TUri>} TVariables
+   * @overload
+   * @param {CreatedTemplate<TUri>} template_or_options
+   * @returns {void}
+   */
+  /**
+   * Add a resource template to the server. Resources are added manually to the context by the user to provide the LLM with additional context.
+   * Resource templates are used to create resources dynamically based on a URI template. The URI template should be a valid URI template as defined in RFC 6570.
+   * Resource templates can have a list method that returns a list of resources that match the template and a complete method that returns a list of resources given one of the template variables, this method will
+   * be invoked to provide completions for the template variables to the user.
+   * Use the description and title to help the user to understand what the resource is.
+   * @template {string} TUri
+   * @template {ExtractURITemplateVariables<TUri>} TVariables
+   * @overload
+   * @param {TemplateOptions<TUri>} template_or_options
+   * @param {(uri: string, params: Record<TVariables, string | string[]>) => Promise<ReadResourceResult> | ReadResourceResult} execute
+   * @returns {void}
+   */
+  /**
+   * Add a resource template to the server. Resources are added manually to the context by the user to provide the LLM with additional context.
+   * Resource templates are used to create resources dynamically based on a URI template. The URI template should be a valid URI template as defined in RFC 6570.
+   * Resource templates can have a list method that returns a list of resources that match the template and a complete method that returns a list of resources given one of the template variables, this method will
+   * be invoked to provide completions for the template variables to the user.
+   * Use the description and title to help the user to understand what the resource is.
+   * @template {string} TUri
+   * @template {ExtractURITemplateVariables<TUri>} TVariables
+   * @param {CreatedTemplate<TUri> | TemplateOptions<TUri>} template_or_options
+   * @param {(uri: string, params: Record<TVariables, string | string[]>) => Promise<ReadResourceResult> | ReadResourceResult} [execute]
+   */
+  template(template_or_options, execute) {
+    if ("execute" in template_or_options) {
+      execute = template_or_options.execute;
+    }
+    const stored_template = (
+      /** @type {StoredResource & { uri: string }} */
+      /** @type {unknown} */
+      template_or_options
+    );
+    stored_template.execute = /** @type {NonNullable<typeof execute>} */
+    execute;
+    stored_template.list_resources = template_or_options.list;
+    stored_template.template = true;
+    this.#resource(stored_template);
+  }
+  /**
+   * The main function that receive a JSONRpc message and either dispatch a `send` event or process the request.
+   *
+   * @param {JSONRPCMessage} message
+   * @param {Context<CustomContext>} [ctx]
+   * @returns {ReturnType<JSONRPCServer['receive']> | ReturnType<JSONRPCClient['receive'] | undefined>}
+   */
+  receive(message, ctx) {
+    const validated_message = safeParse(
+      union([JSONRPCRequestSchema, JSONRPCNotificationSchema]),
+      message
+    );
+    if (validated_message.success) {
+      const progress_token = (
+        /** @type {string | undefined} */
+        validated_message.output.params?._meta?.progressToken
+      );
+      return this.#ctx_storage.run(
+        { ...ctx ?? {}, progress_token },
+        async () => await this.#server.receive(validated_message.output)
+      );
+    }
+    const validated_response = parse(
+      union([JSONRPCResponseSchema, JSONRPCErrorSchema]),
+      message
+    );
+    this.#lazyily_create_client();
+    return this.#ctx_storage.run(
+      ctx ?? {},
+      async () => this.#client?.receive(validated_response)
+    );
+  }
+  /**
+   * Lower level api to send a request to the client, mostly useful to call client methods that not yet supported by the server or
+   * if you want to send requests with json schema that is not expressible with your validation library.
+   * @param {{ method: string, params?: JSONRPCParams }} request
+   * @returns {Promise<unknown>}
+   */
+  async request({ method, params }) {
+    this.#lazyily_create_client();
+    return this.#client?.request(method, params, "standalone");
+  }
+  /**
+   * Send a notification for subscriptions
+   * @template {keyof ChangedArgs} TWhat
+   * @param {[what: TWhat, ...ChangedArgs[TWhat]]} args
+   */
+  changed(...args) {
+    const [what, id] = args;
+    if (what === "prompts") {
+      this.#notify_prompts_list_changed();
+    } else if (what === "tools") {
+      this.#notify_tools_list_changed();
+    } else if (what === "resources") {
+      this.#notify_resources_list_changed();
+    } else {
+      const resource = this.#resources.get(id);
+      if (!resource) return;
+      this.#notify(
+        `notifications/resources/updated`,
+        {
+          uri: id,
+          title: resource.name
+        },
+        "broadcast"
+      );
+    }
+  }
+  /**
+   * Refresh roots list from client
+   */
+  async refreshRoots() {
+    await this.#refresh_roots();
+  }
+  /**
+   * Emit an elicitation request to the client. Elicitations are used to ask the user for input in a structured way, the client will show a UI to the user to fill the input.
+   * The schema should be a valid Standard Schema V1 schema and should be an Object with the properties you need.
+   * The client will return the validated input as a JSON object that matches the schema.
+   *
+   * If the client doesn't support elicitation, it will throw an error.
+   *
+   * @template {StandardSchema extends undefined ? never : StandardSchema} TSchema
+   * @param {string} message
+   * @param {TSchema} schema
+   * @returns {Promise<ElicitResult & { content?: StandardSchemaV1.InferOutput<TSchema> }>}
+   */
+  async elicitation(message, schema6) {
+    if (!this.#client_capabilities?.elicitation)
+      throw new McpError(-32601, "Client doesn't support elicitation");
+    this.#lazyily_create_client();
+    const result = await this.#client?.request(
+      "elicitation/create",
+      {
+        message,
+        requestedSchema: await this.#options.adapter?.toJsonSchema(schema6)
+      },
+      "standalone"
+    );
+    const elicit_result = parse(ElicitResultSchema, result);
+    let validated_result = schema6["~standard"].validate(
+      elicit_result.content
+    );
+    if (validated_result instanceof Promise)
+      validated_result = await validated_result;
+    if (validated_result.issues) {
+      throw new McpError(
+        -32603,
+        `Invalid elicitation result: ${JSON.stringify(validated_result.issues)}`
+      );
+    }
+    return { ...elicit_result, content: validated_result.value };
+  }
+  /**
+   * Request language model sampling from the client
+   * @param {CreateMessageRequestParams} request
+   * @returns {Promise<CreateMessageResult>}
+   */
+  async message(request) {
+    if (!this.#client_capabilities?.sampling)
+      throw new McpError(-32601, "Client doesn't support sampling");
+    this.#lazyily_create_client();
+    const validated_request = parse(
+      CreateMessageRequestParamsSchema,
+      request
+    );
+    const response = await this.#client?.request(
+      "sampling/createMessage",
+      validated_request,
+      "standalone"
+    );
+    return parse(CreateMessageResultSchema, response);
+  }
+  /**
+   * Send a progress notification to the client. This is useful for long-running operations where you want to inform the user about the progress.
+   *
+   * @param {number} progress The current progress value, it should be between 0 and total and should always increase
+   * @param {number} [total] The total value, defaults to 1
+   * @param {string} [message] An optional message to accompany the progress update
+   */
+  progress(progress, total = 1, message = void 0) {
+    if (this.#progress_token != null) {
+      this.#notify("notifications/progress", {
+        progress,
+        total,
+        message,
+        progressToken: this.#progress_token
+      });
+    }
+  }
+  /**
+   * Log a message to the client if logging is enabled and the level is appropriate
+   *
+   * @param {LoggingLevel} level
+   * @param {unknown} data
+   * @param {string} [logger]
+   */
+  log(level, data, logger) {
+    if (!this.#options.capabilities?.logging) {
+      throw new McpError(
+        -32601,
+        "The server doesn't support logging, please enable it in capabilities"
+      );
+    }
+    const current_session_level = this.#ctx_storage.getStore()?.sessionInfo?.logLevel ?? this.#options.logging?.default ?? "info";
+    if (current_session_level && this.#should_log(level, current_session_level)) {
+      this.#notify("notifications/message", {
+        level,
+        data,
+        logger
+      });
+    }
+  }
+  /**
+   * Check if a log message should be sent based on severity levels
+   * @param {LoggingLevel} message_level
+   * @param {LoggingLevel} session_level
+   * @returns {boolean}
+   */
+  #should_log(message_level, session_level) {
+    const levels = [
+      "debug",
+      "info",
+      "notice",
+      "warning",
+      "error",
+      "critical",
+      "alert",
+      "emergency"
+    ];
+    const message_severity = levels.indexOf(message_level);
+    const session_severity = levels.indexOf(session_level);
+    return message_severity >= session_severity;
+  }
+};
 
-// ../mcp-server/src/mcp/handlers/tools/list-components.ts
-import { tool } from "tmcp/utils";
+// ../mcp-server/src/mcp/handlers/tools/index.ts
+var tools_exports = {};
+__export(tools_exports, {
+  get_component: () => get_component,
+  get_component_demo: () => get_component_demo,
+  get_utils: () => get_utils,
+  list_components: () => list_components,
+  list_exports: () => list_exports,
+  search_components: () => search_components
+});
+
+// ../../node_modules/.pnpm/tmcp@1.19.4_typescript@5.9.3/node_modules/tmcp/src/utils/index.js
+var tool = {
+  /**
+   * @param {string} text
+   */
+  text(text) {
+    return {
+      content: [
+        {
+          type: (
+            /** @type {const} */
+            "text"
+          ),
+          text
+        }
+      ]
+    };
+  },
+  /**
+   * @param {string} text
+   */
+  error(text) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: (
+            /** @type {const} */
+            "text"
+          ),
+          text
+        }
+      ]
+    };
+  },
+  /**
+   * @param {"audio" | "image"} type
+   * @param {string} data
+   * @param {string} mime_type
+   */
+  media(type, data, mime_type) {
+    return {
+      content: [
+        {
+          type,
+          data,
+          mimeType: mime_type
+        }
+      ]
+    };
+  },
+  /**
+   * @param {EmbeddedResource["resource"]} resource
+   */
+  resource(resource) {
+    return {
+      content: [
+        {
+          type: (
+            /** @type {const} */
+            "resource"
+          ),
+          resource
+        }
+      ]
+    };
+  },
+  /**
+   * @param {Omit<ResourceLink, "type">} resource_link
+   */
+  resourceLink(resource_link) {
+    return {
+      content: [
+        {
+          type: (
+            /** @type {const} */
+            "resource_link"
+          ),
+          ...resource_link
+        }
+      ]
+    };
+  },
+  /**
+   * @template {Record<string, unknown>} T
+   * @param {T} obj
+   */
+  structured(obj) {
+    return (
+      /** @type {const} */
+      {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(obj)
+          }
+        ],
+        structuredContent: obj
+      }
+    );
+  },
+  /**
+   * @template {Record<string, unknown> | undefined} [T=undefined]
+   * @param {Array<CallToolResult<undefined>>} results
+   * @param {T} [obj]
+   */
+  mix(results, obj) {
+    return (
+      /** @type {CallToolResult<T>} */
+      {
+        isError: results.some((r) => r.isError),
+        content: results.flatMap((r) => r.content ? r.content : []),
+        structuredContent: obj
+      }
+    );
+  }
+};
 
 // ../mcp-server/src/constants.ts
 import { resolve } from "path";
@@ -977,7 +5241,6 @@ function list_components(server2) {
 }
 
 // ../mcp-server/src/mcp/handlers/tools/get-component.ts
-import { tool as tool2 } from "tmcp/utils";
 var schema2 = object({
   name: pipe(
     string(),
@@ -1005,13 +5268,13 @@ function get_component(server2) {
           const similar = all.filter(
             (c) => c.name.toLowerCase().includes(needle) || needle.includes(c.name.toLowerCase())
           ).map((c) => `${c.name} (${c.category})`).slice(0, 5).join(", ");
-          return tool2.text(
+          return tool.text(
             `Component '${name}' not found.${similar ? ` Similar: ${similar}` : " Use alus_list_components to browse."}`
           );
         }
         const entry = matches[0];
         const src = await read_component_source(entry);
-        return tool2.text(
+        return tool.text(
           truncate(
             `# ${entry.name} (${entry.category})
 
@@ -1020,14 +5283,13 @@ ${src}`,
           )
         );
       } catch (e) {
-        return tool2.error(e.message);
+        return tool.error(e.message);
       }
     }
   );
 }
 
 // ../mcp-server/src/mcp/handlers/tools/search-components.ts
-import { tool as tool3 } from "tmcp/utils";
 import { readFile as readFile2 } from "fs/promises";
 var schema3 = object({
   query: pipe(string(), minLength(2), description("Case-insensitive search string")),
@@ -1071,9 +5333,9 @@ function search_components(server2) {
             }
           }
         }
-        if (!hits.length) return tool3.text(`No results for '${query}'.`);
+        if (!hits.length) return tool.text(`No results for '${query}'.`);
         if (response_format === "json") {
-          return tool3.text(JSON.stringify({ query, total: hits.length, hits }, null, 2));
+          return tool.text(JSON.stringify({ query, total: hits.length, hits }, null, 2));
         }
         const lines = [`# Search: '${query}' \u2014 ${hits.length} hit(s)`, ""];
         for (const h of hits) {
@@ -1085,16 +5347,15 @@ function search_components(server2) {
             ""
           );
         }
-        return tool3.text(truncate(lines.join("\n"), "Narrow with category or a more specific query."));
+        return tool.text(truncate(lines.join("\n"), "Narrow with category or a more specific query."));
       } catch (e) {
-        return tool3.error(e.message);
+        return tool.error(e.message);
       }
     }
   );
 }
 
 // ../mcp-server/src/mcp/handlers/tools/get-component-demo.ts
-import { tool as tool4 } from "tmcp/utils";
 import { readFile as readFile3, readdir as readdir2 } from "fs/promises";
 var schema4 = object({
   name: pipe(
@@ -1123,9 +5384,9 @@ function get_component_demo(server2) {
           } catch {
           }
           const hint = available.length ? ` Available: ${available.slice(0, 10).join(", ")}${available.length > 10 ? "\u2026" : ""}` : "";
-          return tool4.text(`Demo not found for '${name}'.${hint}`);
+          return tool.text(`Demo not found for '${name}'.${hint}`);
         }
-        return tool4.text(
+        return tool.text(
           truncate(
             `# Demo: ${name}
 \`\`\`svelte
@@ -1135,14 +5396,13 @@ ${content}
           )
         );
       } catch (e) {
-        return tool4.error(e.message);
+        return tool.error(e.message);
       }
     }
   );
 }
 
 // ../mcp-server/src/mcp/handlers/tools/list-exports.ts
-import { tool as tool5 } from "tmcp/utils";
 import { readFile as readFile4 } from "fs/promises";
 function list_exports(server2) {
   server2.tool(
@@ -1154,18 +5414,17 @@ function list_exports(server2) {
     async () => {
       try {
         const content = await readFile4(`${COMPONENTS_DIR}/index.ts`, "utf-8");
-        return tool5.text(`\`\`\`typescript
+        return tool.text(`\`\`\`typescript
 ${content}
 \`\`\``);
       } catch (e) {
-        return tool5.error(e.message);
+        return tool.error(e.message);
       }
     }
   );
 }
 
 // ../mcp-server/src/mcp/handlers/tools/get-utils.ts
-import { tool as tool6 } from "tmcp/utils";
 import { readFile as readFile5 } from "fs/promises";
 var MODULES = ["aria", "focus", "id", "keyboard", "index", "form/state"];
 var schema5 = object({
@@ -1183,11 +5442,11 @@ function get_utils(server2) {
       try {
         const path = module === "index" ? `${UTILS_ROOT}/a11y/index.ts` : module === "form/state" ? `${UTILS_ROOT}/form/state.ts` : `${UTILS_ROOT}/a11y/${module}.ts`;
         const content = await readFile5(path, "utf-8");
-        return tool6.text(`\`\`\`typescript
+        return tool.text(`\`\`\`typescript
 ${content}
 \`\`\``);
       } catch (e) {
-        return tool6.error(e.message);
+        return tool.error(e.message);
       }
     }
   );
@@ -1195,8 +5454,8 @@ ${content}
 
 // ../mcp-server/src/mcp/handlers/index.ts
 function setup_tools(server2) {
-  for (const tool7 in tools_exports) {
-    tools_exports[tool7](server2);
+  for (const tool2 in tools_exports) {
+    tools_exports[tool2](server2);
   }
 }
 
@@ -1215,7 +5474,128 @@ var server = new McpServer(
 ).withContext();
 setup_tools(server);
 
+// ../../node_modules/.pnpm/@tmcp+transport-stdio@0.4.3_tmcp@1.19.4_typescript@6.0.3_/node_modules/@tmcp/transport-stdio/src/index.js
+import process2 from "process";
+var StdioTransport = class {
+  /**
+   * @type {McpServer<any, TCustom>}
+   */
+  #server;
+  /**
+   * @type {Set<() => void>}
+   */
+  #cleaners = /* @__PURE__ */ new Set();
+  /**
+   * @type {NonNullable<Partial<Context["sessionInfo"]>>}
+   */
+  #session_info = {};
+  /**
+   * @type {Subscriptions}
+   */
+  #subscriptions = {
+    resource: []
+  };
+  /**
+   *
+   * @param {McpServer<any, TCustom>} server
+   */
+  constructor(server2) {
+    this.#server = server2;
+    this.#cleaners.add(
+      this.#server.on("initialize", ({ capabilities, clientInfo }) => {
+        this.#session_info.clientCapabilities = capabilities;
+        this.#session_info.clientInfo = clientInfo;
+        this.#cleaners.add(
+          this.#server.on("send", ({ request }) => {
+            process2.stdout.write(JSON.stringify(request) + "\n");
+          })
+        );
+        this.#cleaners.add(
+          this.#server.on("broadcast", ({ request }) => {
+            if (request.method === "notifications/resources/updated" && !this.#subscriptions.resource.includes(
+              request.params.uri
+            )) {
+              return;
+            }
+            process2.stdout.write(JSON.stringify(request) + "\n");
+          })
+        );
+        this.#cleaners.add(
+          this.#server.on("loglevelchange", ({ level }) => {
+            this.#session_info.logLevel = level;
+          })
+        );
+        this.#cleaners.add(
+          this.#server.on("subscription", ({ uri, action }) => {
+            this.#subscriptions ??= {
+              resource: []
+            };
+            if (action === "remove") {
+              this.#subscriptions.resource = this.#subscriptions.resource?.filter(
+                (item) => item !== uri
+              );
+            } else {
+              this.#subscriptions.resource?.push(uri);
+            }
+          })
+        );
+      })
+    );
+  }
+  #close() {
+    for (const cleaner of this.#cleaners) {
+      cleaner();
+    }
+    process2.exit(0);
+  }
+  /**
+   * @param {TCustom} [ctx]
+   */
+  listen(ctx) {
+    process2.stdin.setEncoding("utf8");
+    let buffer = "";
+    process2.stdin.on("data", async (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const message = JSON.parse(line);
+            const is_init = message.method === "initialize";
+            const session_info = is_init ? {
+              clientCapabilities: message.params?.capabilities,
+              clientInfo: message.params?.clientInfo
+            } : this.#session_info;
+            const response = await this.#server.receive(message, {
+              custom: ctx,
+              sessionInfo: (
+                /** @type {Context["sessionInfo"]} */
+                session_info
+              )
+            });
+            if (response) {
+              process2.stdout.write(
+                JSON.stringify(response) + "\n"
+              );
+            }
+          } catch {
+          }
+        }
+      }
+    });
+    process2.stdin.on("end", () => {
+      this.#close();
+    });
+    process2.on("SIGINT", () => {
+      this.#close();
+    });
+    process2.on("SIGTERM", () => {
+      this.#close();
+    });
+  }
+};
+
 // src/index.ts
-import { StdioTransport } from "@tmcp/transport-stdio";
 var transport = new StdioTransport(server);
 transport.listen();