@introspection-ai/recipes 0.13.0 → 0.14.0

package/dist/mcp-chunks/chunk-2U4BSDC4.js

@@ -0,0 +1,3951 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  writeTextFileAtomic
+} from "./chunk-2XL7MG7R.js";
+import {
+  homeConfigCandidates,
+  listConfigLayerPaths,
+  pathExists,
+  pathExistsAsync,
+  resolveConfigPath
+} from "./chunk-WQJZMCJN.js";
+import {
+  expandHome,
+  resolveEnvPlaceholders
+} from "./chunk-ECIVB7P4.js";
+import {
+  resolveLifecycle
+} from "./chunk-LS7PMWSR.js";
+import {
+  external_exports
+} from "./chunk-D3MRAZ6H.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-LRKZP7DJ.js";
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/parser.js
+var require_parser = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/parser.js"(exports2, module2) {
+    "use strict";
+    var ParserEND = 1114112;
+    var ParserError = class _ParserError extends Error {
+      /* istanbul ignore next */
+      constructor(msg, filename, linenumber) {
+        super("[ParserError] " + msg, filename, linenumber);
+        this.name = "ParserError";
+        this.code = "ParserError";
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _ParserError);
+      }
+    };
+    var State = class {
+      constructor(parser) {
+        this.parser = parser;
+        this.buf = "";
+        this.returned = null;
+        this.result = null;
+        this.resultTable = null;
+        this.resultArr = null;
+      }
+    };
+    var Parser = class {
+      constructor() {
+        this.pos = 0;
+        this.col = 0;
+        this.line = 0;
+        this.obj = {};
+        this.ctx = this.obj;
+        this.stack = [];
+        this._buf = "";
+        this.char = null;
+        this.ii = 0;
+        this.state = new State(this.parseStart);
+      }
+      parse(str) {
+        if (str.length === 0 || str.length == null) return;
+        this._buf = String(str);
+        this.ii = -1;
+        this.char = -1;
+        let getNext;
+        while (getNext === false || this.nextChar()) {
+          getNext = this.runOne();
+        }
+        this._buf = null;
+      }
+      nextChar() {
+        if (this.char === 10) {
+          ++this.line;
+          this.col = -1;
+        }
+        ++this.ii;
+        this.char = this._buf.codePointAt(this.ii);
+        ++this.pos;
+        ++this.col;
+        return this.haveBuffer();
+      }
+      haveBuffer() {
+        return this.ii < this._buf.length;
+      }
+      runOne() {
+        return this.state.parser.call(this, this.state.returned);
+      }
+      finish() {
+        this.char = ParserEND;
+        let last;
+        do {
+          last = this.state.parser;
+          this.runOne();
+        } while (this.state.parser !== last);
+        this.ctx = null;
+        this.state = null;
+        this._buf = null;
+        return this.obj;
+      }
+      next(fn) {
+        if (typeof fn !== "function") throw new ParserError("Tried to set state to non-existent state: " + JSON.stringify(fn));
+        this.state.parser = fn;
+      }
+      goto(fn) {
+        this.next(fn);
+        return this.runOne();
+      }
+      call(fn, returnWith) {
+        if (returnWith) this.next(returnWith);
+        this.stack.push(this.state);
+        this.state = new State(fn);
+      }
+      callNow(fn, returnWith) {
+        this.call(fn, returnWith);
+        return this.runOne();
+      }
+      return(value) {
+        if (this.stack.length === 0) throw this.error(new ParserError("Stack underflow"));
+        if (value === void 0) value = this.state.buf;
+        this.state = this.stack.pop();
+        this.state.returned = value;
+      }
+      returnNow(value) {
+        this.return(value);
+        return this.runOne();
+      }
+      consume() {
+        if (this.char === ParserEND) throw this.error(new ParserError("Unexpected end-of-buffer"));
+        this.state.buf += this._buf[this.ii];
+      }
+      error(err) {
+        err.line = this.line;
+        err.col = this.col;
+        err.pos = this.pos;
+        return err;
+      }
+      /* istanbul ignore next */
+      parseStart() {
+        throw new ParserError("Must declare a parseStart method");
+      }
+    };
+    Parser.END = ParserEND;
+    Parser.Error = ParserError;
+    module2.exports = Parser;
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime.js
+var require_create_datetime = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (value) => {
+      const date = new Date(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/format-num.js
+var require_format_num = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/format-num.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (d, num) => {
+      num = String(num);
+      while (num.length < d) num = "0" + num;
+      return num;
+    };
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime-float.js
+var require_create_datetime_float = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime-float.js"(exports2, module2) {
+    "use strict";
+    var f = require_format_num();
+    var FloatingDateTime = class extends Date {
+      constructor(value) {
+        super(value + "Z");
+        this.isFloating = true;
+      }
+      toISOString() {
+        const date = `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+        const time = `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+        return `${date}T${time}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new FloatingDateTime(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-date.js
+var require_create_date = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-date.js"(exports2, module2) {
+    "use strict";
+    var f = require_format_num();
+    var DateTime = global.Date;
+    var Date2 = class extends DateTime {
+      constructor(value) {
+        super(value);
+        this.isDate = true;
+      }
+      toISOString() {
+        return `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new Date2(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-time.js
+var require_create_time = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-time.js"(exports2, module2) {
+    "use strict";
+    var f = require_format_num();
+    var Time = class extends Date {
+      constructor(value) {
+        super(`0000-01-01T${value}Z`);
+        this.isTime = true;
+      }
+      toISOString() {
+        return `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new Time(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/toml-parser.js
+var require_toml_parser = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/toml-parser.js"(exports, module) {
+    "use strict";
+    module.exports = makeParserClass(require_parser());
+    module.exports.makeParserClass = makeParserClass;
+    var TomlError = class _TomlError extends Error {
+      constructor(msg) {
+        super(msg);
+        this.name = "TomlError";
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _TomlError);
+        this.fromTOML = true;
+        this.wrapped = null;
+      }
+    };
+    TomlError.wrap = (err) => {
+      const terr = new TomlError(err.message);
+      terr.code = err.code;
+      terr.wrapped = err;
+      return terr;
+    };
+    module.exports.TomlError = TomlError;
+    var createDateTime = require_create_datetime();
+    var createDateTimeFloat = require_create_datetime_float();
+    var createDate = require_create_date();
+    var createTime = require_create_time();
+    var CTRL_I = 9;
+    var CTRL_J = 10;
+    var CTRL_M = 13;
+    var CTRL_CHAR_BOUNDARY = 31;
+    var CHAR_SP = 32;
+    var CHAR_QUOT = 34;
+    var CHAR_NUM = 35;
+    var CHAR_APOS = 39;
+    var CHAR_PLUS = 43;
+    var CHAR_COMMA = 44;
+    var CHAR_HYPHEN = 45;
+    var CHAR_PERIOD = 46;
+    var CHAR_0 = 48;
+    var CHAR_1 = 49;
+    var CHAR_7 = 55;
+    var CHAR_9 = 57;
+    var CHAR_COLON = 58;
+    var CHAR_EQUALS = 61;
+    var CHAR_A = 65;
+    var CHAR_E = 69;
+    var CHAR_F = 70;
+    var CHAR_T = 84;
+    var CHAR_U = 85;
+    var CHAR_Z = 90;
+    var CHAR_LOWBAR = 95;
+    var CHAR_a = 97;
+    var CHAR_b = 98;
+    var CHAR_e = 101;
+    var CHAR_f = 102;
+    var CHAR_i = 105;
+    var CHAR_l = 108;
+    var CHAR_n = 110;
+    var CHAR_o = 111;
+    var CHAR_r = 114;
+    var CHAR_s = 115;
+    var CHAR_t = 116;
+    var CHAR_u = 117;
+    var CHAR_x = 120;
+    var CHAR_z = 122;
+    var CHAR_LCUB = 123;
+    var CHAR_RCUB = 125;
+    var CHAR_LSQB = 91;
+    var CHAR_BSOL = 92;
+    var CHAR_RSQB = 93;
+    var CHAR_DEL = 127;
+    var SURROGATE_FIRST = 55296;
+    var SURROGATE_LAST = 57343;
+    var escapes = {
+      [CHAR_b]: "\b",
+      [CHAR_t]: "	",
+      [CHAR_n]: "\n",
+      [CHAR_f]: "\f",
+      [CHAR_r]: "\r",
+      [CHAR_QUOT]: '"',
+      [CHAR_BSOL]: "\\"
+    };
+    function isDigit(cp) {
+      return cp >= CHAR_0 && cp <= CHAR_9;
+    }
+    function isHexit(cp) {
+      return cp >= CHAR_A && cp <= CHAR_F || cp >= CHAR_a && cp <= CHAR_f || cp >= CHAR_0 && cp <= CHAR_9;
+    }
+    function isBit(cp) {
+      return cp === CHAR_1 || cp === CHAR_0;
+    }
+    function isOctit(cp) {
+      return cp >= CHAR_0 && cp <= CHAR_7;
+    }
+    function isAlphaNumQuoteHyphen(cp) {
+      return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_APOS || cp === CHAR_QUOT || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+    }
+    function isAlphaNumHyphen(cp) {
+      return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+    }
+    var _type = /* @__PURE__ */ Symbol("type");
+    var _declared = /* @__PURE__ */ Symbol("declared");
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var defineProperty = Object.defineProperty;
+    var descriptor = { configurable: true, enumerable: true, writable: true, value: void 0 };
+    function hasKey(obj, key) {
+      if (hasOwnProperty.call(obj, key)) return true;
+      if (key === "__proto__") defineProperty(obj, "__proto__", descriptor);
+      return false;
+    }
+    var INLINE_TABLE = /* @__PURE__ */ Symbol("inline-table");
+    function InlineTable() {
+      return Object.defineProperties({}, {
+        [_type]: { value: INLINE_TABLE }
+      });
+    }
+    function isInlineTable(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INLINE_TABLE;
+    }
+    var TABLE = /* @__PURE__ */ Symbol("table");
+    function Table() {
+      return Object.defineProperties({}, {
+        [_type]: { value: TABLE },
+        [_declared]: { value: false, writable: true }
+      });
+    }
+    function isTable(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === TABLE;
+    }
+    var _contentType = /* @__PURE__ */ Symbol("content-type");
+    var INLINE_LIST = /* @__PURE__ */ Symbol("inline-list");
+    function InlineList(type) {
+      return Object.defineProperties([], {
+        [_type]: { value: INLINE_LIST },
+        [_contentType]: { value: type }
+      });
+    }
+    function isInlineList(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INLINE_LIST;
+    }
+    var LIST = /* @__PURE__ */ Symbol("list");
+    function List() {
+      return Object.defineProperties([], {
+        [_type]: { value: LIST }
+      });
+    }
+    function isList(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === LIST;
+    }
+    var _custom;
+    try {
+      const utilInspect = eval("require('util').inspect");
+      _custom = utilInspect.custom;
+    } catch (_) {
+    }
+    var _inspect = _custom || "inspect";
+    var BoxedBigInt = class {
+      constructor(value) {
+        try {
+          this.value = global.BigInt.asIntN(64, value);
+        } catch (_) {
+          this.value = null;
+        }
+        Object.defineProperty(this, _type, { value: INTEGER });
+      }
+      isNaN() {
+        return this.value === null;
+      }
+      /* istanbul ignore next */
+      toString() {
+        return String(this.value);
+      }
+      /* istanbul ignore next */
+      [_inspect]() {
+        return `[BigInt: ${this.toString()}]}`;
+      }
+      valueOf() {
+        return this.value;
+      }
+    };
+    var INTEGER = /* @__PURE__ */ Symbol("integer");
+    function Integer(value) {
+      let num = Number(value);
+      if (Object.is(num, -0)) num = 0;
+      if (global.BigInt && !Number.isSafeInteger(num)) {
+        return new BoxedBigInt(value);
+      } else {
+        return Object.defineProperties(new Number(num), {
+          isNaN: { value: function() {
+            return isNaN(this);
+          } },
+          [_type]: { value: INTEGER },
+          [_inspect]: { value: () => `[Integer: ${value}]` }
+        });
+      }
+    }
+    function isInteger(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INTEGER;
+    }
+    var FLOAT = /* @__PURE__ */ Symbol("float");
+    function Float(value) {
+      return Object.defineProperties(new Number(value), {
+        [_type]: { value: FLOAT },
+        [_inspect]: { value: () => `[Float: ${value}]` }
+      });
+    }
+    function isFloat(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === FLOAT;
+    }
+    function tomlType(value) {
+      const type = typeof value;
+      if (type === "object") {
+        if (value === null) return "null";
+        if (value instanceof Date) return "datetime";
+        if (_type in value) {
+          switch (value[_type]) {
+            case INLINE_TABLE:
+              return "inline-table";
+            case INLINE_LIST:
+              return "inline-list";
+            /* istanbul ignore next */
+            case TABLE:
+              return "table";
+            /* istanbul ignore next */
+            case LIST:
+              return "list";
+            case FLOAT:
+              return "float";
+            case INTEGER:
+              return "integer";
+          }
+        }
+      }
+      return type;
+    }
+    function makeParserClass(Parser) {
+      class TOMLParser extends Parser {
+        constructor() {
+          super();
+          this.ctx = this.obj = Table();
+        }
+        /* MATCH HELPER */
+        atEndOfWord() {
+          return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
+        }
+        atEndOfLine() {
+          return this.char === Parser.END || this.char === CTRL_J || this.char === CTRL_M;
+        }
+        parseStart() {
+          if (this.char === Parser.END) {
+            return null;
+          } else if (this.char === CHAR_LSQB) {
+            return this.call(this.parseTableOrList);
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else if (isAlphaNumQuoteHyphen(this.char)) {
+            return this.callNow(this.parseAssignStatement);
+          } else {
+            throw this.error(new TomlError(`Unknown character "${this.char}"`));
+          }
+        }
+        // HELPER, this strips any whitespace and comments to the end of the line
+        // then RETURNS. Last state in a production.
+        parseWhitespaceToEOL() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CHAR_NUM) {
+            return this.goto(this.parseComment);
+          } else if (this.char === Parser.END || this.char === CTRL_J) {
+            return this.return();
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
+          }
+        }
+        /* ASSIGNMENT: key = value */
+        parseAssignStatement() {
+          return this.callNow(this.parseAssign, this.recordAssignStatement);
+        }
+        recordAssignStatement(kv) {
+          let target = this.ctx;
+          let finalKey = kv.key.pop();
+          for (let kw of kv.key) {
+            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            target = target[kw] = target[kw] || Table();
+          }
+          if (hasKey(target, finalKey)) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          if (isInteger(kv.value) || isFloat(kv.value)) {
+            target[finalKey] = kv.value.valueOf();
+          } else {
+            target[finalKey] = kv.value;
+          }
+          return this.goto(this.parseWhitespaceToEOL);
+        }
+        /* ASSSIGNMENT expression, key = value possibly inside an inline table */
+        parseAssign() {
+          return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+        }
+        recordAssignKeyword(key) {
+          if (this.state.resultTable) {
+            this.state.resultTable.push(key);
+          } else {
+            this.state.resultTable = [key];
+          }
+          return this.goto(this.parseAssignKeywordPreDot);
+        }
+        parseAssignKeywordPreDot() {
+          if (this.char === CHAR_PERIOD) {
+            return this.next(this.parseAssignKeywordPostDot);
+          } else if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+            return this.goto(this.parseAssignEqual);
+          }
+        }
+        parseAssignKeywordPostDot() {
+          if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+            return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+          }
+        }
+        parseAssignEqual() {
+          if (this.char === CHAR_EQUALS) {
+            return this.next(this.parseAssignPreValue);
+          } else {
+            throw this.error(new TomlError('Invalid character, expected "="'));
+          }
+        }
+        parseAssignPreValue() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseValue, this.recordAssignValue);
+          }
+        }
+        recordAssignValue(value) {
+          return this.returnNow({ key: this.state.resultTable, value });
+        }
+        /* COMMENTS: #...eol */
+        parseComment() {
+          do {
+            if (this.char === Parser.END || this.char === CTRL_J) {
+              return this.return();
+            }
+          } while (this.nextChar());
+        }
+        /* TABLES AND LISTS, [foo] and [[foo]] */
+        parseTableOrList() {
+          if (this.char === CHAR_LSQB) {
+            this.next(this.parseList);
+          } else {
+            return this.goto(this.parseTable);
+          }
+        }
+        /* TABLE [foo.bar.baz] */
+        parseTable() {
+          this.ctx = this.obj;
+          return this.goto(this.parseTableNext);
+        }
+        parseTableNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseKeyword, this.parseTableMore);
+          }
+        }
+        parseTableMore(keyword) {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CHAR_RSQB) {
+            if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            } else {
+              this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
+              this.ctx[_declared] = true;
+            }
+            return this.next(this.parseWhitespaceToEOL);
+          } else if (this.char === CHAR_PERIOD) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx = this.ctx[keyword] = Table();
+            } else if (isTable(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword];
+            } else if (isList(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+            } else {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            return this.next(this.parseTableNext);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        /* LIST [[a.b.c]] */
+        parseList() {
+          this.ctx = this.obj;
+          return this.goto(this.parseListNext);
+        }
+        parseListNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseKeyword, this.parseListMore);
+          }
+        }
+        parseListMore(keyword) {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CHAR_RSQB) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx[keyword] = List();
+            }
+            if (isInlineList(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline array"));
+            } else if (isList(this.ctx[keyword])) {
+              const next = Table();
+              this.ctx[keyword].push(next);
+              this.ctx = next;
+            } else {
+              throw this.error(new TomlError("Can't redefine an existing key"));
+            }
+            return this.next(this.parseListEnd);
+          } else if (this.char === CHAR_PERIOD) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx = this.ctx[keyword] = Table();
+            } else if (isInlineList(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline array"));
+            } else if (isInlineTable(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline table"));
+            } else if (isList(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+            } else if (isTable(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword];
+            } else {
+              throw this.error(new TomlError("Can't redefine an existing key"));
+            }
+            return this.next(this.parseListNext);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        parseListEnd(keyword) {
+          if (this.char === CHAR_RSQB) {
+            return this.next(this.parseWhitespaceToEOL);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        /* VALUE string, number, boolean, inline list, inline object */
+        parseValue() {
+          if (this.char === Parser.END) {
+            throw this.error(new TomlError("Key without value"));
+          } else if (this.char === CHAR_QUOT) {
+            return this.next(this.parseDoubleString);
+          }
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseSingleString);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            return this.goto(this.parseNumberSign);
+          } else if (this.char === CHAR_i) {
+            return this.next(this.parseInf);
+          } else if (this.char === CHAR_n) {
+            return this.next(this.parseNan);
+          } else if (isDigit(this.char)) {
+            return this.goto(this.parseNumberOrDateTime);
+          } else if (this.char === CHAR_t || this.char === CHAR_f) {
+            return this.goto(this.parseBoolean);
+          } else if (this.char === CHAR_LSQB) {
+            return this.call(this.parseInlineList, this.recordValue);
+          } else if (this.char === CHAR_LCUB) {
+            return this.call(this.parseInlineTable, this.recordValue);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
+          }
+        }
+        recordValue(value) {
+          return this.returnNow(value);
+        }
+        parseInf() {
+          if (this.char === CHAR_n) {
+            return this.next(this.parseInf2);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+          }
+        }
+        parseInf2() {
+          if (this.char === CHAR_f) {
+            if (this.state.buf === "-") {
+              return this.return(-Infinity);
+            } else {
+              return this.return(Infinity);
+            }
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+          }
+        }
+        parseNan() {
+          if (this.char === CHAR_a) {
+            return this.next(this.parseNan2);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "nan"'));
+          }
+        }
+        parseNan2() {
+          if (this.char === CHAR_n) {
+            return this.return(NaN);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "nan"'));
+          }
+        }
+        /* KEYS, barewords or basic, literal, or dotted */
+        parseKeyword() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseBasicString);
+          } else if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralString);
+          } else {
+            return this.goto(this.parseBareKey);
+          }
+        }
+        /* KEYS: barewords */
+        parseBareKey() {
+          do {
+            if (this.char === Parser.END) {
+              throw this.error(new TomlError("Key ended without value"));
+            } else if (isAlphaNumHyphen(this.char)) {
+              this.consume();
+            } else if (this.state.buf.length === 0) {
+              throw this.error(new TomlError("Empty bare keys are not allowed"));
+            } else {
+              return this.returnNow();
+            }
+          } while (this.nextChar());
+        }
+        /* STRINGS, single quoted (literal) */
+        parseSingleString() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiStringMaybe);
+          } else {
+            return this.goto(this.parseLiteralString);
+          }
+        }
+        parseLiteralString() {
+          do {
+            if (this.char === CHAR_APOS) {
+              return this.return();
+            } else if (this.atEndOfLine()) {
+              throw this.error(new TomlError("Unterminated string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        parseLiteralMultiStringMaybe() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiString);
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseLiteralMultiString() {
+          if (this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CTRL_J) {
+            return this.next(this.parseLiteralMultiStringContent);
+          } else {
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        parseLiteralMultiStringContent() {
+          do {
+            if (this.char === CHAR_APOS) {
+              return this.next(this.parseLiteralMultiEnd);
+            } else if (this.char === Parser.END) {
+              throw this.error(new TomlError("Unterminated multi-line string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        parseLiteralMultiEnd() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiEnd2);
+          } else {
+            this.state.buf += "'";
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        parseLiteralMultiEnd2() {
+          if (this.char === CHAR_APOS) {
+            return this.return();
+          } else {
+            this.state.buf += "''";
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        /* STRINGS double quoted */
+        parseDoubleString() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiStringMaybe);
+          } else {
+            return this.goto(this.parseBasicString);
+          }
+        }
+        parseBasicString() {
+          do {
+            if (this.char === CHAR_BSOL) {
+              return this.call(this.parseEscape, this.recordEscapeReplacement);
+            } else if (this.char === CHAR_QUOT) {
+              return this.return();
+            } else if (this.atEndOfLine()) {
+              throw this.error(new TomlError("Unterminated string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        recordEscapeReplacement(replacement) {
+          this.state.buf += replacement;
+          return this.goto(this.parseBasicString);
+        }
+        parseMultiStringMaybe() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiString);
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseMultiString() {
+          if (this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CTRL_J) {
+            return this.next(this.parseMultiStringContent);
+          } else {
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiStringContent() {
+          do {
+            if (this.char === CHAR_BSOL) {
+              return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
+            } else if (this.char === CHAR_QUOT) {
+              return this.next(this.parseMultiEnd);
+            } else if (this.char === Parser.END) {
+              throw this.error(new TomlError("Unterminated multi-line string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        errorControlCharInString() {
+          let displayCode = "\\u00";
+          if (this.char < 16) {
+            displayCode += "0";
+          }
+          displayCode += this.char.toString(16);
+          return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`));
+        }
+        recordMultiEscapeReplacement(replacement) {
+          this.state.buf += replacement;
+          return this.goto(this.parseMultiStringContent);
+        }
+        parseMultiEnd() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiEnd2);
+          } else {
+            this.state.buf += '"';
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiEnd2() {
+          if (this.char === CHAR_QUOT) {
+            return this.return();
+          } else {
+            this.state.buf += '""';
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiEscape() {
+          if (this.char === CTRL_M || this.char === CTRL_J) {
+            return this.next(this.parseMultiTrim);
+          } else if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return this.next(this.parsePreMultiTrim);
+          } else {
+            return this.goto(this.parseEscape);
+          }
+        }
+        parsePreMultiTrim() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CTRL_M || this.char === CTRL_J) {
+            return this.next(this.parseMultiTrim);
+          } else {
+            throw this.error(new TomlError("Can't escape whitespace"));
+          }
+        }
+        parseMultiTrim() {
+          if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseEscape() {
+          if (this.char in escapes) {
+            return this.return(escapes[this.char]);
+          } else if (this.char === CHAR_u) {
+            return this.call(this.parseSmallUnicode, this.parseUnicodeReturn);
+          } else if (this.char === CHAR_U) {
+            return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
+          } else {
+            throw this.error(new TomlError("Unknown escape character: " + this.char));
+          }
+        }
+        parseUnicodeReturn(char) {
+          try {
+            const codePoint = parseInt(char, 16);
+            if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) {
+              throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
+            }
+            return this.returnNow(String.fromCodePoint(codePoint));
+          } catch (err) {
+            throw this.error(TomlError.wrap(err));
+          }
+        }
+        parseSmallUnicode() {
+          if (!isHexit(this.char)) {
+            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+          } else {
+            this.consume();
+            if (this.state.buf.length >= 4) return this.return();
+          }
+        }
+        parseLargeUnicode() {
+          if (!isHexit(this.char)) {
+            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+          } else {
+            this.consume();
+            if (this.state.buf.length >= 8) return this.return();
+          }
+        }
+        /* NUMBERS */
+        parseNumberSign() {
+          this.consume();
+          return this.next(this.parseMaybeSignedInfOrNan);
+        }
+        parseMaybeSignedInfOrNan() {
+          if (this.char === CHAR_i) {
+            return this.next(this.parseInf);
+          } else if (this.char === CHAR_n) {
+            return this.next(this.parseNan);
+          } else {
+            return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart);
+          }
+        }
+        parseNumberIntegerStart() {
+          if (this.char === CHAR_0) {
+            this.consume();
+            return this.next(this.parseNumberIntegerExponentOrDecimal);
+          } else {
+            return this.goto(this.parseNumberInteger);
+          }
+        }
+        parseNumberIntegerExponentOrDecimal() {
+          if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseNumberInteger() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseNoUnder() {
+          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) {
+            throw this.error(new TomlError("Unexpected character, expected digit"));
+          } else if (this.atEndOfWord()) {
+            throw this.error(new TomlError("Incomplete number"));
+          }
+          return this.returnNow();
+        }
+        parseNoUnderHexOctBinLiteral() {
+          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD) {
+            throw this.error(new TomlError("Unexpected character, expected digit"));
+          } else if (this.atEndOfWord()) {
+            throw this.error(new TomlError("Incomplete number"));
+          }
+          return this.returnNow();
+        }
+        parseNumberFloat() {
+          if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else {
+            return this.returnNow(Float(this.state.buf));
+          }
+        }
+        parseNumberExponentSign() {
+          if (isDigit(this.char)) {
+            return this.goto(this.parseNumberExponent);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.call(this.parseNoUnder, this.parseNumberExponent);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected -, + or digit"));
+          }
+        }
+        parseNumberExponent() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder);
+          } else {
+            return this.returnNow(Float(this.state.buf));
+          }
+        }
+        /* NUMBERS or DATETIMES  */
+        parseNumberOrDateTime() {
+          if (this.char === CHAR_0) {
+            this.consume();
+            return this.next(this.parseNumberBaseOrDateTime);
+          } else {
+            return this.goto(this.parseNumberOrDateTimeOnly);
+          }
+        }
+        parseNumberOrDateTimeOnly() {
+          if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder, this.parseNumberInteger);
+          } else if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length > 4) this.next(this.parseNumberInteger);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (this.char === CHAR_HYPHEN) {
+            return this.goto(this.parseDateTime);
+          } else if (this.char === CHAR_COLON) {
+            return this.goto(this.parseOnlyTimeHour);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseDateTimeOnly() {
+          if (this.state.buf.length < 4) {
+            if (isDigit(this.char)) {
+              return this.consume();
+            } else if (this.char === CHAR_COLON) {
+              return this.goto(this.parseOnlyTimeHour);
+            } else {
+              throw this.error(new TomlError("Expected digit while parsing year part of a date"));
+            }
+          } else {
+            if (this.char === CHAR_HYPHEN) {
+              return this.goto(this.parseDateTime);
+            } else {
+              throw this.error(new TomlError("Expected hyphen (-) while parsing year part of date"));
+            }
+          }
+        }
+        parseNumberBaseOrDateTime() {
+          if (this.char === CHAR_b) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerBin);
+          } else if (this.char === CHAR_o) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerOct);
+          } else if (this.char === CHAR_x) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerHex);
+          } else if (this.char === CHAR_PERIOD) {
+            return this.goto(this.parseNumberInteger);
+          } else if (isDigit(this.char)) {
+            return this.goto(this.parseDateTimeOnly);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseIntegerHex() {
+          if (isHexit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseIntegerOct() {
+          if (isOctit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseIntegerBin() {
+          if (isBit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        /* DATETIME */
+        parseDateTime() {
+          if (this.state.buf.length < 4) {
+            throw this.error(new TomlError("Years less than 1000 must be zero padded to four characters"));
+          }
+          this.state.result = this.state.buf;
+          this.state.buf = "";
+          return this.next(this.parseDateMonth);
+        }
+        parseDateMonth() {
+          if (this.char === CHAR_HYPHEN) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Months less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "-" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseDateDay);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseDateDay() {
+          if (this.char === CHAR_T || this.char === CHAR_SP) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Days less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "-" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseStartTimeHour);
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDate(this.state.result + "-" + this.state.buf));
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseStartTimeHour() {
+          if (this.atEndOfWord()) {
+            return this.returnNow(createDate(this.state.result));
+          } else {
+            return this.goto(this.parseTimeHour);
+          }
+        }
+        parseTimeHour() {
+          if (this.char === CHAR_COLON) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "T" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseTimeMin);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseTimeMin() {
+          if (this.state.buf.length < 2 && isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+            this.state.result += ":" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseTimeSec);
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseTimeSec() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length === 2) {
+              this.state.result += ":" + this.state.buf;
+              this.state.buf = "";
+              return this.next(this.parseTimeZoneOrFraction);
+            }
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseOnlyTimeHour() {
+          if (this.char === CHAR_COLON) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+            }
+            this.state.result = this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseOnlyTimeMin);
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeMin() {
+          if (this.state.buf.length < 2 && isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+            this.state.result += ":" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseOnlyTimeSec);
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeSec() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length === 2) {
+              return this.next(this.parseOnlyTimeFractionMaybe);
+            }
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeFractionMaybe() {
+          this.state.result += ":" + this.state.buf;
+          if (this.char === CHAR_PERIOD) {
+            this.state.buf = "";
+            this.next(this.parseOnlyTimeFraction);
+          } else {
+            return this.return(createTime(this.state.result));
+          }
+        }
+        parseOnlyTimeFraction() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.atEndOfWord()) {
+            if (this.state.buf.length === 0) throw this.error(new TomlError("Expected digit in milliseconds"));
+            return this.returnNow(createTime(this.state.result + "." + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseTimeZoneOrFraction() {
+          if (this.char === CHAR_PERIOD) {
+            this.consume();
+            this.next(this.parseDateTimeFraction);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.next(this.parseTimeZoneHour);
+          } else if (this.char === CHAR_Z) {
+            this.consume();
+            return this.return(createDateTime(this.state.result + this.state.buf));
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseDateTimeFraction() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 1) {
+            throw this.error(new TomlError("Expected digit in milliseconds"));
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.next(this.parseTimeZoneHour);
+          } else if (this.char === CHAR_Z) {
+            this.consume();
+            return this.return(createDateTime(this.state.result + this.state.buf));
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseTimeZoneHour() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (/\d\d$/.test(this.state.buf)) return this.next(this.parseTimeZoneSep);
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+          }
+        }
+        parseTimeZoneSep() {
+          if (this.char === CHAR_COLON) {
+            this.consume();
+            this.next(this.parseTimeZoneMin);
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected colon"));
+          }
+        }
+        parseTimeZoneMin() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (/\d\d$/.test(this.state.buf)) return this.return(createDateTime(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+          }
+        }
+        /* BOOLEAN */
+        parseBoolean() {
+          if (this.char === CHAR_t) {
+            this.consume();
+            return this.next(this.parseTrue_r);
+          } else if (this.char === CHAR_f) {
+            this.consume();
+            return this.next(this.parseFalse_a);
+          }
+        }
+        parseTrue_r() {
+          if (this.char === CHAR_r) {
+            this.consume();
+            return this.next(this.parseTrue_u);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseTrue_u() {
+          if (this.char === CHAR_u) {
+            this.consume();
+            return this.next(this.parseTrue_e);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseTrue_e() {
+          if (this.char === CHAR_e) {
+            return this.return(true);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_a() {
+          if (this.char === CHAR_a) {
+            this.consume();
+            return this.next(this.parseFalse_l);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_l() {
+          if (this.char === CHAR_l) {
+            this.consume();
+            return this.next(this.parseFalse_s);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_s() {
+          if (this.char === CHAR_s) {
+            this.consume();
+            return this.next(this.parseFalse_e);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_e() {
+          if (this.char === CHAR_e) {
+            return this.return(false);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        /* INLINE LISTS */
+        parseInlineList() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+            return null;
+          } else if (this.char === Parser.END) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CHAR_RSQB) {
+            return this.return(this.state.resultArr || InlineList());
+          } else {
+            return this.callNow(this.parseValue, this.recordInlineListValue);
+          }
+        }
+        recordInlineListValue(value) {
+          if (this.state.resultArr) {
+            const listType = this.state.resultArr[_contentType];
+            const valueType = tomlType(value);
+            if (listType !== valueType) {
+              throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`));
+            }
+          } else {
+            this.state.resultArr = InlineList(tomlType(value));
+          }
+          if (isFloat(value) || isInteger(value)) {
+            this.state.resultArr.push(value.valueOf());
+          } else {
+            this.state.resultArr.push(value);
+          }
+          return this.goto(this.parseInlineListNext);
+        }
+        parseInlineListNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+            return null;
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CHAR_COMMA) {
+            return this.next(this.parseInlineList);
+          } else if (this.char === CHAR_RSQB) {
+            return this.goto(this.parseInlineList);
+          } else {
+            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+          }
+        }
+        /* INLINE TABLE */
+        parseInlineTable() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_RCUB) {
+            return this.return(this.state.resultTable || InlineTable());
+          } else {
+            if (!this.state.resultTable) this.state.resultTable = InlineTable();
+            return this.callNow(this.parseAssign, this.recordInlineTableValue);
+          }
+        }
+        recordInlineTableValue(kv) {
+          let target = this.state.resultTable;
+          let finalKey = kv.key.pop();
+          for (let kw of kv.key) {
+            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            target = target[kw] = target[kw] || Table();
+          }
+          if (hasKey(target, finalKey)) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          if (isInteger(kv.value) || isFloat(kv.value)) {
+            target[finalKey] = kv.value.valueOf();
+          } else {
+            target[finalKey] = kv.value;
+          }
+          return this.goto(this.parseInlineTableNext);
+        }
+        parseInlineTableNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_COMMA) {
+            return this.next(this.parseInlineTable);
+          } else if (this.char === CHAR_RCUB) {
+            return this.goto(this.parseInlineTable);
+          } else {
+            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+          }
+        }
+      }
+      return TOMLParser;
+    }
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-pretty-error.js
+var require_parse_pretty_error = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-pretty-error.js"(exports2, module2) {
+    "use strict";
+    module2.exports = prettyError;
+    function prettyError(err, buf) {
+      if (err.pos == null || err.line == null) return err;
+      let msg = err.message;
+      msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:
+`;
+      if (buf && buf.split) {
+        const lines = buf.split(/\n/);
+        const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length;
+        let linePadding = " ";
+        while (linePadding.length < lineNumWidth) linePadding += " ";
+        for (let ii = Math.max(0, err.line - 1); ii < Math.min(lines.length, err.line + 2); ++ii) {
+          let lineNum = String(ii + 1);
+          if (lineNum.length < lineNumWidth) lineNum = " " + lineNum;
+          if (err.line === ii) {
+            msg += lineNum + "> " + lines[ii] + "\n";
+            msg += linePadding + "  ";
+            for (let hh = 0; hh < err.col; ++hh) {
+              msg += " ";
+            }
+            msg += "^\n";
+          } else {
+            msg += lineNum + ": " + lines[ii] + "\n";
+          }
+        }
+      }
+      err.message = msg + "\n";
+      return err;
+    }
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-string.js
+var require_parse_string = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-string.js"(exports2, module2) {
+    "use strict";
+    module2.exports = parseString;
+    var TOMLParser = require_toml_parser();
+    var prettyError = require_parse_pretty_error();
+    function parseString(str) {
+      if (global.Buffer && global.Buffer.isBuffer(str)) {
+        str = str.toString("utf8");
+      }
+      const parser = new TOMLParser();
+      try {
+        parser.parse(str);
+        return parser.finish();
+      } catch (err) {
+        throw prettyError(err, str);
+      }
+    }
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-async.js
+var require_parse_async = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-async.js"(exports2, module2) {
+    "use strict";
+    module2.exports = parseAsync;
+    var TOMLParser = require_toml_parser();
+    var prettyError = require_parse_pretty_error();
+    function parseAsync(str, opts) {
+      if (!opts) opts = {};
+      const index = 0;
+      const blocksize = opts.blocksize || 40960;
+      const parser = new TOMLParser();
+      return new Promise((resolve, reject) => {
+        setImmediate(parseAsyncNext, index, blocksize, resolve, reject);
+      });
+      function parseAsyncNext(index2, blocksize2, resolve, reject) {
+        if (index2 >= str.length) {
+          try {
+            return resolve(parser.finish());
+          } catch (err) {
+            return reject(prettyError(err, str));
+          }
+        }
+        try {
+          parser.parse(str.slice(index2, index2 + blocksize2));
+          setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve, reject);
+        } catch (err) {
+          reject(prettyError(err, str));
+        }
+      }
+    }
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-stream.js
+var require_parse_stream = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-stream.js"(exports2, module2) {
+    "use strict";
+    module2.exports = parseStream;
+    var stream = __require("stream");
+    var TOMLParser = require_toml_parser();
+    function parseStream(stm) {
+      if (stm) {
+        return parseReadable(stm);
+      } else {
+        return parseTransform(stm);
+      }
+    }
+    function parseReadable(stm) {
+      const parser = new TOMLParser();
+      stm.setEncoding("utf8");
+      return new Promise((resolve, reject) => {
+        let readable;
+        let ended = false;
+        let errored = false;
+        function finish() {
+          ended = true;
+          if (readable) return;
+          try {
+            resolve(parser.finish());
+          } catch (err) {
+            reject(err);
+          }
+        }
+        function error(err) {
+          errored = true;
+          reject(err);
+        }
+        stm.once("end", finish);
+        stm.once("error", error);
+        readNext();
+        function readNext() {
+          readable = true;
+          let data;
+          while ((data = stm.read()) !== null) {
+            try {
+              parser.parse(data);
+            } catch (err) {
+              return error(err);
+            }
+          }
+          readable = false;
+          if (ended) return finish();
+          if (errored) return;
+          stm.once("readable", readNext);
+        }
+      });
+    }
+    function parseTransform() {
+      const parser = new TOMLParser();
+      return new stream.Transform({
+        objectMode: true,
+        transform(chunk, encoding, cb) {
+          try {
+            parser.parse(chunk.toString(encoding));
+          } catch (err) {
+            this.emit("error", err);
+          }
+          cb();
+        },
+        flush(cb) {
+          try {
+            this.push(parser.finish());
+          } catch (err) {
+            this.emit("error", err);
+          }
+          cb();
+        }
+      });
+    }
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse.js
+var require_parse = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_parse_string();
+    module2.exports.async = require_parse_async();
+    module2.exports.stream = require_parse_stream();
+    module2.exports.prettyError = require_parse_pretty_error();
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/stringify.js
+var require_stringify = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/stringify.js"(exports2, module2) {
+    "use strict";
+    module2.exports = stringify;
+    module2.exports.value = stringifyInline;
+    function stringify(obj) {
+      if (obj === null) throw typeError("null");
+      if (obj === void 0) throw typeError("undefined");
+      if (typeof obj !== "object") throw typeError(typeof obj);
+      if (typeof obj.toJSON === "function") obj = obj.toJSON();
+      if (obj == null) return null;
+      const type = tomlType2(obj);
+      if (type !== "table") throw typeError(type);
+      return stringifyObject("", "", obj);
+    }
+    function typeError(type) {
+      return new Error("Can only stringify objects, not " + type);
+    }
+    function arrayOneTypeError() {
+      return new Error("Array values can't have mixed types");
+    }
+    function getInlineKeys(obj) {
+      return Object.keys(obj).filter((key) => isInline(obj[key]));
+    }
+    function getComplexKeys(obj) {
+      return Object.keys(obj).filter((key) => !isInline(obj[key]));
+    }
+    function toJSON(obj) {
+      let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, "__proto__") ? { ["__proto__"]: void 0 } : {};
+      for (let prop of Object.keys(obj)) {
+        if (obj[prop] && typeof obj[prop].toJSON === "function" && !("toISOString" in obj[prop])) {
+          nobj[prop] = obj[prop].toJSON();
+        } else {
+          nobj[prop] = obj[prop];
+        }
+      }
+      return nobj;
+    }
+    function stringifyObject(prefix, indent, obj) {
+      obj = toJSON(obj);
+      var inlineKeys;
+      var complexKeys;
+      inlineKeys = getInlineKeys(obj);
+      complexKeys = getComplexKeys(obj);
+      var result = [];
+      var inlineIndent = indent || "";
+      inlineKeys.forEach((key) => {
+        var type = tomlType2(obj[key]);
+        if (type !== "undefined" && type !== "null") {
+          result.push(inlineIndent + stringifyKey(key) + " = " + stringifyAnyInline(obj[key], true));
+        }
+      });
+      if (result.length > 0) result.push("");
+      var complexIndent = prefix && inlineKeys.length > 0 ? indent + "  " : "";
+      complexKeys.forEach((key) => {
+        result.push(stringifyComplex(prefix, complexIndent, key, obj[key]));
+      });
+      return result.join("\n");
+    }
+    function isInline(value) {
+      switch (tomlType2(value)) {
+        case "undefined":
+        case "null":
+        case "integer":
+        case "nan":
+        case "float":
+        case "boolean":
+        case "string":
+        case "datetime":
+          return true;
+        case "array":
+          return value.length === 0 || tomlType2(value[0]) !== "table";
+        case "table":
+          return Object.keys(value).length === 0;
+        /* istanbul ignore next */
+        default:
+          return false;
+      }
+    }
+    function tomlType2(value) {
+      if (value === void 0) {
+        return "undefined";
+      } else if (value === null) {
+        return "null";
+      } else if (typeof value === "bigint" || Number.isInteger(value) && !Object.is(value, -0)) {
+        return "integer";
+      } else if (typeof value === "number") {
+        return "float";
+      } else if (typeof value === "boolean") {
+        return "boolean";
+      } else if (typeof value === "string") {
+        return "string";
+      } else if ("toISOString" in value) {
+        return isNaN(value) ? "undefined" : "datetime";
+      } else if (Array.isArray(value)) {
+        return "array";
+      } else {
+        return "table";
+      }
+    }
+    function stringifyKey(key) {
+      var keyStr = String(key);
+      if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
+        return keyStr;
+      } else {
+        return stringifyBasicString(keyStr);
+      }
+    }
+    function stringifyBasicString(str) {
+      return '"' + escapeString(str).replace(/"/g, '\\"') + '"';
+    }
+    function stringifyLiteralString(str) {
+      return "'" + str + "'";
+    }
+    function numpad(num, str) {
+      while (str.length < num) str = "0" + str;
+      return str;
+    }
+    function escapeString(str) {
+      return str.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r").replace(/([\u0000-\u001f\u007f])/, (c) => "\\u" + numpad(4, c.codePointAt(0).toString(16)));
+    }
+    function stringifyMultilineString(str) {
+      let escaped = str.split(/\n/).map((str2) => {
+        return escapeString(str2).replace(/"(?="")/g, '\\"');
+      }).join("\n");
+      if (escaped.slice(-1) === '"') escaped += "\\\n";
+      return '"""\n' + escaped + '"""';
+    }
+    function stringifyAnyInline(value, multilineOk) {
+      let type = tomlType2(value);
+      if (type === "string") {
+        if (multilineOk && /\n/.test(value)) {
+          type = "string-multiline";
+        } else if (!/[\b\t\n\f\r']/.test(value) && /"/.test(value)) {
+          type = "string-literal";
+        }
+      }
+      return stringifyInline(value, type);
+    }
+    function stringifyInline(value, type) {
+      if (!type) type = tomlType2(value);
+      switch (type) {
+        case "string-multiline":
+          return stringifyMultilineString(value);
+        case "string":
+          return stringifyBasicString(value);
+        case "string-literal":
+          return stringifyLiteralString(value);
+        case "integer":
+          return stringifyInteger(value);
+        case "float":
+          return stringifyFloat(value);
+        case "boolean":
+          return stringifyBoolean(value);
+        case "datetime":
+          return stringifyDatetime(value);
+        case "array":
+          return stringifyInlineArray(value.filter((_) => tomlType2(_) !== "null" && tomlType2(_) !== "undefined" && tomlType2(_) !== "nan"));
+        case "table":
+          return stringifyInlineTable(value);
+        /* istanbul ignore next */
+        default:
+          throw typeError(type);
+      }
+    }
+    function stringifyInteger(value) {
+      return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+    }
+    function stringifyFloat(value) {
+      if (value === Infinity) {
+        return "inf";
+      } else if (value === -Infinity) {
+        return "-inf";
+      } else if (Object.is(value, NaN)) {
+        return "nan";
+      } else if (Object.is(value, -0)) {
+        return "-0.0";
+      }
+      var chunks = String(value).split(".");
+      var int = chunks[0];
+      var dec = chunks[1] || 0;
+      return stringifyInteger(int) + "." + dec;
+    }
+    function stringifyBoolean(value) {
+      return String(value);
+    }
+    function stringifyDatetime(value) {
+      return value.toISOString();
+    }
+    function isNumber(type) {
+      return type === "float" || type === "integer";
+    }
+    function arrayType(values) {
+      var contentType = tomlType2(values[0]);
+      if (values.every((_) => tomlType2(_) === contentType)) return contentType;
+      if (values.every((_) => isNumber(tomlType2(_)))) return "float";
+      return "mixed";
+    }
+    function validateArray(values) {
+      const type = arrayType(values);
+      if (type === "mixed") {
+        throw arrayOneTypeError();
+      }
+      return type;
+    }
+    function stringifyInlineArray(values) {
+      values = toJSON(values);
+      const type = validateArray(values);
+      var result = "[";
+      var stringified = values.map((_) => stringifyInline(_, type));
+      if (stringified.join(", ").length > 60 || /\n/.test(stringified)) {
+        result += "\n  " + stringified.join(",\n  ") + "\n";
+      } else {
+        result += " " + stringified.join(", ") + (stringified.length > 0 ? " " : "");
+      }
+      return result + "]";
+    }
+    function stringifyInlineTable(value) {
+      value = toJSON(value);
+      var result = [];
+      Object.keys(value).forEach((key) => {
+        result.push(stringifyKey(key) + " = " + stringifyAnyInline(value[key], false));
+      });
+      return "{ " + result.join(", ") + (result.length > 0 ? " " : "") + "}";
+    }
+    function stringifyComplex(prefix, indent, key, value) {
+      var valueType = tomlType2(value);
+      if (valueType === "array") {
+        return stringifyArrayOfTables(prefix, indent, key, value);
+      } else if (valueType === "table") {
+        return stringifyComplexTable(prefix, indent, key, value);
+      } else {
+        throw typeError(valueType);
+      }
+    }
+    function stringifyArrayOfTables(prefix, indent, key, values) {
+      values = toJSON(values);
+      validateArray(values);
+      var firstValueType = tomlType2(values[0]);
+      if (firstValueType !== "table") throw typeError(firstValueType);
+      var fullKey = prefix + stringifyKey(key);
+      var result = "";
+      values.forEach((table) => {
+        if (result.length > 0) result += "\n";
+        result += indent + "[[" + fullKey + "]]\n";
+        result += stringifyObject(fullKey + ".", indent, table);
+      });
+      return result;
+    }
+    function stringifyComplexTable(prefix, indent, key, value) {
+      var fullKey = prefix + stringifyKey(key);
+      var result = "";
+      if (getInlineKeys(value).length > 0) {
+        result += indent + "[" + fullKey + "]\n";
+      }
+      return result + stringifyObject(fullKey + ".", indent, value);
+    }
+  }
+});
+
+// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/toml.js
+var require_toml = __commonJS({
+  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/toml.js"(exports2) {
+    "use strict";
+    exports2.parse = require_parse();
+    exports2.stringify = require_stringify();
+  }
+});
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config.js
+import path6 from "node:path";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config/read-config.js
+import fs2 from "node:fs/promises";
+import path from "node:path";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config-schema.js
+var ImportKindSchema = external_exports.enum(["cursor", "claude-code", "claude-desktop", "codex", "windsurf", "opencode", "vscode"]).describe("Supported editor/client configurations to import MCP servers from");
+var DEFAULT_IMPORTS = [
+  "cursor",
+  "claude-code",
+  "claude-desktop",
+  "codex",
+  "windsurf",
+  "opencode",
+  "vscode"
+];
+var RawLifecycleSchema = external_exports.union([
+  external_exports.literal("keep-alive").describe("Keep the server connection alive"),
+  external_exports.literal("ephemeral").describe("Connect only when needed"),
+  external_exports.object({
+    mode: external_exports.union([external_exports.literal("keep-alive"), external_exports.literal("ephemeral")]).describe("Connection lifecycle mode"),
+    idleTimeoutMs: external_exports.number().int().positive().optional().describe("Idle timeout in milliseconds before disconnecting")
+  })
+]).describe("Server connection lifecycle: keep-alive maintains persistent connections, ephemeral connects on-demand");
+var ToolNamesSchema = external_exports.array(external_exports.string()).describe("Exact MCP tool names");
+var RawLoggingSchema = external_exports.object({
+  daemon: external_exports.object({
+    enabled: external_exports.boolean().optional().describe("Enable daemon logging for this server")
+  }).optional().describe("Daemon-specific logging configuration")
+}).optional().describe("Logging configuration for the server");
+var RawHttpFetchSchema = external_exports.enum(["default", "node-http1"]).describe("HTTP fetch implementation for Streamable HTTP/SSE requests");
+var RawRefreshSchema = external_exports.object({
+  tokenEndpoint: external_exports.string().optional().describe("OAuth token endpoint used to refresh access tokens"),
+  token_endpoint: external_exports.string().optional().describe("OAuth token endpoint used to refresh access tokens"),
+  clientIdEnv: external_exports.string().optional().describe("Environment variable containing the OAuth client id"),
+  client_id_env: external_exports.string().optional().describe("Environment variable containing the OAuth client id"),
+  clientSecretEnv: external_exports.string().optional().describe("Environment variable containing the OAuth client secret"),
+  client_secret_env: external_exports.string().optional().describe("Environment variable containing the OAuth client secret"),
+  clientAuthMethod: external_exports.string().optional().describe("OAuth token endpoint client auth method"),
+  client_auth_method: external_exports.string().optional().describe("OAuth token endpoint client auth method"),
+  refreshSkewSeconds: external_exports.number().int().nonnegative().optional().describe("Refresh before expiry by this many seconds"),
+  refresh_skew_seconds: external_exports.number().int().nonnegative().optional().describe("Refresh before expiry by this many seconds"),
+  accessTokenEnv: external_exports.string().optional().describe("STDIO env var that receives the refreshed access token"),
+  access_token_env: external_exports.string().optional().describe("STDIO env var that receives the refreshed access token")
+}).describe("Refreshable bearer token settings");
+var RawEntrySchema = external_exports.object({
+  description: external_exports.string().optional().describe("Human-readable description of the server"),
+  baseUrl: external_exports.string().optional().describe("Base URL for HTTP/SSE transport (camelCase)"),
+  base_url: external_exports.string().optional().describe("Base URL for HTTP/SSE transport (snake_case)"),
+  url: external_exports.string().optional().describe("Server URL for HTTP/SSE transport"),
+  serverUrl: external_exports.string().optional().describe("Server URL for HTTP/SSE transport (camelCase)"),
+  server_url: external_exports.string().optional().describe("Server URL for HTTP/SSE transport (snake_case)"),
+  command: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional().describe("Command to spawn for stdio transport (string or array of arguments)"),
+  executable: external_exports.string().optional().describe("Executable path for stdio transport"),
+  args: external_exports.array(external_exports.string()).optional().describe("Arguments to pass to the stdio command"),
+  cwd: external_exports.string().optional().describe("Working directory for stdio servers. A leading ~ is expanded to $HOME; relative paths resolve against the config file directory"),
+  headers: external_exports.record(external_exports.string(), external_exports.string()).optional().describe("HTTP headers for requests. Supports ${VAR}, ${VAR:-fallback}, and $env:VAR placeholders"),
+  env: external_exports.record(external_exports.string(), external_exports.string()).optional().describe("Environment variables for stdio commands. Supports ${VAR} and ${VAR:-fallback} placeholders"),
+  auth: external_exports.string().optional().describe('Authentication method (e.g., "oauth")'),
+  tokenCacheDir: external_exports.string().optional().describe("Directory for caching OAuth tokens (camelCase)"),
+  token_cache_dir: external_exports.string().optional().describe("Directory for caching OAuth tokens (snake_case)"),
+  clientName: external_exports.string().optional().describe("Client identifier for server telemetry (camelCase)"),
+  client_name: external_exports.string().optional().describe("Client identifier for server telemetry (snake_case)"),
+  oauthClientId: external_exports.string().optional().describe("Pre-registered OAuth client id (camelCase)"),
+  oauth_client_id: external_exports.string().optional().describe("Pre-registered OAuth client id (snake_case)"),
+  oauthClientSecret: external_exports.string().optional().describe("Pre-registered OAuth client secret (camelCase)"),
+  oauth_client_secret: external_exports.string().optional().describe("Pre-registered OAuth client secret (snake_case)"),
+  oauthClientSecretEnv: external_exports.string().optional().describe("Environment variable containing the OAuth client secret"),
+  oauth_client_secret_env: external_exports.string().optional().describe("Environment variable containing the OAuth client secret"),
+  oauthTokenEndpointAuthMethod: external_exports.string().optional().describe("OAuth token endpoint auth method, e.g. client_secret_post"),
+  oauth_token_endpoint_auth_method: external_exports.string().optional().describe("OAuth token endpoint auth method, e.g. client_secret_post"),
+  oauthRedirectUrl: external_exports.string().optional().describe("Custom OAuth redirect URL (camelCase)"),
+  oauth_redirect_url: external_exports.string().optional().describe("Custom OAuth redirect URL (snake_case)"),
+  oauthScope: external_exports.string().optional().describe("OAuth scope override (camelCase)"),
+  oauth_scope: external_exports.string().optional().describe("OAuth scope override (snake_case)"),
+  oauthCommand: external_exports.object({
+    args: external_exports.array(external_exports.string()).describe("Arguments for the OAuth command")
+  }).optional().describe("Custom OAuth command configuration for stdio servers (camelCase)"),
+  oauth_command: external_exports.object({
+    args: external_exports.array(external_exports.string()).describe("Arguments for the OAuth command")
+  }).optional().describe("Custom OAuth command configuration for stdio servers (snake_case)"),
+  bearerToken: external_exports.string().optional().describe("Static bearer token for authentication (camelCase)"),
+  bearer_token: external_exports.string().optional().describe("Static bearer token for authentication (snake_case)"),
+  bearerTokenEnv: external_exports.string().optional().describe("Environment variable name containing the bearer token (camelCase)"),
+  bearer_token_env: external_exports.string().optional().describe("Environment variable name containing the bearer token (snake_case)"),
+  refresh: RawRefreshSchema.optional(),
+  httpFetch: RawHttpFetchSchema.optional().describe("HTTP fetch implementation for Streamable HTTP/SSE requests"),
+  http_fetch: RawHttpFetchSchema.optional().describe("HTTP fetch implementation for Streamable HTTP/SSE requests"),
+  lifecycle: RawLifecycleSchema.optional(),
+  logging: RawLoggingSchema,
+  allowedTools: ToolNamesSchema.optional().describe("Only these exact tool names are exposed (camelCase)"),
+  allowed_tools: ToolNamesSchema.optional().describe("Only these exact tool names are exposed (snake_case)"),
+  blockedTools: ToolNamesSchema.optional().describe("These exact tool names are hidden and blocked (camelCase)"),
+  blocked_tools: ToolNamesSchema.optional().describe("These exact tool names are hidden and blocked (snake_case)")
+}).superRefine((entry, ctx) => {
+  const hasAllowed = entry.allowedTools !== void 0 || entry.allowed_tools !== void 0;
+  const hasBlocked = entry.blockedTools !== void 0 || entry.blocked_tools !== void 0;
+  if (hasAllowed && hasBlocked) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Specify either allowedTools or blockedTools, not both.",
+      path: ["allowedTools"]
+    });
+  }
+}).describe("MCP server definition supporting both HTTP/SSE and stdio transports");
+var RawConfigSchema = external_exports.object({
+  mcpServers: external_exports.record(external_exports.string(), RawEntrySchema).describe("Map of server names to their configurations"),
+  daemonIdleTimeoutMs: external_exports.number().int().positive().optional().describe("Idle timeout in milliseconds before shutting down an inactive daemon"),
+  daemon_idle_timeout_ms: external_exports.number().int().positive().optional().describe("Idle timeout in milliseconds before shutting down an inactive daemon"),
+  imports: external_exports.array(ImportKindSchema).optional().describe("Editor configurations to import servers from. Omit to use defaults, or set to [] to disable imports")
+}).describe("mcporter configuration file schema");
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config/imports/shared.js
+import fs from "node:fs/promises";
+
+// node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit2(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit2(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit2(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit2(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+
+// node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function printParseErrorCode(code) {
+  switch (code) {
+    case 1:
+      return "InvalidSymbol";
+    case 2:
+      return "InvalidNumberFormat";
+    case 3:
+      return "PropertyNameExpected";
+    case 4:
+      return "ValueExpected";
+    case 5:
+      return "ColonExpected";
+    case 6:
+      return "CommaExpected";
+    case 7:
+      return "CloseBraceExpected";
+    case 8:
+      return "CloseBracketExpected";
+    case 9:
+      return "EndOfFileExpected";
+    case 10:
+      return "InvalidCommentToken";
+    case 11:
+      return "UnexpectedEndOfComment";
+    case 12:
+      return "UnexpectedEndOfString";
+    case 13:
+      return "UnexpectedEndOfNumber";
+    case 14:
+      return "InvalidUnicode";
+    case 15:
+      return "InvalidEscapeCharacter";
+    case 16:
+      return "InvalidCharacter";
+  }
+  return "<unknown ParseErrorCode>";
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config/imports/shared.js
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseJsonBuffer(buffer) {
+  const errors = [];
+  const parsed = parse2(buffer, errors, { allowTrailingComma: true });
+  const first = errors[0];
+  if (first) {
+    const message = printParseErrorCode(first.error);
+    throw new SyntaxError(`Failed to parse JSON (offset ${first.offset}): ${message}`);
+  }
+  return parsed;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config/read-config.js
+async function loadConfigLayers(options, rootDir) {
+  const explicitPath = options.configPath ?? process.env.MCPORTER_CONFIG;
+  if (explicitPath) {
+    const resolvedPath = path.resolve(expandHome(explicitPath.trim()));
+    const config = await readConfigFile(resolvedPath, true);
+    return [{ config, path: resolvedPath, explicit: true }];
+  }
+  const layers = [];
+  const homeCandidates = homeConfigCandidates();
+  const existingHome = homeCandidates.find((candidate) => pathExists(candidate));
+  if (existingHome) {
+    layers.push({ config: await readConfigFile(existingHome, false), path: existingHome, explicit: false });
+  }
+  const projectPath = path.resolve(rootDir, "config", "mcporter.json");
+  if (pathExists(projectPath)) {
+    layers.push({ config: await readConfigFile(projectPath, false), path: projectPath, explicit: false });
+  }
+  if (layers.length === 0) {
+    layers.push({ config: { mcpServers: {} }, path: projectPath, explicit: false });
+  }
+  return layers;
+}
+async function readConfigFile(configPath, explicit) {
+  if (!explicit && !await pathExistsAsync(configPath)) {
+    return { mcpServers: {} };
+  }
+  try {
+    const buffer = await fs2.readFile(configPath, "utf8");
+    return RawConfigSchema.parse(parseJsonBuffer(buffer));
+  } catch (error) {
+    if (!explicit && isMissingConfigError(error)) {
+      return { mcpServers: {} };
+    }
+    if (!explicit && isSyntaxError(error)) {
+      warnConfigFallback(configPath, error);
+      return { mcpServers: {} };
+    }
+    throw error;
+  }
+}
+function isErrno(error, code) {
+  return Boolean(error && typeof error === "object" && error.code === code);
+}
+function isMissingConfigError(error) {
+  return isErrno(error, "ENOENT") || includesErrnoMessage(error, "ENOENT");
+}
+function isSyntaxError(error) {
+  return error instanceof SyntaxError;
+}
+var warnedConfigPaths = /* @__PURE__ */ new Set();
+function warnConfigFallback(configPath, error) {
+  if (warnedConfigPaths.has(configPath)) {
+    return;
+  }
+  warnedConfigPaths.add(configPath);
+  const reason = error instanceof Error ? error.message : String(error);
+  console.warn(`[mcporter] Ignoring config at ${configPath}: ${reason}`);
+}
+function includesErrnoMessage(error, code) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const message = error.message;
+  return typeof message === "string" && message.includes(code);
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config/imports/external.js
+var import_toml = __toESM(require_toml(), 1);
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config/imports/paths-utils.js
+import os from "node:os";
+import path2 from "node:path";
+function normalizeProjectPath(input) {
+  if (!input || typeof input !== "string") {
+    return "";
+  }
+  return path2.resolve(expandHomeShortcut(input));
+}
+function expandHomeShortcut(input) {
+  if (input === "~") {
+    return os.homedir();
+  }
+  if (input.startsWith("~/") || input.startsWith("~\\")) {
+    return path2.join(os.homedir(), input.slice(2));
+  }
+  return input;
+}
+function pathsEqual(a, b) {
+  if (!a || !b) {
+    return false;
+  }
+  if (process.platform === "win32") {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+  return a === b;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config/imports/external.js
+async function readExternalEntries(filePath, options = {}) {
+  if (!await fileExists(filePath)) {
+    return null;
+  }
+  const buffer = await fs3.readFile(filePath, "utf8");
+  if (!buffer.trim()) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    if (filePath.endsWith(".toml")) {
+      const parsed2 = (0, import_toml.parse)(buffer);
+      return extractFromCodexConfig(parsed2);
+    }
+    const parsed = parseJsonBuffer(buffer);
+    return extractFromMcpJson(parsed, options, filePath);
+  } catch (error) {
+    if (shouldIgnoreParseError(error)) {
+      return /* @__PURE__ */ new Map();
+    }
+    throw error;
+  }
+}
+function extractFromMcpJson(raw, options, filePath) {
+  const map = /* @__PURE__ */ new Map();
+  if (!isRecord(raw)) {
+    return map;
+  }
+  const { importKind, projectRoot } = options;
+  const descriptor2 = resolveContainerDescriptor(importKind, filePath);
+  const containers = [];
+  if (descriptor2.allowMcpServers && isRecord(raw.mcpServers)) {
+    containers.push(raw.mcpServers);
+  }
+  if (descriptor2.allowServers && isRecord(raw.servers)) {
+    containers.push(raw.servers);
+  }
+  if (descriptor2.allowMcp && isRecord(raw.mcp)) {
+    containers.push(raw.mcp);
+  }
+  if (descriptor2.allowRootFallback && containers.length === 0) {
+    containers.push(raw);
+  }
+  for (const container of containers) {
+    addEntriesFromContainer(container, map);
+  }
+  if (projectRoot) {
+    const projectEntries = extractClaudeProjectEntries(raw, projectRoot);
+    for (const [name, entry] of projectEntries) {
+      if (!map.has(name)) {
+        map.set(name, entry);
+      }
+    }
+  }
+  return map;
+}
+function extractFromCodexConfig(raw) {
+  const map = /* @__PURE__ */ new Map();
+  const serversRaw = raw.mcp_servers;
+  if (!serversRaw || typeof serversRaw !== "object") {
+    return map;
+  }
+  for (const [name, value] of Object.entries(serversRaw)) {
+    if (!value || typeof value !== "object") {
+      continue;
+    }
+    const entry = convertExternalEntry(value);
+    if (entry) {
+      map.set(name, entry);
+    }
+  }
+  return map;
+}
+function convertExternalEntry(value) {
+  const result = {};
+  if (typeof value.description === "string") {
+    result.description = value.description;
+  }
+  const env = asStringRecord(value.env);
+  if (env) {
+    result.env = env;
+  }
+  const headers = buildExternalHeaders(value);
+  if (headers) {
+    result.headers = headers;
+  }
+  const auth = asString(value.auth);
+  if (auth) {
+    result.auth = auth;
+  }
+  const tokenCacheDir = asString(value.tokenCacheDir ?? value.token_cache_dir ?? value.token_cacheDir);
+  if (tokenCacheDir) {
+    result.tokenCacheDir = tokenCacheDir;
+  }
+  const clientName = asString(value.clientName ?? value.client_name);
+  if (clientName) {
+    result.clientName = clientName;
+  }
+  const oauthClientId = asString(value.oauthClientId ?? value.oauth_client_id);
+  if (oauthClientId) {
+    result.oauthClientId = oauthClientId;
+  }
+  const oauthClientSecret = asString(value.oauthClientSecret ?? value.oauth_client_secret);
+  if (oauthClientSecret) {
+    result.oauthClientSecret = oauthClientSecret;
+  }
+  const oauthClientSecretEnv = asString(value.oauthClientSecretEnv ?? value.oauth_client_secret_env);
+  if (oauthClientSecretEnv) {
+    result.oauthClientSecretEnv = oauthClientSecretEnv;
+  }
+  const oauthTokenEndpointAuthMethod = asString(value.oauthTokenEndpointAuthMethod ?? value.oauth_token_endpoint_auth_method);
+  if (oauthTokenEndpointAuthMethod) {
+    result.oauthTokenEndpointAuthMethod = oauthTokenEndpointAuthMethod;
+  }
+  const httpFetch = asString(value.httpFetch ?? value.http_fetch);
+  if (httpFetch) {
+    result.httpFetch = httpFetch;
+  }
+  const refresh = asRefresh(value.refresh);
+  if (refresh) {
+    result.refresh = refresh;
+  }
+  const url = asString(value.baseUrl ?? value.base_url ?? value.url ?? value.serverUrl ?? value.server_url);
+  if (url) {
+    result.baseUrl = url;
+  }
+  const commandValue = value.command ?? value.executable;
+  if (Array.isArray(commandValue) && commandValue.every((item) => typeof item === "string")) {
+    result.command = commandValue;
+  } else if (typeof commandValue === "string") {
+    result.command = commandValue;
+  }
+  if (Array.isArray(value.args) && value.args.every((item) => typeof item === "string")) {
+    result.args = value.args;
+  }
+  const hasHttpTarget = typeof result.baseUrl === "string";
+  const hasCommandTarget = typeof result.command === "string" || Array.isArray(result.command) && result.command.length > 0;
+  if (!hasHttpTarget && !hasCommandTarget) {
+    return null;
+  }
+  const parsed = RawEntrySchema.safeParse(result);
+  return parsed.success ? parsed.data : null;
+}
+function buildExternalHeaders(record) {
+  const headers = {};
+  const literalHeaders = asStringRecord(record.headers);
+  if (literalHeaders) {
+    Object.assign(headers, literalHeaders);
+  }
+  const bearerToken = asString(record.bearerToken ?? record.bearer_token);
+  if (bearerToken) {
+    headers.Authorization = `Bearer ${bearerToken}`;
+  }
+  const bearerTokenEnv = asString(record.bearerTokenEnv ?? record.bearer_token_env);
+  if (bearerTokenEnv) {
+    headers.Authorization = `$env:${bearerTokenEnv}`;
+  }
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+function asRefresh(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  const result = {};
+  copyString(record, result, "tokenEndpoint", "token_endpoint");
+  copyString(record, result, "clientIdEnv", "client_id_env");
+  copyString(record, result, "clientSecretEnv", "client_secret_env");
+  copyString(record, result, "clientAuthMethod", "client_auth_method");
+  copyString(record, result, "accessTokenEnv", "access_token_env");
+  const refreshSkewSeconds = record.refreshSkewSeconds ?? record.refresh_skew_seconds;
+  if (typeof refreshSkewSeconds === "number" && Number.isInteger(refreshSkewSeconds) && refreshSkewSeconds >= 0) {
+    result.refreshSkewSeconds = refreshSkewSeconds;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function copyString(source, target, camel, snake) {
+  const value = asString(source[camel] ?? source[snake]);
+  if (value) {
+    target[camel] = value;
+  }
+}
+function extractClaudeProjectEntries(raw, projectRoot) {
+  const map = /* @__PURE__ */ new Map();
+  if (!isRecord(raw.projects)) {
+    return map;
+  }
+  const projects = raw.projects;
+  const targetPath = normalizeProjectPath(projectRoot);
+  for (const [projectKey, value] of Object.entries(projects)) {
+    if (!isRecord(value) || !isRecord(value.mcpServers)) {
+      continue;
+    }
+    const normalizedKey = normalizeProjectPath(projectKey);
+    if (!pathsEqual(normalizedKey, targetPath)) {
+      continue;
+    }
+    addEntriesFromContainer(value.mcpServers, map);
+  }
+  return map;
+}
+function addEntriesFromContainer(container, target) {
+  for (const [name, value] of Object.entries(container)) {
+    if (!isRecord(value)) {
+      continue;
+    }
+    if (target.has(name)) {
+      continue;
+    }
+    const entry = convertExternalEntry(value);
+    if (entry) {
+      target.set(name, entry);
+    }
+  }
+}
+function resolveContainerDescriptor(importKind, filePath) {
+  if (importKind === "opencode") {
+    return {
+      allowMcpServers: false,
+      allowServers: false,
+      allowMcp: true,
+      allowRootFallback: false
+    };
+  }
+  if (importKind === "claude-code" && filePath) {
+    const normalized = path3.normalize(filePath);
+    const allowRootFallback = normalized.endsWith(".claude.json") || normalized.endsWith(`${path3.sep}.claude${path3.sep}mcp.json`);
+    return {
+      allowMcpServers: true,
+      allowServers: true,
+      allowMcp: true,
+      allowRootFallback
+    };
+  }
+  return {
+    allowMcpServers: true,
+    allowServers: true,
+    allowMcp: true,
+    allowRootFallback: true
+  };
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asStringRecord(input) {
+  if (!input || typeof input !== "object") {
+    return void 0;
+  }
+  const record = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === "string") {
+      record[key] = value;
+    } else if (typeof value === "number" || typeof value === "boolean") {
+      record[key] = String(value);
+    }
+  }
+  return Object.keys(record).length > 0 ? record : void 0;
+}
+function shouldIgnoreParseError(error) {
+  if (error instanceof SyntaxError) {
+    return true;
+  }
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  return "fromTOML" in error;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config/imports/paths.js
+import os2 from "node:os";
+import path4 from "node:path";
+function pathsForImport(kind, rootDir) {
+  switch (kind) {
+    case "cursor":
+      return dedupePaths([
+        path4.resolve(rootDir, ".cursor", "mcp.json"),
+        path4.join(os2.homedir(), ".cursor", "mcp.json"),
+        ...defaultCursorUserConfigPaths()
+      ]);
+    case "claude-code":
+      return dedupePaths([
+        path4.resolve(rootDir, ".claude", "settings.local.json"),
+        path4.resolve(rootDir, ".claude", "settings.json"),
+        path4.resolve(rootDir, ".claude", "mcp.json"),
+        path4.join(os2.homedir(), ".claude", "settings.local.json"),
+        path4.join(os2.homedir(), ".claude", "settings.json"),
+        path4.join(os2.homedir(), ".claude", "mcp.json"),
+        path4.join(os2.homedir(), ".claude.json")
+      ]);
+    case "claude-desktop":
+      return [defaultClaudeDesktopConfigPath()];
+    case "codex":
+      return [path4.resolve(rootDir, ".codex", "config.toml"), path4.join(os2.homedir(), ".codex", "config.toml")];
+    case "windsurf":
+      return defaultWindsurfConfigPaths();
+    case "opencode":
+      return opencodeConfigPaths(rootDir);
+    case "vscode":
+      return dedupePaths([path4.resolve(rootDir, ".vscode", "mcp.json"), ...defaultVscodeConfigPaths()]);
+    default:
+      return [];
+  }
+}
+function defaultCursorUserConfigPaths() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  const configs = xdgConfig ? [path4.join(xdgConfig, "Cursor", "User", "mcp.json")] : [];
+  return dedupePaths([
+    path4.join(os2.homedir(), "AppData", "Roaming", "Cursor", "User", "mcp.json"),
+    path4.join(os2.homedir(), "Library", "Application Support", "Cursor", "User", "mcp.json"),
+    ...configs
+  ]);
+}
+function defaultWindsurfConfigPaths() {
+  const homeDir = os2.homedir();
+  const paths = [
+    path4.join(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+    path4.join(homeDir, ".codeium", "windsurf-next", "mcp_config.json"),
+    path4.join(homeDir, ".windsurf", "mcp_config.json"),
+    path4.join(homeDir, ".config", ".codeium", "windsurf", "mcp_config.json")
+  ];
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path4.join(homeDir, "AppData", "Roaming");
+    paths.push(path4.join(appData, "Codeium", "windsurf", "mcp_config.json"));
+  }
+  return dedupePaths(paths);
+}
+function defaultVscodeConfigPaths() {
+  if (process.platform === "darwin") {
+    return [
+      path4.join(os2.homedir(), "Library", "Application Support", "Code", "User", "mcp.json"),
+      path4.join(os2.homedir(), "Library", "Application Support", "Code - Insiders", "User", "mcp.json")
+    ];
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path4.join(os2.homedir(), "AppData", "Roaming");
+    return [path4.join(appData, "Code", "User", "mcp.json"), path4.join(appData, "Code - Insiders", "User", "mcp.json")];
+  }
+  return [
+    path4.join(os2.homedir(), ".config", "Code", "User", "mcp.json"),
+    path4.join(os2.homedir(), ".config", "Code - Insiders", "User", "mcp.json")
+  ];
+}
+function opencodeConfigPaths(rootDir) {
+  const overrideConfig = process.env.OPENCODE_CONFIG;
+  const overrideDir = process.env.OPENCODE_CONFIG_DIR;
+  const envConfigPath = process.env.OPENAI_WORKDIR;
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const configHome = xdg ?? path4.join(process.env.HOME ?? "", ".config");
+  const paths = [
+    overrideConfig ?? "",
+    path4.resolve(rootDir, "opencode.jsonc"),
+    path4.resolve(rootDir, "opencode.json")
+  ];
+  if (overrideDir && overrideDir.length > 0) {
+    paths.push(path4.join(overrideDir, "opencode.jsonc"), path4.join(overrideDir, "opencode.json"));
+  }
+  paths.push(path4.resolve(rootDir, ".openai", "config.json"), envConfigPath ? path4.resolve(envConfigPath, ".openai", "config.json") : "", path4.join(configHome, "openai", "config.json"));
+  for (const dir of defaultOpencodeConfigDirs()) {
+    paths.push(path4.join(dir, "opencode.jsonc"), path4.join(dir, "opencode.json"));
+  }
+  return dedupePaths(paths);
+}
+function defaultOpencodeConfigDirs() {
+  const dirs = [];
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg && xdg.length > 0) {
+    dirs.push(path4.join(xdg, "opencode"));
+  } else if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path4.join(os2.homedir(), "AppData", "Roaming");
+    dirs.push(path4.join(appData, "opencode"));
+  } else {
+    dirs.push(path4.join(os2.homedir(), ".config", "opencode"));
+  }
+  return dirs;
+}
+function defaultClaudeDesktopConfigPath() {
+  const homeDir = os2.homedir();
+  const darwinPath = path4.join(homeDir, "Library", "Application Support", "Claude", "settings.json");
+  const windowsPath = path4.join(homeDir, "AppData", "Roaming", "Claude", "settings.json");
+  const linuxPath = path4.join(homeDir, ".config", "Claude", "settings.json");
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return darwinPath;
+  }
+  if (platform === "win32") {
+    return windowsPath;
+  }
+  return linuxPath;
+}
+function dedupePaths(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const candidate of paths) {
+    if (!candidate || seen.has(candidate)) {
+      continue;
+    }
+    seen.add(candidate);
+    result.push(candidate);
+  }
+  return result;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config-normalize.js
+import fs4 from "node:fs";
+import path5 from "node:path";
+function normalizeServerEntry(name, raw, baseDir, source, sources) {
+  const resolvedRaw = resolveConfigEnvPlaceholders(name, raw);
+  raw = resolvedRaw;
+  const description = raw.description;
+  const env = raw.env ? { ...raw.env } : void 0;
+  const auth = normalizeAuth(raw.auth);
+  const tokenCacheDir = normalizePath(raw.tokenCacheDir ?? raw.token_cache_dir);
+  const clientName = raw.clientName ?? raw.client_name;
+  const oauthClientId = raw.oauthClientId ?? raw.oauth_client_id ?? void 0;
+  const oauthClientSecret = raw.oauthClientSecret ?? raw.oauth_client_secret ?? void 0;
+  const oauthClientSecretEnv = raw.oauthClientSecretEnv ?? raw.oauth_client_secret_env ?? void 0;
+  const oauthTokenEndpointAuthMethod = raw.oauthTokenEndpointAuthMethod ?? raw.oauth_token_endpoint_auth_method ?? void 0;
+  const oauthRedirectUrl = raw.oauthRedirectUrl ?? raw.oauth_redirect_url ?? void 0;
+  const oauthScope = raw.oauthScope ?? raw.oauth_scope ?? void 0;
+  const refresh = normalizeRefresh(raw.refresh);
+  const httpFetch = normalizeHttpFetch(raw.httpFetch ?? raw.http_fetch);
+  const oauthCommandRaw = raw.oauthCommand ?? raw.oauth_command;
+  const oauthCommand = oauthCommandRaw ? { args: [...oauthCommandRaw.args] } : void 0;
+  const headers = buildHeaders(raw);
+  const httpUrl = getUrl(raw);
+  const stdio = getCommand(raw, baseDir);
+  let command;
+  if (httpUrl) {
+    command = {
+      kind: "http",
+      url: new URL(httpUrl),
+      headers: ensureHttpAcceptHeader(headers)
+    };
+  } else if (stdio) {
+    command = {
+      kind: "stdio",
+      command: stdio.command,
+      args: stdio.args,
+      cwd: resolveCwd(raw.cwd, baseDir)
+    };
+  } else {
+    throw new Error(`Server '${name}' is missing a baseUrl/url or command definition in mcporter.json`);
+  }
+  const lifecycle = resolveLifecycle(name, raw.lifecycle, command);
+  const logging = normalizeLogging(raw.logging);
+  const allowedTools = raw.allowedTools ?? raw.allowed_tools;
+  const blockedTools = raw.blockedTools ?? raw.blocked_tools;
+  const defaultedOauthCommand = !oauthCommand && name.toLowerCase() === "gmail" && command.kind === "stdio" ? { args: ["auth", "http://localhost:3000/oauth2callback"] } : oauthCommand;
+  return {
+    name,
+    description,
+    command,
+    env,
+    auth,
+    tokenCacheDir,
+    clientName,
+    oauthClientId,
+    oauthClientSecret,
+    oauthClientSecretEnv,
+    oauthTokenEndpointAuthMethod,
+    oauthRedirectUrl,
+    oauthScope,
+    oauthCommand: defaultedOauthCommand,
+    refresh,
+    httpFetch,
+    source,
+    sources,
+    lifecycle,
+    logging,
+    ...allowedTools !== void 0 ? { allowedTools: [...allowedTools] } : {},
+    ...blockedTools !== void 0 ? { blockedTools: [...blockedTools] } : {}
+  };
+}
+var __configInternals = {
+  ensureHttpAcceptHeader,
+  resolveConfigEnvPlaceholders
+};
+function resolveConfigEnvPlaceholders(name, raw) {
+  return resolveConfigEnvValue(name, raw, []);
+}
+function resolveConfigEnvValue(name, value, pathSegments) {
+  if (typeof value === "string") {
+    if (!value.includes("$") || shouldDeferEnvResolution(pathSegments)) {
+      return value;
+    }
+    try {
+      return resolveEnvPlaceholders(value);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const field = pathSegments.join(".") || "<root>";
+      throw new Error(`Server '${name}' field '${field}' has unresolved env placeholder: ${message}`, { cause: error });
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => resolveConfigEnvValue(name, entry, [...pathSegments, String(index)]));
+  }
+  if (value && typeof value === "object") {
+    const resolved = {};
+    for (const [key, entry] of Object.entries(value)) {
+      resolved[key] = resolveConfigEnvValue(name, entry, [...pathSegments, key]);
+    }
+    return resolved;
+  }
+  return value;
+}
+function shouldDeferEnvResolution(pathSegments) {
+  const [root] = pathSegments;
+  const field = pathSegments.at(-1) ?? "";
+  return root === "headers" || root === "env" || field === "bearerToken" || field === "bearer_token" || field.endsWith("Env") || field.endsWith("_env");
+}
+function normalizeAuth(auth) {
+  if (!auth) {
+    return void 0;
+  }
+  if (auth.toLowerCase() === "oauth") {
+    return "oauth";
+  }
+  if (auth.toLowerCase() === "refreshable_bearer") {
+    return "refreshable_bearer";
+  }
+  return void 0;
+}
+function normalizeRefresh(raw) {
+  const tokenEndpoint = raw?.tokenEndpoint ?? raw?.token_endpoint;
+  if (!tokenEndpoint) {
+    return void 0;
+  }
+  return {
+    tokenEndpoint,
+    clientIdEnv: raw?.clientIdEnv ?? raw?.client_id_env,
+    clientSecretEnv: raw?.clientSecretEnv ?? raw?.client_secret_env,
+    clientAuthMethod: raw?.clientAuthMethod ?? raw?.client_auth_method,
+    refreshSkewSeconds: raw?.refreshSkewSeconds ?? raw?.refresh_skew_seconds,
+    accessTokenEnv: raw?.accessTokenEnv ?? raw?.access_token_env
+  };
+}
+function normalizeHttpFetch(value) {
+  return value;
+}
+function normalizePath(input) {
+  if (!input) {
+    return void 0;
+  }
+  return expandHome(input);
+}
+function resolveCwd(input, baseDir) {
+  if (!input) {
+    return baseDir;
+  }
+  return path5.resolve(baseDir, expandHome(input));
+}
+function getUrl(raw) {
+  return raw.baseUrl ?? raw.base_url ?? raw.url ?? raw.serverUrl ?? raw.server_url ?? void 0;
+}
+function getCommand(raw, baseDir) {
+  const commandValue = raw.command ?? raw.executable;
+  if (Array.isArray(commandValue)) {
+    if (commandValue.length === 0 || typeof commandValue[0] !== "string") {
+      return void 0;
+    }
+    return { command: commandValue[0], args: commandValue.slice(1) };
+  }
+  if (typeof commandValue === "string" && commandValue.length > 0) {
+    const args = Array.isArray(raw.args) ? raw.args : [];
+    if (args.length > 0) {
+      return { command: commandValue, args };
+    }
+    if (isExistingCommandPath(commandValue, baseDir)) {
+      return { command: commandValue, args: [] };
+    }
+    const tokens = parseCommandString(commandValue);
+    if (tokens.length === 0) {
+      return void 0;
+    }
+    const [commandToken, ...rest] = tokens;
+    if (!commandToken) {
+      return void 0;
+    }
+    return { command: commandToken, args: rest };
+  }
+  return void 0;
+}
+function isExistingCommandPath(value, baseDir) {
+  const trimmed = value.trim();
+  if (!trimmed.includes(" ")) {
+    return false;
+  }
+  if (!looksLikePath(trimmed)) {
+    return false;
+  }
+  const expanded = expandHome(trimmed);
+  const resolved = path5.isAbsolute(expanded) ? expanded : path5.resolve(baseDir, expanded);
+  try {
+    return fs4.statSync(resolved).isFile();
+  } catch {
+    return false;
+  }
+}
+function looksLikePath(value) {
+  return /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("/") || value.startsWith("./") || value.startsWith("../") || value.startsWith("~/");
+}
+function buildHeaders(raw) {
+  const headers = {};
+  if (raw.headers) {
+    Object.assign(headers, raw.headers);
+  }
+  const bearerToken = raw.bearerToken ?? raw.bearer_token;
+  if (bearerToken) {
+    headers.Authorization = `Bearer ${bearerToken}`;
+  }
+  const bearerTokenEnv = raw.bearerTokenEnv ?? raw.bearer_token_env;
+  if (bearerTokenEnv) {
+    headers.Authorization = `$env:${bearerTokenEnv}`;
+  }
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+function ensureHttpAcceptHeader(headers) {
+  const requiredAccept = "application/json, text/event-stream";
+  const normalized = headers ? { ...headers } : {};
+  const acceptKey = Object.keys(normalized).find((key) => key.toLowerCase() === "accept");
+  const currentValue = acceptKey ? normalized[acceptKey] : void 0;
+  if (!currentValue || !hasRequiredAcceptTokens(currentValue)) {
+    normalized[acceptKey ?? "accept"] = requiredAccept;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function hasRequiredAcceptTokens(value) {
+  const lower = value.toLowerCase();
+  return lower.includes("application/json") && lower.includes("text/event-stream");
+}
+function parseCommandString(value) {
+  const result = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escapeNext = false;
+  for (const char of value.trim()) {
+    if (escapeNext) {
+      current += char;
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (char === " " && !inSingleQuote && !inDoubleQuote) {
+      if (current.length > 0) {
+        result.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (escapeNext) {
+    current += "\\";
+  }
+  if (current.length > 0) {
+    result.push(current);
+  }
+  return result;
+}
+function normalizeLogging(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  if (raw.daemon) {
+    const logging = { daemon: { enabled: raw.daemon.enabled } };
+    return logging;
+  }
+  return void 0;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/config.js
+async function loadServerDefinitions(options = {}) {
+  const rootDir = options.rootDir ?? process.cwd();
+  const layers = await loadConfigLayers(options, rootDir);
+  const merged = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    const configuredImports = layer.config.imports;
+    const imports = configuredImports ? configuredImports.length === 0 ? configuredImports : [...configuredImports, ...DEFAULT_IMPORTS.filter((kind) => !configuredImports.includes(kind))] : DEFAULT_IMPORTS;
+    for (const importKind of imports) {
+      const candidates = pathsForImport(importKind, rootDir);
+      for (const candidate of candidates) {
+        const resolved = expandHome(candidate);
+        const entries = await readExternalEntries(resolved, { projectRoot: rootDir, importKind });
+        if (!entries) {
+          continue;
+        }
+        for (const [name, rawEntry] of entries) {
+          const source = { kind: "import", path: resolved, importKind };
+          const baseDir = path6.dirname(resolved);
+          try {
+            normalizeServerEntry(name, rawEntry, baseDir, source, [source]);
+          } catch {
+            continue;
+          }
+          if (merged.has(name)) {
+            continue;
+          }
+          const existing = merged.get(name);
+          if (existing) {
+            existing.sources.push(source);
+            continue;
+          }
+          merged.set(name, {
+            raw: rawEntry,
+            baseDir,
+            source,
+            sources: [source]
+          });
+        }
+      }
+    }
+    for (const [name, entryRaw] of Object.entries(layer.config.mcpServers)) {
+      const source = { kind: "local", path: layer.path };
+      const parsed = RawEntrySchema.parse(entryRaw);
+      const existing = merged.get(name);
+      if (existing) {
+        const sources = [source, ...existing.sources];
+        merged.set(name, { raw: parsed, baseDir: path6.dirname(layer.path), source, sources });
+        continue;
+      }
+      merged.set(name, {
+        raw: parsed,
+        baseDir: path6.dirname(layer.path),
+        source,
+        sources: [source]
+      });
+    }
+  }
+  const servers = [];
+  for (const [name, { raw, baseDir: entryBaseDir, source, sources }] of merged) {
+    try {
+      servers.push(normalizeServerEntry(name, raw, entryBaseDir, source, sources));
+    } catch (error) {
+      if (source.kind !== "import") {
+        throw error;
+      }
+    }
+  }
+  return servers;
+}
+async function loadDaemonConfig(options = {}) {
+  const rootDir = options.rootDir ?? process.cwd();
+  const layers = await loadConfigLayers(options, rootDir);
+  let idleTimeoutMs;
+  for (const layer of layers) {
+    const raw = layer.config.daemonIdleTimeoutMs ?? layer.config.daemon_idle_timeout_ms;
+    if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
+      idleTimeoutMs = Math.trunc(raw);
+    }
+  }
+  return { idleTimeoutMs };
+}
+async function loadRawConfig(options = {}) {
+  const rootDir = options.rootDir ?? process.cwd();
+  const resolved = resolveConfigPath2(options.configPath, rootDir);
+  const config = await readConfigFile(resolved.path, resolved.explicit);
+  return { config, ...resolved };
+}
+async function listConfigLayerPaths2(options = {}, rootDir = process.cwd()) {
+  return await listConfigLayerPaths(options, rootDir);
+}
+async function writeRawConfig(targetPath, config) {
+  const serialized = `${JSON.stringify(config, null, 2)}
+`;
+  await writeTextFileAtomic(targetPath, serialized);
+}
+function resolveConfigPath2(configPath, rootDir) {
+  return resolveConfigPath(configPath, rootDir);
+}
+
+export {
+  readExternalEntries,
+  pathsForImport,
+  __configInternals,
+  loadServerDefinitions,
+  loadDaemonConfig,
+  loadRawConfig,
+  listConfigLayerPaths2 as listConfigLayerPaths,
+  writeRawConfig,
+  resolveConfigPath2 as resolveConfigPath
+};