deepseek-web-retrieval 0.2.0 → 0.3.0

package/dist/cli.js

@@ -1,17 +1,3998 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core/constants.ts
+var SEARCH_ENDPOINT = "https://api.deepseek.com/v1/tools/search", FETCH_ENDPOINT = "https://api.deepseek.com/v1/tools/fetch", DEFAULT_SEARCH_COUNT = 10, DEFAULT_MAX_RESULTS = 5, DEFAULT_MIN_RERANK = 1.5, DEFAULT_MIN_AUTHORITY = 2, DEFAULT_MAX_SUMMARY_CHARS = 1200, DEFAULT_FETCH_MAX_CHARS = 16000, DEFAULT_TIMEOUT_MS = 30000, MIN_TIMEOUT_MS = 1000, MAX_TIMEOUT_MS = 120000, MAX_QUERY_CHARS = 128, MAX_URL_CHARS = 8192, MAX_ERROR_BODY_CHARS = 2000, MAX_RESPONSE_BYTES, FETCH_TRUNCATION_MARKER = `
+
+[content truncated]`, DEFAULT_API_KEY_SOURCE = "auto", DEFAULT_MAX_RETRIES = 0, MAX_RETRIES = 5, DEFAULT_RETRY_BASE_DELAY_MS = 250, MAX_RETRY_DELAY_MS = 1e4, API_KEY_ENV = "DEEPSEEK_API_KEY", ENABLE_SEARCH_ENV = "DEEPSEEK_ENABLE_SEARCH", ENABLE_FETCH_ENV = "DEEPSEEK_ENABLE_FETCH";
+var init_constants = __esm(() => {
+  MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+});
+
+// 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 && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(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 && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(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 += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            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 += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      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;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      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;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      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;
+      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 isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+var init_scanner = __esm(() => {
+  (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/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces, maxCachedValues = 200, cachedBreakLinesWithSpaces, supportedEols;
+var init_string_intern = __esm(() => {
+  cachedSpaces = new Array(20).fill(0).map((_, index) => {
+    return " ".repeat(index);
+  });
+  cachedBreakLinesWithSpaces = {
+    " ": {
+      "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+        return `
+` + " ".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
+` + " ".repeat(index);
+      })
+    },
+    "\t": {
+      "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+        return `
+` + "\t".repeat(index);
+      }),
+      "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+        return "\r" + "\t".repeat(index);
+      }),
+      "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+        return `\r
+` + "\t".repeat(index);
+      })
+    }
+  };
+  supportedEols = [`
+`, "\r", `\r
+`];
+});
+
+// node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) {
+    indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+  } else {
+    indentValue = "\t";
+  }
+  const indentType = indentValue === "\t" ? "\t" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+    }
+  }
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0;i < count; i++) {
+    result += s;
+  }
+  return result;
+}
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "\t") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+  for (let i = 0;i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === `
+`) {
+        return `\r
+`;
+      }
+      return "\r";
+    } else if (ch === `
+`) {
+      return `
+`;
+    }
+  }
+  return options && options.eol || `
+`;
+}
+function isEOL(text, offset) {
+  return `\r
+`.indexOf(text.charAt(offset)) !== -1;
+}
+var init_format = __esm(() => {
+  init_scanner();
+  init_string_intern();
+});
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+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 object2 = {};
+      onValue(object2);
+      previousParents.push(currentParent);
+      currentParent = object2;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array2 = [];
+      onValue(array2);
+      previousParents.push(currentParent);
+      currentParent = array2;
+      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 parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: undefined };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path) {
+  if (!root) {
+    return;
+  }
+  let node = root;
+  for (let segment of path) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+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);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          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);
+          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]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _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]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } 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]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } 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;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+var ParseOptions;
+var init_parser = __esm(() => {
+  init_scanner();
+  (function(ParseOptions2) {
+    ParseOptions2.DEFAULT = {
+      allowTrailingComma: false
+    };
+  })(ParseOptions || (ParseOptions = {}));
+});
+
+// node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+  const path = originalPath.slice();
+  const errors = [];
+  const root = parseTree(text, errors);
+  let parent = undefined;
+  let lastSegment = undefined;
+  while (path.length > 0) {
+    lastSegment = path.pop();
+    parent = findNodeAtLocation(root, path);
+    if (parent === undefined && value !== undefined) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === undefined) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== undefined) {
+      if (value === undefined) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+      }
+    } else {
+      if (value === undefined) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === undefined && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== undefined) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1;i >= 0; i--) {
+    const edit2 = edits[i];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+var init_edit = __esm(() => {
+  init_format();
+  init_parser();
+});
+
+// node_modules/jsonc-parser/lib/esm/main.js
+function modify(text, path, value, options) {
+  return setProperty(text, path, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1;i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
+var ScanError, SyntaxKind, parse2, ParseErrorCode;
+var init_main = __esm(() => {
+  init_format();
+  init_edit();
+  init_scanner();
+  init_parser();
+  (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 = {}));
+  (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 = {}));
+  parse2 = parse;
+  (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 = {}));
+});
+
+// src/core/jsonc.ts
+function parseJsonc(text) {
+  const errors = [];
+  const value = parse2(text, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    const first = errors[0];
+    throw new SyntaxError(`JSONC parse error at offset ${first.offset} (code ${first.error})`);
+  }
+  return value;
+}
+var init_jsonc = __esm(() => {
+  init_main();
+});
+
+// src/installer/formats/value.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object")
+    return false;
+  const aArray = Array.isArray(a);
+  const bArray = Array.isArray(b);
+  if (aArray !== bArray)
+    return false;
+  if (aArray && bArray) {
+    const x2 = a;
+    const y2 = b;
+    return x2.length === y2.length && x2.every((item, index) => deepEqual(item, y2[index]));
+  }
+  const x = a;
+  const y = b;
+  const xKeys = Object.keys(x);
+  const yKeys = Object.keys(y);
+  return xKeys.length === yKeys.length && xKeys.every((key) => deepEqual(x[key], y[key]));
+}
+function valueAt(value, path) {
+  let node = value;
+  for (const key of path) {
+    if (Array.isArray(node)) {
+      const index = Number(key);
+      node = Number.isInteger(index) ? node[index] : undefined;
+    } else if (isPlainObject(node)) {
+      node = node[key];
+    } else {
+      return;
+    }
+    if (node === undefined)
+      return;
+  }
+  return node;
+}
+function removeAt(value, path) {
+  const parent = valueAt(value, path.slice(0, -1));
+  if (isPlainObject(parent))
+    delete parent[path[path.length - 1]];
+}
+function appendEntries(existing, entries, path) {
+  if (existing !== undefined && !Array.isArray(existing)) {
+    throw new Error(`cannot append to ${path.join(".")}: it is a ${typeof existing}, not an array`);
+  }
+  const list = Array.isArray(existing) ? existing : [];
+  const appended = entries.filter((entry) => !list.some((item) => deepEqual(item, entry)));
+  return { list, appended };
+}
+
+// src/installer/formats/json.ts
+import { existsSync, readFileSync } from "node:fs";
+function loadJson(file) {
+  if (!existsSync(file))
+    return { exists: false, text: "", value: {}, lossy: false };
+  const text = readFileSync(file, "utf8");
+  try {
+    return { exists: true, text, value: parseJsonc(text), lossy: false };
+  } catch (error) {
+    const parseError = error instanceof Error ? error.message : String(error);
+    return { exists: true, text, value: {}, lossy: false, parseError };
+  }
+}
+function jsonGet(text, path) {
+  const root = parse2(text, undefined, { allowTrailingComma: true });
+  return valueAt(root, path);
+}
+function applyJsonOps(text, ops) {
+  let current = text.trim().length > 0 ? text : `{}
+`;
+  const recorded = [];
+  const createdParents = [];
+  for (const op of ops) {
+    const path = op.path;
+    if (op.op === "set") {
+      current = ensureParents(current, op.path, createdParents);
+      const previous = jsonGet(current, op.path);
+      current = edit(current, path, op.value);
+      recorded.push({ op: "set", path: op.path, applied: structuredClone(op.value), previous });
+      continue;
+    }
+    current = ensureParents(current, op.path, createdParents);
+    const existing = jsonGet(current, op.path);
+    const { list, appended } = appendEntries(existing, op.entries ?? [], op.path);
+    if (existing === undefined) {
+      current = edit(current, path, []);
+      createdParents.push(op.path);
+    }
+    let index = list.length;
+    for (const entry of appended) {
+      current = edit(current, [...path, index], entry);
+      index += 1;
+    }
+    recorded.push({ op: "append-array", path: op.path, applied: appended, previous: undefined });
+  }
+  return { text: current, recorded, createdParents };
+}
+function revertJsonOps(text, ops, createdParents) {
+  let current = text;
+  const notes = [];
+  for (const record of [...ops].reverse()) {
+    const path = record.path;
+    if (record.op === "set") {
+      const now = jsonGet(current, record.path);
+      if (now === undefined)
+        continue;
+      if (!deepEqual(now, record.applied)) {
+        notes.push(`${record.path.join(".")}: current value differs from what the installer wrote; left untouched`);
+        continue;
+      }
+      current = record.previous === undefined ? edit(current, path, undefined) : edit(current, path, record.previous);
+    } else {
+      const entries = Array.isArray(record.applied) ? record.applied : [];
+      for (const entry of [...entries].reverse()) {
+        const list = jsonGet(current, record.path);
+        if (!Array.isArray(list))
+          continue;
+        const index = list.findIndex((item) => deepEqual(item, entry));
+        if (index === -1)
+          continue;
+        current = edit(current, [...path, index], undefined);
+      }
+    }
+  }
+  for (const parent of [...createdParents].reverse()) {
+    const value = jsonGet(current, parent);
+    const isEmptyObject = isPlainObject(value) && Object.keys(value).length === 0;
+    const isEmptyArray = Array.isArray(value) && value.length === 0;
+    if (isEmptyObject || isEmptyArray) {
+      current = edit(current, parent, undefined);
+    }
+  }
+  return { text: current, notes };
+}
+function edit(text, path, value) {
+  return applyEdits(text, modify(text, path, value, { formattingOptions: JSON_FORMATTING }));
+}
+function ensureParents(text, path, created) {
+  let current = text;
+  for (let depth = 0;depth < path.length - 1; depth += 1) {
+    const prefix = path.slice(0, depth + 1);
+    const existing = jsonGet(current, prefix);
+    if (existing !== undefined && typeof existing !== "object") {
+      throw new Error(`cannot descend into ${prefix.join(".")}: it is a ${typeof existing}, not an object`);
+    }
+    if (existing !== undefined)
+      continue;
+    const nextSegmentIsIndex = Number.isInteger(Number(path[depth + 1]));
+    const placeholder = nextSegmentIsIndex ? [] : {};
+    current = edit(current, prefix, placeholder);
+    created.push(prefix);
+  }
+  return current;
+}
+function jsonOpHolds(text, op) {
+  if (op.op === "set")
+    return deepEqual(jsonGet(text, op.path), op.value);
+  const list = jsonGet(text, op.path);
+  return Array.isArray(list) && (op.entries ?? []).every((entry) => list.some((item) => deepEqual(item, entry)));
+}
+var JSON_FORMATTING, jsonCodec;
+var init_json = __esm(() => {
+  init_main();
+  init_jsonc();
+  JSON_FORMATTING = { insertSpaces: true, tabSize: 2, insertFinalNewline: false };
+  jsonCodec = {
+    format: "json",
+    load: loadJson,
+    apply: (text, edit2) => {
+      if (edit2.format !== "json")
+        throw new Error(`json codec cannot apply a ${edit2.format} edit`);
+      const result = applyJsonOps(text, edit2.ops);
+      return { text: result.text, recorded: result.recorded, createdParents: result.createdParents };
+    },
+    verify: (text, edit2, op) => {
+      if (edit2.format !== "json")
+        throw new Error(`json codec cannot verify a ${edit2.format} edit`);
+      const ops = op === undefined ? edit2.ops : [op];
+      return ops.every((candidate) => jsonOpHolds(text, candidate));
+    },
+    revert: (text, recorded) => revertJsonOps(text, recorded.ops, recorded.createdParents ?? []),
+    isEffectivelyEmpty: (text) => text.replace(/[{}\s]/g, "").length === 0
+  };
+});
+
+// src/installer/formats/rules.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+function rulesMarkers(host) {
+  return {
+    begin: `<!-- deepseek-web-retrieval:${host}:rules:begin -->`,
+    end: `<!-- deepseek-web-retrieval:${host}:rules:end -->`
+  };
+}
+function buildRulesBlock(host, lines) {
+  const markers = rulesMarkers(host);
+  return [markers.begin, ...lines, markers.end].join(`
+`);
+}
+function upsertBlock(host, text, block) {
+  const without = removeBlock(host, text);
+  const trimmed = without.trimEnd();
+  return trimmed ? `${trimmed}
+
+${block}
+` : `${block}
+`;
+}
+function removeBlock(host, text) {
+  const markers = rulesMarkers(host);
+  const start = text.indexOf(markers.begin);
+  if (start === -1)
+    return text;
+  const end = text.indexOf(markers.end);
+  if (end === -1)
+    return text.slice(0, start);
+  let after = text.slice(end + markers.end.length);
+  after = after.replace(/^\n{1,2}/, "");
+  const before = text.slice(0, start);
+  return before.endsWith(`
+
+`) ? `${before.slice(0, -1)}${after}` : before + after;
+}
+function hasBlock(host, text) {
+  const markers = rulesMarkers(host);
+  return text.includes(markers.begin) && text.includes(markers.end);
+}
+function rulesCodec(host) {
+  return {
+    format: "rules",
+    load: (file) => existsSync2(file) ? { exists: true, text: readFileSync2(file, "utf8"), value: {}, lossy: false } : { exists: false, text: "", value: {}, lossy: false },
+    apply: (text, edit2) => {
+      if (edit2.format !== "rules")
+        throw new Error(`rules codec cannot apply a ${edit2.format} edit`);
+      return { text: upsertBlock(host, text, edit2.block), recorded: [], createdParents: [] };
+    },
+    verify: (text) => hasBlock(host, text),
+    revert: (text) => ({ text: removeBlock(host, text), notes: [] }),
+    isEffectivelyEmpty: (text) => text.trim().length === 0
+  };
+}
+var init_rules = () => {};
+
+// node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string2, ptr) {
+  let lines = string2.slice(0, ptr).split(/\r?\n/);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string2, line, column) {
+  let lines = string2.split(/\r?\n/);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1;i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += `
+`;
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += `^
+`;
+    }
+  }
+  return codeblock;
+}
+var TomlError;
+var init_error = __esm(() => {
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  TomlError = class TomlError extends Error {
+    line;
+    column;
+    codeblock;
+    constructor(message, options) {
+      const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+      const codeblock = makeCodeBlock(options.toml, line, column);
+      super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+      this.line = line;
+      this.column = column;
+      this.codeblock = codeblock;
+    }
+    static x(message, ctx, ptr) {
+      throw new TomlError(message, { toml: ctx.s, ptr: ptr ?? ctx.p });
+    }
+  };
+});
+
+// node_modules/smol-toml/dist/primitive.js
+function parseString(ctx) {
+  let startPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
+  let first = c;
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+  if (isMultiline) {
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
+  }
+  let parsed = "";
+  let sliceStart = ctx.p;
+  let state = 0;
+  for (;ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
+      state = state && 3;
+    } else if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in strings", ctx);
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+      if (isMultiline) {
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+      }
+      if (!state) {
+        let s = ctx.s.slice(sliceStart, ctx.p);
+        parsed = parsed ? parsed + s : s;
+      }
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
+    } else if (!state) {
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === 120 || c === 117 || c === 85) {
+        let errPtr = ctx.p++ - 1;
+        let value = 0;
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0;j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p);
+          let digit = hex >= 48 && hex <= 57 ? hex - 48 : hex >= 65 && hex <= 70 ? hex - 65 + 10 : hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1;
+          if (digit < 0)
+            TomlError.x("invalid non-hex character in unicode escape", ctx);
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          TomlError.x("invalid unicode escape", ctx, errPtr);
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = ctx.p--;
+        state = 0;
+      } else if (isMultiline && (c === 32 || c === 9)) {
+        state = 2;
+      } else {
+        if (c === 98)
+          parsed += "\b";
+        else if (c === 116)
+          parsed += "\t";
+        else if (c === 110)
+          parsed += `
+`;
+        else if (c === 102)
+          parsed += "\f";
+        else if (c === 114)
+          parsed += "\r";
+        else if (c === 101)
+          parsed += "\x1B";
+        else if (c === 34)
+          parsed += '"';
+        else if (c === 92)
+          parsed += "\\";
+        else
+          TomlError.x("unrecognised escape sequence", ctx);
+        sliceStart = ctx.p + 1;
+        state = 0;
+      }
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2)
+        TomlError.x("invalid escape: only line-ending whitespace may be escaped", ctx, sliceStart);
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
+    }
+  }
+  TomlError.x("unfinished string", ctx, startPtr);
+}
+var init_primitive = __esm(() => {
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE, TomlDate;
+var init_date = __esm(() => {
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
+  TomlDate = class TomlDate extends Date {
+    #hasDate = false;
+    #hasTime = false;
+    #offset = null;
+    constructor(date, fasttype, unsafeDelim) {
+      let hasDate = true;
+      let hasTime = true;
+      let offset = "Z";
+      let c;
+      if (typeof date === "string") {
+        if (fasttype)
+          prep: {
+            if (fasttype < 3) {
+              if (+date.slice(11, 13) > 23) {
+                date = "";
+                break prep;
+              }
+              if (fasttype === 2) {
+                offset = null;
+                date += "Z";
+              } else if ((c = date.charCodeAt(date.length - 1)) !== 90 && c !== 122) {
+                offset = date.slice(date.length - 6);
+              }
+              if (unsafeDelim)
+                date = date.slice(0, 10) + "T" + date.slice(11);
+            } else if (fasttype === 4) {
+              date = +date.slice(0, 2) > 23 ? "" : `0000-01-01T${date}Z`;
+            }
+            hasDate = fasttype !== 4;
+            hasTime = fasttype !== 3;
+          }
+        else {
+          let match = date.match(DATE_TIME_RE);
+          if (match) {
+            if (!match[1]) {
+              hasDate = false;
+              date = `0000-01-01T${date}`;
+            }
+            hasTime = !!match[2];
+            hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+            if (match[2] && +match[2] > 23) {
+              date = "";
+            } else {
+              offset = match[3] || null;
+              if (!offset && hasTime)
+                date += "Z";
+            }
+          } else {
+            date = "";
+          }
+        }
+      }
+      super(date);
+      if (!isNaN(this.getTime())) {
+        this.#hasDate = hasDate;
+        this.#hasTime = hasTime;
+        this.#offset = offset;
+      }
+    }
+    isDateTime() {
+      return this.#hasDate && this.#hasTime;
+    }
+    isLocal() {
+      return !this.#hasDate || !this.#hasTime || !this.#offset;
+    }
+    isDate() {
+      return this.#hasDate && !this.#hasTime;
+    }
+    isTime() {
+      return this.#hasTime && !this.#hasDate;
+    }
+    isValid() {
+      return this.#hasDate || this.#hasTime;
+    }
+    toISOString() {
+      let iso = super.toISOString();
+      if (this.isDate())
+        return iso.slice(0, 10);
+      if (this.isTime())
+        return iso.slice(11, 23);
+      if (this.#offset === null)
+        return iso.slice(0, -1);
+      if (this.#offset === "Z" || this.#offset === "z")
+        return iso;
+      let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+      offset = this.#offset[0] === "-" ? offset : -offset;
+      let offsetDate = new Date(this.getTime() - offset * 60000);
+      return offsetDate.toISOString().slice(0, -1) + this.#offset;
+    }
+    static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+      let date = new TomlDate(jsDate);
+      date.#offset = offset;
+      return date;
+    }
+    static wrapAsLocalDateTime(jsDate) {
+      let date = new TomlDate(jsDate);
+      date.#offset = null;
+      return date;
+    }
+    static wrapAsLocalDate(jsDate) {
+      let date = new TomlDate(jsDate);
+      date.#hasTime = false;
+      date.#offset = null;
+      return date;
+    }
+    static wrapAsLocalTime(jsDate) {
+      let date = new TomlDate(jsDate);
+      date.#hasDate = false;
+      date.#offset = null;
+      return date;
+    }
+  };
+});
+
+// node_modules/smol-toml/dist/extract.js
+function isDigit2(char, base = 10) {
+  return base === 16 ? char > 47 && char < 58 || char > 64 && char < 71 || char > 96 && char < 103 : char > 47 && char < 48 + base;
+}
+function isEndOfValue(char, delim) {
+  return char === 32 || char === 9 || char === 10 || char === 13 || delim && (char === delim || char === 44) || char === 35;
+}
+function extractValue(ctx, end) {
+  let errPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p);
+  if (c === 91 || c === 123) {
+    ctx.d-- || TomlError.x("document contains excessively nested structures. aborting.", ctx);
+    let value = c === 91 ? parseArray(ctx) : parseInlineTable(ctx);
+    ctx.d++;
+    return value;
+  }
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, false;
+  }
+  if (c === 43 || c === 45) {
+    return parseNumber(ctx, ctx.p, ctx.s.charCodeAt(++ctx.p), 44 - c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 4) === 45 && ctx.s.charCodeAt(ctx.p + 7) === 45) {
+    return parseDate(ctx, c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 2) === 58) {
+    return parseTime(ctx, c, end);
+  }
+  return parseNumber(ctx, ctx.p, c, 0, end);
+}
+function parseNumber(ctx, startPtr, startChr, sign, endChr) {
+  let c = startChr;
+  let state = 0;
+  let hasUnderscores = false;
+  if (c === 105) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 110 || ctx.s.charCodeAt(++ctx.p) !== 102)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, (sign || 1) / 0;
+  }
+  if (c === 110) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 110)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, NaN;
+  }
+  if (c === 48) {
+    if (++ctx.p >= ctx.s.length || isEndOfValue(c = ctx.s.charCodeAt(ctx.p), endChr))
+      return ctx.bi === true ? 0n : 0;
+    if (!sign) {
+      if (c === 120)
+        return parseIntegerBaseN(ctx, startPtr, 16, endChr);
+      else if (c === 98)
+        return parseIntegerBaseN(ctx, startPtr, 2, endChr);
+      else if (c === 111)
+        return parseIntegerBaseN(ctx, startPtr, 8, endChr);
+    }
+    if (c === 46)
+      state = 2;
+    else if (c === 101 || c === 69)
+      state = 4;
+    else
+      TomlError.x("illegal leading zero", ctx, startPtr);
+  } else if (!isDigit2(c))
+    TomlError.x("invalid value", ctx, startPtr);
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (!state)
+      state = 1;
+    if (c === 95) {
+      if (!(state & 1))
+        TomlError.x("illegal underscore", ctx);
+      state += 11;
+      hasUnderscores = true;
+    } else if (state === 1 && c === 46)
+      state = 2;
+    else if ((state === 1 || state === 3) && (c === 101 || c === 69))
+      state = 4;
+    else if (state === 4 && (c === 43 || c === 45)) {
+      state = 6;
+    } else if (!isDigit2(c))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (state > 9)
+      state -= 11;
+    else if (!(state & 1))
+      state++;
+  }
+  if (!state) {
+    let val = (startChr - 48) * (sign || 1);
+    return ctx.bi === true ? BigInt(val) : val;
+  }
+  if (!(state & 1))
+    TomlError.x("unfinished numeric value", ctx, startPtr);
+  let str = ctx.s.slice(startPtr, ctx.p);
+  if (hasUnderscores)
+    str = str.replaceAll("_", "");
+  return state > 1 ? parseFloat(str) : parseInteger(ctx, str, 10, startPtr);
+}
+function parseIntegerBaseN(ctx, startPtr, base, endChr) {
+  let c, underscore = 1;
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (c === 95) {
+      if (underscore & 1)
+        TomlError.x("illegal underscore", ctx);
+      underscore = 3;
+    } else if (!isDigit2(c, base))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (underscore & 1)
+      underscore--;
+  }
+  if (underscore & 1)
+    TomlError.x("unfinished numeric value", ctx);
+  let str = ctx.s.slice(startPtr + 2, ctx.p);
+  if (underscore)
+    str = str.replaceAll("_", "");
+  return parseInteger(ctx, str, base, startPtr);
+}
+function parseInteger(ctx, str, base, startPtr) {
+  if (ctx.bi !== true)
+    int: {
+      let val = parseInt(str, base);
+      if (!Number.isSafeInteger(val)) {
+        if (ctx.bi)
+          break int;
+        TomlError.x("integer value cannot be represented losslessly", ctx, startPtr);
+      }
+      return val;
+    }
+  return base === 10 ? BigInt(str) : BigInt((base === 2 ? "0b" : base === 8 ? "0o" : "0x") + str);
+}
+function parseDate(ctx, c, endChr) {
+  let startPtr = ctx.p++, unsafeSeparator;
+  if (!isDigit2(c) || !isDigit2(ctx.s.charCodeAt(ctx.p++)) || !isDigit2(ctx.s.charCodeAt(ctx.p++)) || !isDigit2(ctx.s.charCodeAt(ctx.p++))) {
+    return parseNumber(ctx, ctx.p = startPtr, c, 0, endChr);
+  }
+  ctx.p += 5;
+  if (!isDigit2(ctx.s.charCodeAt(ctx.p++)))
+    TomlError.x("invalid date-time: date part is malformed", ctx, startPtr);
+  if (ctx.p >= ctx.s.length || ((c = ctx.s.charCodeAt(ctx.p)) !== 32 || (unsafeSeparator = true, !isDigit2(ctx.s.charCodeAt(ctx.p + 1)))) && c !== 84 && c !== 116) {
+    let t2 = ctx.s.slice(startPtr, ctx.p);
+    return readDate(ctx, t2, 3, false, startPtr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 3) !== 58)
+    TomlError.x("invalid date-time: time part is malformed", ctx, startPtr);
+  if (ctx.s.charCodeAt(ctx.p += 3) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit2(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  if (c = ctx.s.charCodeAt(ctx.p)) {
+    if (c === 90 || c === 122) {
+      let t2 = ctx.s.slice(startPtr, ++ctx.p);
+      return readDate(ctx, t2, 1, unsafeSeparator, startPtr, "[+00:00]");
+    }
+    if (c === 43 || c === 45) {
+      let t2 = ctx.s.slice(startPtr, ctx.p += 6);
+      return readDate(ctx, t2, 1, unsafeSeparator, startPtr, !ctx.ld && "[" + ctx.s.slice(ctx.p - 6, ctx.p) + "]");
+    }
+  }
+  let t = ctx.s.slice(startPtr, ctx.p);
+  return readDate(ctx, t, 2, unsafeSeparator, startPtr);
+}
+function parseTime(ctx, c, endChr) {
+  let start = ctx.p;
+  if (!isDigit2(c) || !isDigit2(ctx.s.charCodeAt(++ctx.p))) {
+    return parseNumber(ctx, --ctx.p, c, 0, endChr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 4) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit2(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  let t = ctx.s.slice(start, ctx.p);
+  return readDate(ctx, t, 4, false, start);
+}
+function readDate(ctx, str, type, unsafeDelim, errPtr, temporalSuffix) {
+  if (ctx.ld) {
+    let date = new TomlDate(str, type, unsafeDelim);
+    if (!date.isValid())
+      TomlError.x("invalid date", ctx, errPtr);
+    return date;
+  }
+  try {
+    if (temporalSuffix)
+      str += temporalSuffix;
+    switch (type) {
+      case 1:
+        return Temporal.ZonedDateTime.from(str);
+      case 2:
+        return Temporal.PlainDateTime.from(str);
+      case 3:
+        return Temporal.PlainDate.from(str);
+      case 4:
+        return Temporal.PlainTime.from(str);
+    }
+  } catch (e) {
+    TomlError.x(e instanceof Error ? e.message : "" + e, ctx, errPtr);
+  }
+}
+var init_extract = __esm(() => {
+  init_primitive();
+  init_struct();
+  init_error();
+  init_date();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// node_modules/smol-toml/dist/util.js
+function skipComment(ctx) {
+  for (;ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in comments", ctx);
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (ctx.p < ctx.s.length) {
+    while (ctx.p < ctx.s.length && ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
+  }
+}
+var init_util = __esm(() => {
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// node_modules/smol-toml/dist/struct.js
+function parseKey(ctx, end = 61) {
+  let startPtr;
+  let state = 0;
+  let parsed = [];
+  let sliceStart;
+  let c = ctx.s.charCodeAt(startPtr = ctx.p);
+  do {
+    if (c === end) {
+      if (!state)
+        TomlError.x("unexpected end of key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      return ctx.p++, parsed;
+    } else if (c === 46) {
+      if (!state)
+        TomlError.x("illegal empty bare key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      state = 0;
+    } else if (!state && (c === 34 || c === 39)) {
+      if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2))
+        TomlError.x("illegal quoted key: multiline strings are not allowed", ctx);
+      parsed.push(parseString(ctx));
+      state = 2;
+      ctx.p--;
+    } else if (c === 32 || c === 9) {
+      if (state === 1) {
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+        state = 2;
+      }
+    } else if (state === 2 || c < 48 && c !== 45 || c > 57 && c < 65 || c > 90 && c < 97 && c !== 95 || c > 122) {
+      TomlError.x("illegal character in key", ctx);
+    } else if (!state) {
+      state = 1;
+      sliceStart = ctx.p;
+    }
+  } while (c = ctx.s.charCodeAt(++ctx.p));
+  TomlError.x("incomplete key-value: cannot find end of key", ctx, startPtr);
+}
+function parseInlineTable(ctx) {
+  let startPtr = ctx.p++;
+  let res = Object.create(null);
+  let seen = new Set;
+  let c;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let errPtr = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0;i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = Object.create(null);
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+        TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+      }
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor")) {
+        t = ctx.uk !== 1 && TomlError.x("document contains an unsafe property", ctx, errPtr);
+        break;
+      }
+      if (!hasOwn && unsafe) {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (hasOwn) {
+      TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+    }
+    skipVoid(ctx, true, true);
+    let value = extractValue(ctx, 125);
+    if (t && typeof (t[k] = value) === "object")
+      seen.add(value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished table", ctx, startPtr);
+}
+function parseArray(ctx) {
+  let startPtr = ctx.p++;
+  let res = [];
+  let c;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(ctx, 93));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished array", ctx, startPtr);
+}
+var init_struct = __esm(() => {
+  init_primitive();
+  init_extract();
+  init_util();
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// node_modules/smol-toml/dist/parse.js
+function peekTable(ctx, key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0;i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = Object.create(null);
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor"))
+        return false;
+      if (unsafe) {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: Object.create(null)
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = Object.create(null));
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: Object.create(null) };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = Object.create(null);
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function validateTablePeek(ctx, peek, ptr) {
+  if (peek === null || ctx.uk === 2)
+    TomlError.x(peek === null ? "trying to redefine an already defined table or value" : "document contains an unsafe property", ctx, ptr);
+}
+function parse3(toml, options = {}) {
+  let ctx = {
+    s: toml,
+    p: 0,
+    d: options.maxDepth ?? 1000,
+    bi: options.integersAsBigInt ?? false,
+    ld: options.useLegacyDate ?? true,
+    uk: options.unsafeKeyBehaviour === "throw" ? 2 : options.unsafeKeyBehaviour === "drop" ? 1 : 0
+  };
+  let res = Object.create(null);
+  let meta = Object.create(null);
+  let tmp;
+  let skipping = false;
+  let tbl = res;
+  let m = meta;
+  if (toml.charCodeAt(0) === 65279)
+    ctx.p++;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      skipping = false;
+      let k = parseKey(ctx, 93);
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p) !== 93) {
+          TomlError.x("expected end of table array declaration", ctx);
+        }
+        ctx.p++;
+      }
+      let p = peekTable(ctx, k, res, meta, isTableArray ? 2 : 1);
+      if (!p) {
+        validateTablePeek(ctx, p, tmp);
+        skipping = true;
+      } else {
+        m = p[2];
+        tbl = p[1];
+      }
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(ctx, k, tbl, m, 0);
+      if (!p && !skipping)
+        validateTablePeek(ctx, p, tmp);
+      skipVoid(ctx, true, true);
+      let v = extractValue(ctx, undefined);
+      if (p && !skipping)
+        p[1][p[0]] = v;
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && (tmp !== 13 || toml.charCodeAt(ctx.p + 1) !== 10)) {
+      TomlError.x("each key-value declaration must be followed by an end-of-line", ctx);
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+var init_parse = __esm(() => {
+  init_struct();
+  init_extract();
+  init_util();
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// node_modules/smol-toml/dist/stringify.js
+function extendedTypeOf(obj) {
+  let type = typeof obj;
+  if (type === "object") {
+    if (Array.isArray(obj))
+      return "array";
+    if (typeof obj.getUTCDate === "function" && obj instanceof Date)
+      return "date";
+    if (globalThis.Temporal) {
+      if (obj.until) {
+        if (obj instanceof Temporal.ZonedDateTime)
+          return "temporal/tz+uc";
+        if (obj instanceof Temporal.PlainDateTime || obj instanceof Temporal.PlainDate)
+          return "temporal/uc";
+        if (obj instanceof Temporal.PlainTime || obj instanceof Temporal.Instant)
+          return "temporal";
+        if (obj instanceof Temporal.PlainYearMonth)
+          return "temporal/x";
+      } else if (obj.toPlainDate && obj instanceof Temporal.PlainMonthDay || obj.negated && obj instanceof Temporal.Duration) {
+        return "temporal/x";
+      }
+    }
+  }
+  return type;
+}
+function isArrayOfTables(obj) {
+  for (let i = 0;i < obj.length; i++) {
+    if (extendedTypeOf(obj[i]) !== "object")
+      return false;
+  }
+  return obj.length != 0;
+}
+function formatWellFormedStringUnchecked(s) {
+  return JSON.stringify(s).replaceAll("", "\\u007f");
+}
+function formatString(s) {
+  return formatWellFormedStringUnchecked(HAS_WELLFORMED ? s.toWellFormed() : s);
+}
+function formatKey(s) {
+  if (BARE_KEY.test(s))
+    return s;
+  if (HAS_WELLFORMED && !s.isWellFormed())
+    throw new RangeError("key contains illegal lone surrogates");
+  return formatWellFormedStringUnchecked(s);
+}
+function stringifyValue(val, type, depth, numberAsFloat, strictTemporal) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  switch (type) {
+    case "number":
+      if (isNaN(val))
+        return "nan";
+      if (val === Infinity)
+        return "inf";
+      if (val === -Infinity)
+        return "-inf";
+      if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val)))
+        return val.toFixed(1);
+    case "bigint":
+    case "boolean":
+    case "temporal":
+      return val.toString();
+    case "string":
+      return formatString(val);
+    case "date":
+      if (isNaN(val.getTime()))
+        throw new TypeError("cannot serialize invalid date");
+      return val.toISOString();
+    case "object":
+      return stringifyInlineTable(val, depth, numberAsFloat, strictTemporal);
+    case "array":
+      return stringifyArray(val, depth, numberAsFloat, strictTemporal);
+    case "temporal/tz+uc":
+      if (strictTemporal) {
+        let tz = val.timeZoneId;
+        let tzc = tz.charCodeAt(0);
+        if (tzc !== 43 && tzc !== 45 && (tzc !== 85 && tzc !== 71 && tzc !== 90 && tzc !== 69 || tz !== "UTC" && tz !== "UCT" && tz !== "Universal" && tz !== "Zulu" && !tz.startsWith("GMT") && tz !== "Greenwich" && !tz.startsWith("Etc/"))) {
+          throw new TypeError("Temporal objects with an IANA timezone are not allowed in Temporal strict mode");
+        }
+      }
+    case "temporal/uc":
+      if (strictTemporal && val.calendarId !== "iso8601")
+        throw new TypeError("Temporal objects with a non-default calendar are not allowed in Temporal strict mode");
+      return val.toString({
+        calendarName: "never",
+        timeZoneName: "never"
+      });
+    case "temporal/x":
+      throw new TypeError("Unsupported " + val[Symbol.toStringTag]);
+  }
+}
+function stringifyInlineTable(obj, depth, numberAsFloat, strictTemporal) {
+  let keys = Object.keys(obj);
+  if (keys.length === 0)
+    return "{}";
+  let res = "{ ";
+  for (let i = 0;i < keys.length; i++) {
+    let k = keys[i];
+    if (i)
+      res += ", ";
+    res += formatKey(k) + " = " + stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat, strictTemporal);
+  }
+  return res + " }";
+}
+function stringifyArray(array2, depth, numberAsFloat, strictTemporal) {
+  if (array2.length === 0)
+    return "[]";
+  let res = "[ ";
+  for (let i = 0;i < array2.length; i++) {
+    if (i)
+      res += ", ";
+    if (array2[i] === null || array2[i] === undefined) {
+      throw new TypeError("arrays cannot contain null or undefined values");
+    }
+    res += stringifyValue(array2[i], extendedTypeOf(array2[i]), depth - 1, numberAsFloat, strictTemporal);
+  }
+  return res + " ]";
+}
+function stringifyArrayTable(array2, key, depth, numberAsFloat, strictTemporal) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let res = "";
+  for (let i = 0;i < array2.length; i++) {
+    res += `${res && `
+`}[[${key}]]
+`;
+    res += stringifyTable(0, array2[i], key, depth, numberAsFloat, strictTemporal);
+  }
+  return res;
+}
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat, strictTemporal) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let preamble = "";
+  let tables = "";
+  let keys = Object.keys(obj);
+  for (let i = 0;i < keys.length; i++) {
+    let k = keys[i];
+    if (obj[k] !== null && obj[k] !== undefined) {
+      let type = extendedTypeOf(obj[k]);
+      if (type === "symbol" || type === "function") {
+        throw new TypeError(`cannot serialize values of type '${type}'`);
+      }
+      let key = formatKey(k);
+      if (type === "array" && isArrayOfTables(obj[k])) {
+        tables += (tables && `
+`) + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat, strictTemporal);
+      } else if (type === "object") {
+        let tblKey = prefix ? `${prefix}.${key}` : key;
+        tables += (tables && `
+`) + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat, strictTemporal);
+      } else {
+        preamble += key;
+        preamble += " = ";
+        preamble += stringifyValue(obj[k], type, depth, numberAsFloat, strictTemporal);
+        preamble += `
+`;
+      }
+    }
+  }
+  if (tableKey && (preamble || !tables))
+    preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+  return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+}
+function stringify(obj, { maxDepth = 1000, numbersAsFloat = false, strictTemporal = false } = {}) {
+  if (extendedTypeOf(obj) !== "object") {
+    throw new TypeError("stringify can only be called with an object");
+  }
+  let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat, strictTemporal);
+  if (str[str.length - 1] !== `
+`)
+    return str + `
+`;
+  return str;
+}
+var BARE_KEY, HAS_WELLFORMED;
+var init_stringify = __esm(() => {
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  BARE_KEY = /^[a-z0-9-_]+$/i;
+  HAS_WELLFORMED = !!"".isWellFormed;
+});
+
+// node_modules/smol-toml/dist/index.js
+var init_dist = __esm(() => {
+  init_parse();
+  init_stringify();
+  init_date();
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// src/installer/formats/toml.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+function loadToml(file) {
+  if (!existsSync3(file))
+    return { exists: false, text: "", value: {}, lossy: false };
+  const text = readFileSync3(file, "utf8");
+  try {
+    return { exists: true, text, value: parse3(text), lossy: hasTomlComment(text) };
+  } catch (error) {
+    const parseError = error instanceof Error ? error.message : String(error);
+    return { exists: true, text, value: {}, lossy: false, parseError };
+  }
+}
+function hasTomlComment(text) {
+  let inBasic = false;
+  let inLiteral = false;
+  for (let i = 0;i < text.length; i += 1) {
+    const ch = text[i];
+    if (inBasic) {
+      if (ch === "\\")
+        i += 1;
+      else if (ch === '"')
+        inBasic = false;
+      continue;
+    }
+    if (inLiteral) {
+      if (ch === "'")
+        inLiteral = false;
+      continue;
+    }
+    if (ch === '"')
+      inBasic = true;
+    else if (ch === "'")
+      inLiteral = true;
+    else if (ch === "#")
+      return true;
+  }
+  return false;
+}
+function serializeToml(value) {
+  return `${stringify(value)}
+`;
+}
+function applyTomlOps(value, ops) {
+  const target = structuredClone(value);
+  const recorded = [];
+  const createdParents = [];
+  for (const op of ops) {
+    const parent = navigate(target, op.path, createdParents);
+    const key = op.path[op.path.length - 1];
+    if (op.op === "set") {
+      const previous = Object.prototype.hasOwnProperty.call(parent, key) ? parent[key] : undefined;
+      parent[key] = structuredClone(op.value);
+      recorded.push({ op: "set", path: op.path, applied: structuredClone(op.value), previous });
+      continue;
+    }
+    const existing = parent[key];
+    if (existing === undefined)
+      createdParents.push(op.path);
+    const { list, appended } = appendEntries(existing, op.entries ?? [], op.path);
+    parent[key] = [...list, ...appended.map((entry) => structuredClone(entry))];
+    recorded.push({ op: "append-array", path: op.path, applied: appended, previous: undefined });
+  }
+  return { value: target, recorded, createdParents };
+}
+function navigate(root, path, created) {
+  let node = root;
+  for (let depth = 0;depth < path.length - 1; depth += 1) {
+    const key = path[depth];
+    const next = node[key];
+    if (next === undefined) {
+      node[key] = {};
+      created.push(path.slice(0, depth + 1));
+    } else if (!isPlainObject(next)) {
+      throw new Error(`cannot descend into ${path.slice(0, depth + 1).join(".")}: it is ${Array.isArray(next) ? "an array" : `a ${typeof next}`}, not a table`);
+    }
+    node = node[key];
+  }
+  return node;
+}
+function revertTomlOps(value, ops) {
+  const notes = [];
+  for (const record of [...ops].reverse()) {
+    if (record.op === "set") {
+      const now = valueAt(value, record.path);
+      if (now === undefined)
+        continue;
+      if (!deepEqual(now, record.applied)) {
+        notes.push(`${record.path.join(".")}: current value differs from what the installer wrote; left untouched`);
+        continue;
+      }
+      if (record.previous === undefined) {
+        removeAt(value, record.path);
+      } else {
+        setValueAt(value, record.path, record.previous);
+      }
+    } else {
+      const entries = Array.isArray(record.applied) ? record.applied : [];
+      for (const entry of entries) {
+        const list = valueAt(value, record.path);
+        if (!Array.isArray(list))
+          continue;
+        const index = list.findIndex((item) => deepEqual(item, entry));
+        if (index === -1)
+          continue;
+        list.splice(index, 1);
+      }
+    }
+  }
+  return notes;
+}
+function pruneCreatedParents(value, parents) {
+  for (const parent of [...parents].reverse()) {
+    const current = valueAt(value, parent);
+    if (isPlainObject(current) && Object.keys(current).length === 0)
+      removeAt(value, parent);
+  }
+}
+function setValueAt(value, path, replacement) {
+  const parent = valueAt(value, path.slice(0, -1));
+  if (isPlainObject(parent))
+    parent[path[path.length - 1]] = replacement;
+}
+function tomlOpHolds(text, op) {
+  const value = parse3(text);
+  const current = valueAt(value, op.path);
+  if (op.op === "set")
+    return deepEqual(current, op.value);
+  return Array.isArray(current) && (op.entries ?? []).every((entry) => current.some((item) => deepEqual(item, entry)));
+}
+var tomlCodec;
+var init_toml = __esm(() => {
+  init_dist();
+  tomlCodec = {
+    format: "toml",
+    load: loadToml,
+    apply: (text, edit2) => {
+      if (edit2.format !== "toml")
+        throw new Error(`toml codec cannot apply a ${edit2.format} edit`);
+      const result = applyTomlOps(parse3(text), edit2.ops);
+      return { text: serializeToml(result.value), recorded: result.recorded, createdParents: result.createdParents };
+    },
+    verify: (text, edit2, op) => {
+      if (edit2.format !== "toml")
+        throw new Error(`toml codec cannot verify a ${edit2.format} edit`);
+      const ops = op === undefined ? edit2.ops : [op];
+      return ops.every((candidate) => tomlOpHolds(text, candidate));
+    },
+    revert: (text, recorded) => {
+      const value = parse3(text);
+      const notes = revertTomlOps(value, recorded.ops);
+      pruneCreatedParents(value, recorded.createdParents ?? []);
+      return { text: serializeToml(value), notes };
+    },
+    isEffectivelyEmpty: (text) => Object.keys(parse3(text)).length === 0
+  };
+});
+
+// src/installer/formats/index.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+function writeConfig(file, serialized) {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, serialized);
+}
+function codecFor(format2, host) {
+  if (format2 === "json")
+    return jsonCodec;
+  if (format2 === "toml")
+    return tomlCodec;
+  return rulesCodec(host);
+}
+var init_formats = __esm(() => {
+  init_json();
+  init_rules();
+  init_toml();
+});
+
+// src/installer/detect.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+function replacingExistingEntryNote(path) {
+  return `An existing ${path} entry is being replaced; its previous form is recorded for uninstall.`;
+}
+function othersStayRegisteredNote(others) {
+  return `Other MCP servers stay registered (${others.join(", ")}); routing to DeepSeek is not exclusive while they offer web tools.`;
+}
+function looksWebCapable(name, entry) {
+  if (WEB_TOOL_HINT.test(name))
+    return true;
+  if (!isPlainObject(entry))
+    return false;
+  const command = typeof entry.command === "string" ? entry.command : "";
+  const url = typeof entry.url === "string" ? entry.url : "";
+  const args = Array.isArray(entry.args) ? entry.args.filter((arg) => typeof arg === "string").join(" ") : "";
+  return WEB_TOOL_HINT.test(`${command} ${args} ${url}`);
+}
+function findCompetitorSteering(host, file) {
+  if (!existsSync4(file))
+    return [];
+  let text;
+  try {
+    text = readFileSync4(file, "utf8");
+  } catch {
+    return [];
+  }
+  return removeBlock(host, text).split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0 && STEERING_HINT.test(line) && !line.includes("deepseek")).slice(0, 2);
+}
+function competitorSteeringNote(file, lines) {
+  const quoted = lines.map((line) => `"${line}"`).join(", ");
+  return `Existing rules in ${file} steer toward other web tools (${quoted}); the plan surfaces this conflict — it does not resolve it.`;
+}
+function splitCompetitors(servers) {
+  const competitors = [];
+  const bystanders = [];
+  for (const [name, entry] of Object.entries(servers)) {
+    if (name === "deepseek")
+      continue;
+    (looksWebCapable(name, entry) ? competitors : bystanders).push(name);
+  }
+  return { competitors, bystanders };
+}
+var BOTH_CAPABILITIES_OFF = "Both capabilities are off; nothing would be installed.", FORCED_COST_NOTE, WEB_TOOL_HINT, STEERING_HINT;
+var init_detect = __esm(() => {
+  init_rules();
+  FORCED_COST_NOTE = "Forced routing is deterministic, and Search and Fetch are billed per successful request — " + `see the README's "Privacy and cost" section before applying.`;
+  WEB_TOOL_HINT = /(web[_ -]?(search|fetch)|search|fetch|browse|scrape|crawl|tavily|brave|exa|perplexity|firecrawl|jina|serp|duckduckgo|reader)/i;
+  STEERING_HINT = /(web[_ ]?(search|fetch)|websearch|webfetch|tavily|exa|brave|perplexity|firecrawl|jina|serp|duckduckgo|google|bing)/i;
+});
+
+// src/installer/paths.ts
+function join(...parts) {
+  return parts.filter((part) => part.length > 0).join("/");
+}
+function configHome(roots) {
+  return roots.configHome ?? join(roots.home, ".config");
+}
+function stateDir(roots, scope) {
+  return scope === "global" ? join(configHome(roots), "deepseek-web-retrieval") : join(roots.cwd, ".deepseek-web-retrieval");
+}
+
+// src/installer/rulesContent.ts
+function rulesLines(ids, search, fetch) {
+  const lines = ["DeepSeek retrieval guidance:"];
+  if (search !== "off") {
+    lines.push(`- Use ${ids.search} when the task needs fresh external information: current docs, version numbers,`, "  changelogs, or anything you cannot know from the repository alone. Do not search for facts already", "  present locally.");
+  }
+  if (fetch !== "off") {
+    lines.push(`- Use ${ids.fetch} to read a specific public web page as Markdown when its content is needed.`);
+  }
+  lines.push("- Never send localhost or private-network URLs to the DeepSeek tools; use local tools for those (the", "  server blocks private hosts by default).", "- DeepSeek requests are billed per successful call; retrieve only what the task needs.");
+  return lines;
+}
+var MCP_TOOL_IDS;
+var init_rulesContent = __esm(() => {
+  MCP_TOOL_IDS = { search: "mcp__deepseek__deepseek_web_search", fetch: "mcp__deepseek__deepseek_fetch" };
+});
+
+// src/installer/hosts/shared.ts
+function planHeader(input, paths, loaded, dialect) {
+  const notes = [];
+  const errors = [];
+  if (loaded.parseError) {
+    errors.push({ message: `${paths.config} exists but does not parse as ${dialect}: ${loaded.parseError}` });
+    return { notes, errors, abort: true };
+  }
+  if (input.search === "off" && input.fetch === "off") {
+    errors.push({ message: BOTH_CAPABILITIES_OFF });
+  }
+  const steering = findCompetitorSteering(input.host, paths.rules);
+  if (steering.length > 0)
+    notes.push(competitorSteeringNote(paths.rules, steering));
+  return { notes, errors, abort: false };
+}
+var init_shared = __esm(() => {
+  init_detect();
+});
+
+// src/installer/hosts/codex.ts
+function codexPaths(input) {
+  return {
+    config: join(input.home, ".codex/config.toml"),
+    rules: input.scope === "global" ? join(input.home, ".codex/AGENTS.md") : join(input.cwd, "AGENTS.md")
+  };
+}
+function planCodex(input, _previous) {
+  const paths = codexPaths(input);
+  const loaded = codecFor("toml", input.host).load(paths.config);
+  const tiers = { search: input.search, fetch: input.fetch };
+  const header = planHeader(input, paths, loaded, "TOML");
+  if (header.abort) {
+    return { host: "codex", scope: input.scope, tiers, edits: [], notes: header.notes, errors: header.errors };
+  }
+  const notes = [...header.notes];
+  const errors = [...header.errors];
+  const edits = [];
+  const tools = loaded.value.tools;
+  if (isPlainObject(tools) && "web_search" in tools) {
+    errors.push({
+      message: `${paths.config} sets [tools] web_search, which is a silent no-op at Codex 0.163.0 (only the top-level ` + "web_search key controls the tool). Remove it first so the config cannot mislead."
+    });
+  }
+  const servers = loaded.value.mcp_servers;
+  if (isPlainObject(servers)) {
+    if ("deepseek" in servers)
+      notes.push(replacingExistingEntryNote("mcp_servers.deepseek"));
+    const { competitors, bystanders } = splitCompetitors(servers);
+    if ((input.search === "forced" || input.fetch === "forced") && competitors.length > 0) {
+      errors.push({
+        message: `Forced cannot deliver exclusive routing: [mcp_servers.${competitors.join("], [mcp_servers.")}] look(s) web-capable, ` + "and Codex offers no per-server kill switch. Remove the server(s), disable their tools by hand via their " + "disabled_tools key, or choose a lower tier."
+      });
+    }
+    const stayRegistered = input.search === "forced" || input.fetch === "forced" ? bystanders : [...competitors, ...bystanders];
+    if (stayRegistered.length > 0)
+      notes.push(othersStayRegisteredNote(stayRegistered));
+  }
+  const env = {};
+  if (input.search === "off")
+    env[ENABLE_SEARCH_ENV] = "false";
+  if (input.fetch === "off")
+    env[ENABLE_FETCH_ENV] = "false";
+  const entry = {
+    command: "npx",
+    args: ["-y", input.packageRef],
+    ...Object.keys(env).length > 0 ? { env } : {},
+    env_vars: [API_KEY_ENV]
+  };
+  const existingEntry = isPlainObject(servers) ? servers.deepseek : undefined;
+  const ops = [
+    { op: "set", path: ["mcp_servers", "deepseek"], value: entry, previous: existingEntry }
+  ];
+  if (input.search === "forced") {
+    const previous = typeof loaded.value.web_search === "string" ? loaded.value.web_search : undefined;
+    ops.push({ op: "set", path: ["web_search"], value: "disabled", previous });
+    notes.push(previous === undefined ? 'web_search is being set to "disabled" (no previous value existed; the default is "cached").' : `web_search is being set to "disabled"; the previous value "${previous}" is snapshotted for uninstall.`);
+  }
+  edits.push({ file: paths.config, format: "toml", ops });
+  notes.push(`Codex stdio children do not inherit the parent environment, so the entry forwards ${API_KEY_ENV} explicitly ` + "via env_vars; the key must be set in the shell that launches Codex.");
+  if (input.scope === "project") {
+    notes.push("Codex config lives in ~/.codex/config.toml only (user level), so the server registration and kill switch are " + "written there even for a project-scope install; the rules file stays project-local.");
+  }
+  if (loaded.lossy) {
+    notes.push(`${paths.config} contains comments; the TOML rewrite will drop them.`);
+  }
+  if (input.search === "forced" || input.fetch === "forced") {
+    notes.push('Forced search is exclusion: the built-in web_search tool is disabled ("disabled" mode). ' + FORCED_COST_NOTE);
+  }
+  if (input.search === "optional" || input.fetch === "optional") {
+    notes.push('Note: Codex ships a built-in web_search tool (default "cached" mode, an OpenAI index) that stays available ' + "alongside the DeepSeek tools under the optional tier.");
+  }
+  if (input.search === "preferred" || input.fetch === "preferred") {
+    edits.push({
+      file: paths.rules,
+      format: "rules",
+      block: buildRulesBlock(input.host, rulesLines(MCP_TOOL_IDS, input.search, input.fetch))
+    });
+    notes.push(input.scope === "global" ? `Rules block upserted in ${paths.rules}; Codex reads ~/.codex/AGENTS.md plus every AGENTS.md from the project root to the cwd.` : `Rules block upserted in ${paths.rules}; Codex reads every AGENTS.md from the project root to the cwd.`);
+  }
+  return { host: "codex", scope: input.scope, tiers, edits, notes, errors };
+}
+var init_codex = __esm(() => {
+  init_formats();
+  init_detect();
+  init_constants();
+  init_rules();
+  init_rulesContent();
+  init_shared();
+});
+
+// src/installer/hosts/opencode.ts
+function opencodePaths(input) {
+  return input.scope === "global" ? { config: join(configHome(input), "opencode/opencode.jsonc"), rules: join(configHome(input), "opencode/AGENTS.md") } : { config: join(input.cwd, "opencode.jsonc"), rules: join(input.cwd, "AGENTS.md") };
+}
+function planOpenCode(input, previous) {
+  const paths = opencodePaths(input);
+  const loaded = codecFor("json", input.host).load(paths.config);
+  const tiers = { search: input.search, fetch: input.fetch };
+  const header = planHeader(input, paths, loaded, "JSONC");
+  if (header.abort) {
+    return { host: "opencode", scope: input.scope, tiers, edits: [], notes: header.notes, errors: header.errors };
+  }
+  const notes = [...header.notes];
+  const errors = [...header.errors];
+  const edits = [];
+  if (input.search === "preferred") {
+    errors.push({
+      message: "OpenCode search has no preferred tier: the websearch provider is host-level config, so the model never " + "chooses between engines. Use --search optional (provider registered, built-in stays default), " + "--search forced (replace the engine), or --search off."
+    });
+  }
+  const plugins = Array.isArray(loaded.value.plugins) ? loaded.value.plugins : [];
+  const alreadyInstalled = plugins.some((entry) => isPlainObject(entry) && typeof entry.package === "string" && entry.package.includes("deepseek-web-retrieval"));
+  if (alreadyInstalled && previous === undefined) {
+    errors.push({
+      message: `${paths.config} already has a plugins entry referencing deepseek-web-retrieval that this installer did not ` + "write. Remove it (or run uninstall if it came from a previous init), then retry."
+    });
+  }
+  if (alreadyInstalled && errors.length === 0) {
+    notes.push("A previous init wrote the plugins entry; re-applying updates it and carries the original snapshots over.");
+  }
+  if (errors.length > 0) {
+    return { host: "opencode", scope: input.scope, tiers, edits, notes, errors };
+  }
+  const options = {};
+  if (input.search === "forced")
+    options.setDefaultWebsearch = true;
+  if (input.search === "off")
+    options.searchEnabled = false;
+  if (input.fetch === "forced")
+    options.fetchOverrideWebfetch = true;
+  if (input.fetch === "off")
+    options.fetchEnabled = false;
+  const ops = [
+    {
+      op: "append-array",
+      path: ["plugins"],
+      entries: [{ package: input.packageRef, options }],
+      existingCount: plugins.length
+    }
+  ];
+  const permissions = [];
+  if (input.search !== "off")
+    permissions.push({ action: "websearch", resource: "*", effect: "allow" });
+  if (input.fetch !== "off")
+    permissions.push({ action: "deepseek_fetch", resource: "*", effect: "allow" });
+  if (input.fetch === "forced")
+    permissions.push({ action: "webfetch", resource: "*", effect: "allow" });
+  const existingPermissions = Array.isArray(loaded.value.permissions) ? loaded.value.permissions.length : 0;
+  if (permissions.length > 0) {
+    ops.push({ op: "append-array", path: ["permissions"], entries: permissions, existingCount: existingPermissions });
+  }
+  if (input.search === "forced") {
+    const currentProvider = isPlainObject(loaded.value.websearch) ? loaded.value.websearch.provider : undefined;
+    ops.push({ op: "set", path: ["websearch", "provider"], value: "deepseek", previous: currentProvider });
+    notes.push(currentProvider === undefined ? "websearch.provider is being set to deepseek (no previous value existed)." : `websearch.provider is being set to deepseek; the previous value "${String(currentProvider)}" is snapshotted for uninstall.`);
+  }
+  edits.push({ file: paths.config, format: "json", ops });
+  notes.push("The plugin entry uses the object form so options are honored; auto-discovered plugins cannot receive options.");
+  if (input.search === "optional") {
+    notes.push("Search tier optional: the deepseek provider is registered but the built-in provider stays the default engine; " + "set websearch.provider to deepseek (or rerun with --search forced) to route search through DeepSeek.");
+  }
+  if (input.search === "forced" || input.fetch === "forced") {
+    notes.push("Forced tier replaces built-in routing. " + FORCED_COST_NOTE);
+  }
+  if (input.fetch === "preferred") {
+    edits.push({
+      file: paths.rules,
+      format: "rules",
+      block: buildRulesBlock(input.host, rulesLines(OPENCODE_TOOL_IDS, input.search, input.fetch))
+    });
+    notes.push(`Rules block upserted in ${paths.rules}; OpenCode loads AGENTS.md only (no CLAUDE.md fallback in v2).`);
+  }
+  return { host: "opencode", scope: input.scope, tiers, edits, notes, errors };
+}
+var OPENCODE_TOOL_IDS;
+var init_opencode = __esm(() => {
+  init_formats();
+  init_detect();
+  init_rules();
+  init_rulesContent();
+  init_shared();
+  OPENCODE_TOOL_IDS = { search: "websearch (provider deepseek)", fetch: "deepseek_fetch" };
+});
+
+// src/installer/hosts/pi.ts
+function piPaths(input) {
+  return input.scope === "global" ? { config: join(input.home, ".pi/agent/mcp.json"), rules: join(input.home, ".pi/agent/AGENTS.md") } : { config: join(input.cwd, ".pi/mcp.json"), rules: join(input.cwd, "AGENTS.md") };
+}
+function planPi(input, _previous) {
+  const paths = piPaths(input);
+  const loaded = codecFor("json", input.host).load(paths.config);
+  const tiers = { search: input.search, fetch: input.fetch };
+  const header = planHeader(input, paths, loaded, "JSON");
+  if (header.abort) {
+    return { host: "pi", scope: input.scope, tiers, edits: [], notes: header.notes, errors: header.errors };
+  }
+  const notes = [...header.notes];
+  const errors = [...header.errors];
+  const edits = [];
+  const env = { [API_KEY_ENV]: `\${${API_KEY_ENV}}` };
+  if (input.search === "off")
+    env[ENABLE_SEARCH_ENV] = "false";
+  if (input.fetch === "off")
+    env[ENABLE_FETCH_ENV] = "false";
+  const entry = {
+    command: "npx",
+    args: ["-y", input.packageRef],
+    env,
+    exposure: "direct",
+    enabled: true
+  };
+  const servers = loaded.value.mcpServers;
+  const existingEntry = isPlainObject(servers) ? servers.deepseek : undefined;
+  const ops = [
+    { op: "set", path: ["mcpServers", "deepseek"], value: entry, previous: existingEntry }
+  ];
+  edits.push({ file: paths.config, format: "json", ops });
+  if (isPlainObject(servers)) {
+    if (servers.deepseek !== undefined)
+      notes.push(replacingExistingEntryNote("mcpServers.deepseek"));
+    const { competitors, bystanders } = splitCompetitors(servers);
+    const forced = input.search === "forced" || input.fetch === "forced";
+    if (forced) {
+      const excluded = [];
+      const unexcludable = [];
+      for (const name of competitors) {
+        const current = servers[name];
+        if (!isPlainObject(current)) {
+          unexcludable.push(name);
+          continue;
+        }
+        const previous = typeof current.enabled === "boolean" ? current.enabled : undefined;
+        if (previous === false)
+          continue;
+        ops.push({ op: "set", path: ["mcpServers", name, "enabled"], value: false, previous });
+        excluded.push(name);
+      }
+      if (excluded.length > 0) {
+        notes.push(`Forced tier: web-capable MCP servers are disabled so DeepSeek routing is exclusive (${excluded.join(", ")}; ` + "prior enabled values are snapshotted for uninstall).");
+      }
+      if (unexcludable.length > 0) {
+        errors.push({
+          message: `Forced cannot deliver exclusive routing: mcpServers entries ${unexcludable.join(", ")} look web-capable ` + "but are not objects, so the plan cannot set their enabled key. Fix or remove them, or choose a lower tier."
+        });
+      }
+    }
+    const stayRegistered = forced ? bystanders : [...competitors, ...bystanders];
+    if (stayRegistered.length > 0)
+      notes.push(othersStayRegisteredNote(stayRegistered));
+  }
+  notes.push('"exposure": "direct" is required: Pi 1.3.0 defaults MCP tools to codemode, which hides them from the model.');
+  notes.push(`\`${API_KEY_ENV}\` is written as "\${${API_KEY_ENV}}" so the key expands from the shell that launches Pi and stays out of the file.`);
+  if (loaded.lossy) {
+    notes.push(`${paths.config} contains comments; the JSON edit preserves them.`);
+  }
+  if (input.search === "preferred" || input.fetch === "preferred") {
+    edits.push({
+      file: paths.rules,
+      format: "rules",
+      block: buildRulesBlock(input.host, rulesLines(MCP_TOOL_IDS, input.search, input.fetch))
+    });
+    notes.push(`Rules block upserted in ${paths.rules}; Pi loads AGENTS.md context files from the working directory and its parents.`);
+  }
+  if (input.search === "forced" || input.fetch === "forced") {
+    notes.push("Forced tier: Pi 1.3.0 ships no built-in web tool, so the registered tools are the only web path (de-facto). " + FORCED_COST_NOTE);
+  }
+  return { host: "pi", scope: input.scope, tiers, edits, notes, errors };
+}
+var init_pi = __esm(() => {
+  init_formats();
+  init_detect();
+  init_constants();
+  init_rules();
+  init_rulesContent();
+  init_shared();
+});
+
+// src/installer/state.ts
+import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+function statePathFor(input) {
+  return join2(stateDir(input, input.scope), `install.${input.host}.json`);
+}
+function readRecord(input) {
+  const file = statePathFor(input);
+  if (!existsSync5(file))
+    return;
+  try {
+    return JSON.parse(readFileSync5(file, "utf8"));
+  } catch {
+    return;
+  }
+}
+function claimedByOtherScope(input, files) {
+  const other = input.scope === "global" ? "project" : "global";
+  const record = readRecord({ ...input, scope: other });
+  if (record === undefined)
+    return [];
+  return files.filter((file) => record.files.some((candidate) => candidate.file === file));
+}
+function writeRecord(input, record) {
+  const file = statePathFor(input);
+  mkdirSync2(join2(file, ".."), { recursive: true });
+  writeFileSync2(file, `${JSON.stringify(record, null, 2)}
+`, { mode: 384 });
+  chmodSync(file, 384);
+}
+function deleteRecord(input) {
+  const file = statePathFor(input);
+  if (existsSync5(file))
+    rmSync(file);
+}
+function listRecords(roots) {
+  const records = [];
+  for (const scope of ["global", "project"]) {
+    const dir = stateDir(roots, scope);
+    if (!existsSync5(dir))
+      continue;
+    for (const name of readdirSync(dir)) {
+      if (!name.startsWith("install.") || !name.endsWith(".json"))
+        continue;
+      try {
+        records.push(JSON.parse(readFileSync5(join2(dir, name), "utf8")));
+      } catch {}
+    }
+  }
+  return records;
+}
+var init_state = () => {};
+
+// src/installer/hosts/index.ts
+function planForHost(host, input) {
+  const previous = readRecord(input);
+  const planned = withCrossScopeGuard(HOST_PLANNERS[host](input, previous), input);
+  return withSecretGuard(withOrphanReverts(planned, input, previous));
+}
+function withCrossScopeGuard(plan, input) {
+  if (plan.errors.length > 0)
+    return plan;
+  const other = input.scope === "global" ? "project" : "global";
+  const overlap = claimedByOtherScope(input, plan.edits.map((edit2) => edit2.file));
+  if (overlap.length === 0)
+    return plan;
+  return {
+    ...plan,
+    edits: [],
+    reverts: undefined,
+    errors: [
+      {
+        message: `A ${plan.host} install is already recorded at the ${other} scope and claims the same file(s): ${overlap.join(", ")}. ` + `Uninstall it first (deepseek-web-retrieval uninstall --host ${plan.host} --scope ${other}), ` + `or re-run with --scope ${other} to update it in place — two scopes must not edit one file.`
+      }
+    ]
+  };
+}
+function withSecretGuard(plan) {
+  for (const edit2 of plan.edits) {
+    if (edit2.format === "rules")
+      continue;
+    for (const op of edit2.ops) {
+      if (op.op !== "set" || op.previous === undefined)
+        continue;
+      const offender = findSecretLike(op.previous, op.path.join("."));
+      if (offender !== undefined) {
+        return {
+          ...plan,
+          edits: [],
+          reverts: undefined,
+          errors: [
+            {
+              message: `${edit2.file}: the existing value at ${op.path.join(".")} contains a credential-looking key ` + `(${offender}). The installer refuses to snapshot secrets into its state file. Move the key to ` + `environment indirection ("\${${API_KEY_ENV}}" expansion or env_vars) and re-run.`
+            }
+          ]
+        };
+      }
+    }
+  }
+  return plan;
+}
+function findSecretLike(value, at) {
+  if (typeof value !== "object" || value === null)
+    return;
+  for (const [key, child] of Object.entries(value)) {
+    const path = `${at}.${key}`;
+    if (/(api[_-]?key|token|secret|password|credential)/i.test(key) && typeof child === "string" && child.length > 0 && !/^\$\{[^}]+\}$/.test(child)) {
+      return path;
+    }
+    const nested = findSecretLike(child, path);
+    if (nested !== undefined)
+      return nested;
+  }
+  return;
+}
+function withOrphanReverts(plan, input, previous) {
+  if (plan.errors.length > 0)
+    return plan;
+  if (previous === undefined)
+    return plan;
+  const reverts = [];
+  for (const file of previous.files) {
+    const edit2 = plan.edits.find((candidate) => candidate.file === file.file);
+    if (edit2 === undefined) {
+      reverts.push(file);
+      continue;
+    }
+    if (edit2.format === "rules" || file.format === "rules")
+      continue;
+    const orphanOps = file.ops.filter((op) => !edit2.ops.some((candidate) => candidate.op === op.op && candidate.path.join("\x00") === op.path.join("\x00")));
+    if (orphanOps.length > 0)
+      reverts.push({ ...file, ops: orphanOps });
+  }
+  if (reverts.length === 0)
+    return plan;
+  return { ...plan, reverts };
+}
+var HOST_PLANNERS;
+var init_hosts = __esm(() => {
+  init_codex();
+  init_opencode();
+  init_pi();
+  init_constants();
+  init_state();
+  HOST_PLANNERS = {
+    opencode: planOpenCode,
+    pi: planPi,
+    codex: planCodex
+  };
+});
+
+// src/installer/revert.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, rmdirSync, unlinkSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+function pruneEmptyDir(dir) {
+  try {
+    rmdirSync(dir);
+  } catch {}
+}
+function revertRecordedFile(file, host, opts) {
+  const lines = [];
+  if (!existsSync6(file.file)) {
+    lines.push(`already absent: ${file.file}${opts.label}`);
+    return lines;
+  }
+  const codec = codecFor(file.format, host);
+  const text = readFileSync6(file.file, "utf8");
+  if (file.format === "rules") {
+    const edit2 = { file: file.file, format: "rules", block: file.blockApplied ?? "" };
+    if (!codec.verify(text, edit2)) {
+      lines.push(`no rules block${opts.label} in ${file.file}; left untouched`);
+      return lines;
+    }
+    const updated = codec.revert(text, file).text;
+    if (opts.whole && codec.isEffectivelyEmpty(updated)) {
+      unlinkSync(file.file);
+      pruneEmptyDir(dirname2(file.file));
+      lines.push(`deleted ${file.file} (installer-created, now empty)`);
+    } else {
+      writeConfig(file.file, updated);
+      lines.push(`removed rules block${opts.label} from ${file.file}`);
+    }
+    return lines;
+  }
+  const reverted = codec.revert(text, file);
+  if (opts.whole && file.created && codec.isEffectivelyEmpty(reverted.text)) {
+    unlinkSync(file.file);
+    pruneEmptyDir(dirname2(file.file));
+    lines.push(`deleted ${file.file} (installer-created, now empty)`);
+  } else {
+    writeConfig(file.file, reverted.text);
+    lines.push(`reverted artifacts${opts.label} in ${file.file}`);
+  }
+  lines.push(...reverted.notes.map((note) => `  note: ${note}`));
+  return lines;
+}
+var init_revert = __esm(() => {
+  init_formats();
+});
+
+// src/installer/apply.ts
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
+function applyPlan(plan, input) {
+  if (plan.errors.length > 0) {
+    throw new Error(`refusing to apply a plan with errors: ${plan.errors.map((error) => error.message).join("; ")}`);
+  }
+  assertNoDrift(plan);
+  const previous = readRecord(input);
+  const prepared = plan.edits.map((edit2) => prepareEdit(edit2, plan.host));
+  const files = [];
+  const lines = [];
+  for (const item of prepared) {
+    item.write();
+    files.push(mergeRecorded(item.recorded, previous?.files.find((file) => file.file === item.edit.file)));
+    lines.push(`${item.recorded.created ? "created" : "updated"} ${item.edit.file}`);
+  }
+  if ((plan.reverts ?? []).length > 0) {
+    lines.push(...applyReverts(plan));
+  }
+  const record = {
+    version: 1,
+    host: plan.host,
+    scope: plan.scope,
+    tiers: plan.tiers,
+    createdAt: new Date().toISOString(),
+    files
+  };
+  writeRecord(input, record);
+  const verification = verifyEdits(plan.edits, plan.host);
+  lines.push(...verification.lines);
+  return { lines, ok: verification.ok };
+}
+function assertNoDrift(plan) {
+  const drifts = [];
+  for (const edit2 of plan.edits) {
+    if (edit2.format === "rules")
+      continue;
+    const loaded = codecFor(edit2.format, plan.host).load(edit2.file);
+    if (loaded.parseError) {
+      drifts.push(`${edit2.file} no longer parses (${loaded.parseError})`);
+      continue;
+    }
+    for (const op of edit2.ops) {
+      if (op.op !== "set")
+        continue;
+      const current = valueAt(loaded.value, op.path);
+      if (!deepEqual(current, op.previous)) {
+        drifts.push(`${edit2.file}: ${op.path.join(".")} changed since the plan was rendered`);
+      }
+    }
+  }
+  if (drifts.length > 0) {
+    throw new Error(`refusing to apply — the config changed since the plan was rendered: ${drifts.join("; ")}. ` + "Re-run init to re-plan against the current files.");
+  }
+}
+function prepareEdit(edit2, host) {
+  const codec = codecFor(edit2.format, host);
+  const loaded = codec.load(edit2.file);
+  if (loaded.parseError) {
+    throw new Error(`${edit2.file} does not parse: ${loaded.parseError}`);
+  }
+  const applied = codec.apply(loaded.text, edit2);
+  const recorded = edit2.format === "rules" ? { file: edit2.file, format: "rules", created: !loaded.exists, ops: [], blockApplied: edit2.block } : { file: edit2.file, format: edit2.format, created: !loaded.exists, ops: applied.recorded, createdParents: applied.createdParents };
+  return {
+    edit: edit2,
+    recorded,
+    write: () => writeConfig(edit2.file, applied.text)
+  };
+}
+function applyReverts(plan) {
+  const lines = [];
+  for (const revert of plan.reverts ?? []) {
+    const whole = !plan.edits.some((edit2) => edit2.file === revert.file);
+    lines.push(...revertRecordedFile(revert, plan.host, { label: " (previous init)", whole }));
+  }
+  return lines;
+}
+function mergeRecorded(current, before) {
+  if (before === undefined)
+    return current;
+  const ops = current.ops.map((op) => {
+    const old = before.ops.find((candidate) => candidate.op === op.op && candidate.path.join("\x00") === op.path.join("\x00"));
+    if (old === undefined)
+      return op;
+    if (op.op === "set" && old.op === "set" && deepEqual(op.previous, old.applied)) {
+      return { ...op, previous: old.previous };
+    }
+    if (op.op === "append-array" && old.op === "append-array") {
+      return { ...op, applied: [...old.applied, ...op.applied] };
+    }
+    return op;
+  });
+  return {
+    ...current,
+    created: before.created,
+    ops,
+    createdParents: [...before.createdParents ?? [], ...current.createdParents ?? []]
+  };
+}
+function verifyEdits(edits, host) {
+  const lines = [];
+  let ok = true;
+  for (const edit2 of edits) {
+    if (!existsSync7(edit2.file)) {
+      lines.push(`FAIL ${edit2.file} does not exist after apply`);
+      ok = false;
+      continue;
+    }
+    const codec = codecFor(edit2.format, host);
+    const text = readFileSync7(edit2.file, "utf8");
+    if (edit2.format === "rules") {
+      const good = codec.verify(text, edit2);
+      lines.push(`${good ? "pass" : "FAIL"} ${edit2.file}: rules block ${good ? "present" : "missing"}`);
+      ok = ok && good;
+      continue;
+    }
+    for (const op of edit2.ops) {
+      const good = codec.verify(text, edit2, op);
+      lines.push(`${good ? "pass" : "FAIL"} ${edit2.file}: ${describeOp(op)} ${good ? "holds" : "missing"}`);
+      ok = ok && good;
+    }
+  }
+  return { lines, ok };
+}
+function describeOp(op) {
+  if (op.op === "set")
+    return `set ${op.path.join(".")}`;
+  return `append ${op.path.join(".")}`;
+}
+var init_apply = __esm(() => {
+  init_formats();
+  init_revert();
+  init_state();
+});
+
+// src/installer/render.ts
+function renderPlan(plan) {
+  const lines = [];
+  lines.push(`Install plan: ${plan.host} (${plan.scope} scope)`);
+  lines.push(`Tiers: search=${plan.tiers.search}, fetch=${plan.tiers.fetch}`);
+  lines.push("");
+  lines.push("Files:");
+  for (const edit2 of plan.edits) {
+    lines.push(`  ${edit2.file}`);
+    if (edit2.format === "rules") {
+      lines.push("    upsert marked rules block");
+      continue;
+    }
+    for (const op of edit2.ops) {
+      if (op.op === "set") {
+        const was = op.previous === undefined ? "(absent)" : preview(op.previous);
+        lines.push(`    set ${op.path.join(".")} = ${preview(op.value)} (was ${was})`);
+      } else {
+        const count = (op.entries ?? []).length;
+        const kept = op.existingCount !== undefined ? ` (${op.existingCount} existing kept)` : "";
+        lines.push(`    append ${count} entr${count === 1 ? "y" : "ies"} to ${op.path.join(".")}${kept}`);
+        for (const entry of op.entries ?? [])
+          lines.push(`      + ${preview(entry)}`);
+      }
+    }
+  }
+  if (plan.reverts && plan.reverts.length > 0) {
+    lines.push("");
+    lines.push("Reverts (artifacts from the previous init that this plan no longer wants):");
+    for (const revert of plan.reverts) {
+      lines.push(`  ${revert.file}`);
+      if (revert.format === "rules") {
+        lines.push("    remove rules block");
+        continue;
+      }
+      for (const op of revert.ops) {
+        if (op.op === "set") {
+          lines.push(op.previous === undefined ? `    remove ${op.path.join(".")} (was not set before this install)` : `    restore ${op.path.join(".")} = ${preview(op.previous)}`);
+        } else {
+          const count = Array.isArray(op.applied) ? op.applied.length : 0;
+          lines.push(`    remove ${count} appended entr${count === 1 ? "y" : "ies"} from ${op.path.join(".")}`);
+        }
+      }
+    }
+  }
+  if (plan.notes.length > 0) {
+    lines.push("");
+    lines.push("Notes:");
+    for (const note of plan.notes)
+      lines.push(`  - ${note}`);
+  }
+  return lines.join(`
+`);
+}
+function preview(value) {
+  const text = JSON.stringify(value) ?? String(value);
+  return text.length > 100 ? `${text.slice(0, 97)}...` : text;
+}
+
+// src/installer/uninstall.ts
+function uninstall(input) {
+  const record = readRecord(input);
+  if (record === undefined) {
+    throw new Error(`No ${input.host} install is recorded for the ${input.scope} scope.`);
+  }
+  const other = input.scope === "global" ? "project" : "global";
+  const overlap = claimedByOtherScope(input, record.files.map((file) => file.file));
+  if (overlap.length > 0) {
+    throw new Error(`A ${input.host} install is also recorded at the ${other} scope and claims the same file(s): ${overlap.join(", ")}. ` + `Uninstall the ${other}-scope install first so this rollback cannot clobber its entries.`);
+  }
+  const lines = [];
+  for (const file of [...record.files].reverse()) {
+    lines.push(...revertRecordedFile(file, record.host, { label: "", whole: true }));
+  }
+  deleteRecord(input);
+  pruneEmptyDir(stateDir(input, input.scope));
+  lines.push(`removed install record (${input.host}, ${input.scope})`);
+  return lines;
+}
+var init_uninstall = __esm(() => {
+  init_revert();
+  init_state();
+});
+
+// src/installer/cli.ts
+var exports_cli = {};
+__export(exports_cli, {
+  runInstallerCli: () => runInstallerCli
+});
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+function parseFlags(args) {
+  const values = new Map;
+  const booleans = new Set;
+  const problems = [];
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg.startsWith("--")) {
+      problems.push(`unexpected argument "${arg}" (flags only)`);
+      continue;
+    }
+    const eq = arg.indexOf("=");
+    const name = eq === -1 ? arg.slice(2) : arg.slice(2, eq);
+    if (BOOLEAN_FLAGS.has(name)) {
+      booleans.add(name);
+      continue;
+    }
+    if (!VALUE_FLAGS.has(name)) {
+      problems.push(`unknown flag --${name}`);
+      continue;
+    }
+    if (eq !== -1) {
+      values.set(name, arg.slice(eq + 1));
+      continue;
+    }
+    const next = args[i + 1];
+    if (next === undefined || next.startsWith("--")) {
+      problems.push(`--${name} requires a value`);
+      continue;
+    }
+    values.set(name, next);
+    i += 1;
+  }
+  return { values, booleans, problems };
+}
+async function runInstallerCli(argv, io = {}) {
+  const out = io.out ?? ((line) => console.log(line));
+  const err = io.err ?? ((line) => console.error(line));
+  const [command, ...rest] = argv;
+  if (command === undefined || command === "help" || command === "--help") {
+    out(USAGE);
+    return command === undefined ? 1 : 0;
+  }
+  const flags = parseFlags(rest);
+  if (flags.problems.length > 0) {
+    for (const problem of flags.problems)
+      err(`error: ${problem}`);
+    err(`
+${USAGE}`);
+    return 1;
+  }
+  const cwd = resolve(flags.values.get("cwd") ?? process.cwd());
+  const home = process.env.HOME ?? homedir();
+  const configHome2 = resolveConfigHome(home);
+  if (command === "list") {
+    const records = listRecords({ home, cwd, configHome: configHome2 });
+    if (records.length === 0) {
+      out("No installs recorded.");
+      return 0;
+    }
+    for (const record of records) {
+      out(`${record.host} (${record.scope}) — search=${record.tiers.search}, fetch=${record.tiers.fetch}, installed ${record.createdAt}`);
+      for (const file of record.files)
+        out(`  ${file.created ? "created" : "modified"} ${file.file}`);
+    }
+    return 0;
+  }
+  if (command === "uninstall") {
+    const required2 = requireInput(flags, cwd, home, configHome2, false);
+    if (!required2.ok)
+      return usageError(required2.problems, err);
+    try {
+      for (const line of uninstall(required2.input))
+        out(line);
+      return 0;
+    } catch (error) {
+      err(error instanceof Error ? error.message : String(error));
+      return 1;
+    }
+  }
+  if (command !== "init") {
+    err(`Unknown command "${command}".
+
+${USAGE}`);
+    return 1;
+  }
+  const required = requireInput(flags, cwd, home, configHome2, true);
+  if (!required.ok)
+    return usageError(required.problems, err);
+  const { input } = required;
+  const plan = planForHost(input.host, input);
+  if (plan.errors.length > 0) {
+    for (const error of plan.errors)
+      err(`error: ${error.message}`);
+    err("Nothing was written.");
+    return 1;
+  }
+  out(renderPlan(plan));
+  if (!flags.booleans.has("apply")) {
+    out(`
+Plan only — re-run with --apply to write these changes.`);
+    return 0;
+  }
+  try {
+    const result = applyPlan(plan, input);
+    for (const line of result.lines)
+      out(line);
+    return result.ok ? 0 : 1;
+  } catch (error) {
+    err(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+function usageError(problems, err) {
+  for (const problem of problems)
+    err(`error: ${problem}`);
+  err(`
+${USAGE}`);
+  return 1;
+}
+function resolveConfigHome(home) {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg && home === (process.env.HOME ?? ""))
+    return xdg;
+  return;
+}
+function requireInput(flags, cwd, home, configHome2, needsTiers) {
+  const problems = [];
+  const host = flags.values.get("host");
+  const scope = flags.values.get("scope");
+  const search = needsTiers ? flags.values.get("search") ?? "" : "optional";
+  const fetch = needsTiers ? flags.values.get("fetch") ?? "" : "optional";
+  if (host === undefined)
+    problems.push(`--host is required (one of: ${HOSTS.join(", ")})`);
+  else if (!HOSTS.includes(host))
+    problems.push(`invalid --host value "${host}" (one of: ${HOSTS.join(", ")})`);
+  if (scope === undefined)
+    problems.push(`--scope is required (one of: ${SCOPES.join(", ")})`);
+  else if (!SCOPES.includes(scope))
+    problems.push(`invalid --scope value "${scope}" (one of: ${SCOPES.join(", ")})`);
+  if (needsTiers) {
+    if (!TIERS.includes(search)) {
+      problems.push(flags.values.has("search") ? `invalid --search value "${search}" (one of: ${TIERS.join(", ")})` : `--search is required (one of: ${TIERS.join(", ")})`);
+    }
+    if (!TIERS.includes(fetch)) {
+      problems.push(flags.values.has("fetch") ? `invalid --fetch value "${fetch}" (one of: ${TIERS.join(", ")})` : `--fetch is required (one of: ${TIERS.join(", ")})`);
+    }
+  }
+  if (home === "")
+    problems.push("HOME is not set and the user home cannot be resolved; cannot proceed");
+  if (problems.length > 0)
+    return { ok: false, problems };
+  return {
+    ok: true,
+    input: {
+      host,
+      scope,
+      search,
+      fetch,
+      packageRef: flags.values.get("package") ?? "deepseek-web-retrieval",
+      home,
+      cwd,
+      configHome: configHome2
+    }
+  };
+}
+var HOSTS, HOST_CHOICES, SCOPES, TIERS, USAGE, VALUE_FLAGS, BOOLEAN_FLAGS;
+var init_cli = __esm(() => {
+  init_hosts();
+  init_apply();
+  init_state();
+  init_uninstall();
+  HOSTS = Object.keys(HOST_PLANNERS);
+  HOST_CHOICES = `<${HOSTS.join("|")}>`;
+  SCOPES = ["project", "global"];
+  TIERS = ["optional", "preferred", "forced", "off"];
+  USAGE = `Usage:
+  deepseek-web-retrieval init --host ${HOST_CHOICES} --scope <project|global> --search <optional|preferred|forced|off> --fetch <optional|preferred|forced|off> [--package <npm ref>] [--cwd <dir>] [--apply]
+  deepseek-web-retrieval uninstall --host ${HOST_CHOICES} --scope <project|global> [--cwd <dir>]
+  deepseek-web-retrieval list [--cwd <dir>]
+
+init prints the full plan (every file, old value → new value) and writes nothing
+until --apply is passed. uninstall restores what the plan applied.`;
+  VALUE_FLAGS = new Set(["host", "scope", "search", "fetch", "package", "cwd"]);
+  BOOLEAN_FLAGS = new Set(["apply"]);
+});
 
 // src/mcp/cli.ts
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 
 // src/core/auth.ts
-var API_KEY_ENV = "DEEPSEEK_API_KEY";
+init_constants();
 function apiKeyFromEnv(env = process.env) {
   const key = env[API_KEY_ENV]?.trim();
   return key ? key : undefined;
 }
 
 // src/mcp/auth.ts
-var MISSING_API_KEY_MESSAGE = "DeepSeek API key not found. Set DEEPSEEK_API_KEY in the MCP server's env configuration.";
+init_constants();
+var MISSING_API_KEY_MESSAGE = `DeepSeek API key not found. Set ${API_KEY_ENV} in the MCP server's env configuration.`;
 function requireApiKey(env) {
   const apiKey = apiKeyFromEnv(env);
   if (!apiKey)
@@ -19,30 +4000,11 @@ function requireApiKey(env) {
   return apiKey;
 }
 
-// src/core/constants.ts
-var SEARCH_ENDPOINT = "https://api.deepseek.com/v1/tools/search";
-var FETCH_ENDPOINT = "https://api.deepseek.com/v1/tools/fetch";
-var DEFAULT_SEARCH_COUNT = 10;
-var DEFAULT_MAX_RESULTS = 5;
-var DEFAULT_MIN_RERANK = 1.5;
-var DEFAULT_MIN_AUTHORITY = 2;
-var DEFAULT_MAX_SUMMARY_CHARS = 1200;
-var DEFAULT_FETCH_MAX_CHARS = 16000;
-var DEFAULT_TIMEOUT_MS = 30000;
-var MIN_TIMEOUT_MS = 1000;
-var MAX_TIMEOUT_MS = 120000;
-var MAX_QUERY_CHARS = 128;
-var MAX_URL_CHARS = 8192;
-var MAX_ERROR_BODY_CHARS = 2000;
-var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
-var FETCH_TRUNCATION_MARKER = `
-
-[content truncated]`;
-var DEFAULT_API_KEY_SOURCE = "auto";
-var DEFAULT_MAX_RETRIES = 0;
-var MAX_RETRIES = 5;
-var DEFAULT_RETRY_BASE_DELAY_MS = 250;
-var MAX_RETRY_DELAY_MS = 1e4;
+// src/mcp/config.ts
+init_constants();
+
+// src/core/options.ts
+init_constants();
 
 // src/core/domains.ts
 import { isIP } from "node:net";
@@ -172,7 +4134,7 @@ function resolveSearchOptions(input) {
     language: optionalText(input?.language),
     maxSummaryChars: clampInt(input?.maxSummaryChars, DEFAULT_MAX_SUMMARY_CHARS, 0, 1e6),
     timeoutMs: clampInt(input?.searchTimeoutMs, DEFAULT_TIMEOUT_MS, MIN_TIMEOUT_MS, MAX_TIMEOUT_MS),
-    setDefault: input?.setDefaultWebsearch === true
+    enabled: input?.searchEnabled !== false
   };
 }
 function resolveFetchOptions(input) {
@@ -181,9 +4143,8 @@ function resolveFetchOptions(input) {
     allowedDomains: normalizeDomains(input?.fetchAllowedDomains),
     blockedDomains: normalizeDomains(input?.fetchBlockedDomains),
     timeoutMs: clampInt(input?.fetchTimeoutMs, DEFAULT_TIMEOUT_MS, MIN_TIMEOUT_MS, MAX_TIMEOUT_MS),
-    overrideWebfetch: input?.fetchOverrideWebfetch === true,
-    registerTool: input?.fetchRegisterTool !== false,
-    blockPrivateHosts: input?.fetchBlockPrivateHosts !== false
+    blockPrivateHosts: input?.fetchBlockPrivateHosts !== false,
+    enabled: input?.fetchEnabled !== false
   };
 }
 function resolveAuthOptions(input) {
@@ -213,33 +4174,63 @@ function clampInt(value, fallback, min, max) {
 }
 
 // src/mcp/config.ts
+var NUMBER_ENV = {
+  count: "DEEPSEEK_SEARCH_COUNT",
+  maxResults: "DEEPSEEK_SEARCH_MAX_RESULTS",
+  minRerank: "DEEPSEEK_SEARCH_MIN_RERANK",
+  minAuthority: "DEEPSEEK_SEARCH_MIN_AUTHORITY",
+  maxSummaryChars: "DEEPSEEK_SEARCH_MAX_SUMMARY_CHARS",
+  searchTimeoutMs: "DEEPSEEK_SEARCH_TIMEOUT_MS",
+  fetchMaxChars: "DEEPSEEK_FETCH_MAX_CHARS",
+  fetchTimeoutMs: "DEEPSEEK_FETCH_TIMEOUT_MS",
+  maxRetries: "DEEPSEEK_MAX_RETRIES",
+  retryBaseDelayMs: "DEEPSEEK_RETRY_BASE_DELAY_MS"
+};
+var TEXT_ENV = {
+  language: "DEEPSEEK_SEARCH_LANGUAGE"
+};
+var DOMAINS_ENV = {
+  blockedDomains: "DEEPSEEK_SEARCH_BLOCKED_DOMAINS",
+  includeDomains: "DEEPSEEK_SEARCH_INCLUDE_DOMAINS",
+  fetchAllowedDomains: "DEEPSEEK_FETCH_ALLOWED_DOMAINS",
+  fetchBlockedDomains: "DEEPSEEK_FETCH_BLOCKED_DOMAINS"
+};
+var FLAG_ENV = {
+  allowUnknownAuthority: "DEEPSEEK_SEARCH_ALLOW_UNKNOWN_AUTHORITY"
+};
+var FALSE_ONLY_ENV = {
+  fetchBlockPrivateHosts: "DEEPSEEK_FETCH_BLOCK_PRIVATE_HOSTS",
+  searchEnabled: ENABLE_SEARCH_ENV,
+  fetchEnabled: ENABLE_FETCH_ENV
+};
 function resolveEnvOptions(env = process.env) {
   return resolvePluginOptions(pluginOptionsFromEnv(env));
 }
 function pluginOptionsFromEnv(env) {
   const options = {};
-  putNumber(options, "count", env.DEEPSEEK_SEARCH_COUNT);
-  putNumber(options, "maxResults", env.DEEPSEEK_SEARCH_MAX_RESULTS);
-  putNumber(options, "minRerank", env.DEEPSEEK_SEARCH_MIN_RERANK);
-  putNumber(options, "minAuthority", env.DEEPSEEK_SEARCH_MIN_AUTHORITY);
-  putBoolean(options, "allowUnknownAuthority", env.DEEPSEEK_SEARCH_ALLOW_UNKNOWN_AUTHORITY);
-  putDomains(options, "blockedDomains", env.DEEPSEEK_SEARCH_BLOCKED_DOMAINS);
-  putDomains(options, "includeDomains", env.DEEPSEEK_SEARCH_INCLUDE_DOMAINS);
-  putText(options, "language", env.DEEPSEEK_SEARCH_LANGUAGE);
-  putNumber(options, "maxSummaryChars", env.DEEPSEEK_SEARCH_MAX_SUMMARY_CHARS);
-  putNumber(options, "searchTimeoutMs", env.DEEPSEEK_SEARCH_TIMEOUT_MS);
-  putNumber(options, "fetchMaxChars", env.DEEPSEEK_FETCH_MAX_CHARS);
-  putDomains(options, "fetchAllowedDomains", env.DEEPSEEK_FETCH_ALLOWED_DOMAINS);
-  putDomains(options, "fetchBlockedDomains", env.DEEPSEEK_FETCH_BLOCKED_DOMAINS);
-  putNumber(options, "fetchTimeoutMs", env.DEEPSEEK_FETCH_TIMEOUT_MS);
-  if (isFalseValue(env.DEEPSEEK_FETCH_BLOCK_PRIVATE_HOSTS)) {
-    options.fetchBlockPrivateHosts = false;
-  }
-  putNumber(options, "maxRetries", env.DEEPSEEK_MAX_RETRIES);
-  putNumber(options, "retryBaseDelayMs", env.DEEPSEEK_RETRY_BASE_DELAY_MS);
+  putNumber(options, "count", env);
+  putNumber(options, "maxResults", env);
+  putNumber(options, "minRerank", env);
+  putNumber(options, "minAuthority", env);
+  putBoolean(options, "allowUnknownAuthority", env);
+  putDomains(options, "blockedDomains", env);
+  putDomains(options, "includeDomains", env);
+  putText(options, "language", env);
+  putNumber(options, "maxSummaryChars", env);
+  putNumber(options, "searchTimeoutMs", env);
+  putNumber(options, "fetchMaxChars", env);
+  putDomains(options, "fetchAllowedDomains", env);
+  putDomains(options, "fetchBlockedDomains", env);
+  putNumber(options, "fetchTimeoutMs", env);
+  putFalseOnly(options, "fetchBlockPrivateHosts", env);
+  putFalseOnly(options, "searchEnabled", env);
+  putFalseOnly(options, "fetchEnabled", env);
+  putNumber(options, "maxRetries", env);
+  putNumber(options, "retryBaseDelayMs", env);
   return options;
 }
-function putNumber(target, key, value) {
+function putNumber(target, key, env) {
+  const value = env[NUMBER_ENV[key]];
   if (value === undefined)
     return;
   const trimmed = value.trim();
@@ -249,18 +4240,24 @@ function putNumber(target, key, value) {
   if (Number.isFinite(parsed))
     target[key] = parsed;
 }
-function putText(target, key, value) {
+function putText(target, key, env) {
+  const value = env[TEXT_ENV[key]];
   if (value === undefined)
     return;
   const trimmed = value.trim();
   if (trimmed)
     target[key] = trimmed;
 }
-function putBoolean(target, key, value) {
-  if (isTrueValue(value))
+function putBoolean(target, key, env) {
+  if (isTrueValue(env[FLAG_ENV[key]]))
     target[key] = true;
 }
-function putDomains(target, key, value) {
+function putFalseOnly(target, key, env) {
+  if (isFalseValue(env[FALSE_ONLY_ENV[key]]))
+    target[key] = false;
+}
+function putDomains(target, key, env) {
+  const value = env[DOMAINS_ENV[key]];
   if (value === undefined || !value.trim())
     return;
   const domains = value.split(",").map((domain) => domain.trim()).filter((domain) => domain.length > 0);
@@ -280,7 +4277,11 @@ function isFalseValue(value) {
 import { McpServer } from "@modelcontextprotocol/server";
 import * as z from "zod/v4";
 
+// src/core/client.ts
+init_constants();
+
 // src/core/format.ts
+init_constants();
 function truncate(value, maxChars) {
   if (maxChars <= 0)
     return "";
@@ -337,8 +4338,34 @@ function formatApiError(operation, status, body) {
 function formatTimeoutError(operation, timeoutMs) {
   return `${operation} timed out after ${timeoutMs} ms`;
 }
+function formatSearchResults(results) {
+  if (results.length === 0)
+    return "No results found.";
+  return results.map((result, index) => {
+    const title = result.title?.trim() || result.url;
+    const lines = [`${index + 1}. [${escapeBrackets(title)}](${result.url})`];
+    if (result.content) {
+      lines.push(`   ${result.content.replaceAll(`
+`, " ")}`);
+    }
+    if (result.published !== undefined) {
+      lines.push(`   Published: ${formatPublished(result.published)}`);
+    }
+    return lines.join(`
+`);
+  }).join(`
+
+`);
+}
+function escapeBrackets(value) {
+  return value.replaceAll("[", "\\[").replaceAll("]", "\\]");
+}
+function formatPublished(epochMs) {
+  return new Date(epochMs).toISOString().slice(0, 10);
+}
 
 // src/core/url.ts
+init_constants();
 function parseFetchUrl(value) {
   const input = value.trim();
   if (!input)
@@ -424,16 +4451,13 @@ function processResults(raw, options) {
     }
     seen.add(url);
     const content = truncate(optionalText2(item.summary) ?? optionalText2(item.snippet) ?? "", options.maxSummaryChars);
-    const time = {};
     const published = parsePublished(item.date);
-    if (published !== undefined)
-      time.published = published;
     const title = optionalText2(item.title);
     results.push({
       url,
       ...title ? { title } : {},
       ...content ? { content } : {},
-      time
+      ...published !== undefined ? { published } : {}
     });
   }
   return results;
@@ -445,7 +4469,8 @@ function optionalText2(value) {
   return trimmed ? trimmed : undefined;
 }
 
-// src/core/client.ts
+// src/core/transport.ts
+init_constants();
 class DeepSeekApiError extends Error {
   operation;
   status;
@@ -463,63 +4488,32 @@ class DeepSeekApiError extends Error {
     this.retryAfterMs = input.retryAfterMs;
   }
 }
-async function searchWeb(query, options, request) {
-  const trimmed = query.trim();
-  if (!trimmed)
-    throw new Error("DeepSeek search query must not be empty");
-  if (Array.from(trimmed).length > MAX_QUERY_CHARS) {
-    throw new Error(`DeepSeek search query must be ${MAX_QUERY_CHARS} characters or fewer`);
-  }
-  const builtQuery = buildQuery(trimmed, options);
-  const builtQueryLength = Array.from(builtQuery).length;
-  if (builtQueryLength > MAX_QUERY_CHARS) {
-    throw new Error(`DeepSeek search query must be ${MAX_QUERY_CHARS} characters or fewer after applying ` + `blockedDomains, includeDomains, and language ` + `(built query is ${builtQueryLength} characters)`);
-  }
-  const payload = await postJson(SEARCH_ENDPOINT, {
-    query: builtQuery,
-    count: options.count,
-    need_content: false
-  }, "DeepSeek Search", request, options.timeoutMs);
-  if (!Array.isArray(payload.results)) {
-    throw new Error("DeepSeek Search returned a response without a results array");
-  }
-  return processResults(payload.results, options);
-}
-async function fetchPage(url, options, request) {
-  assertFetchHostPolicy(url, options);
-  const payload = await postJson(FETCH_ENDPOINT, { url: url.href }, "DeepSeek Fetch", request, options.timeoutMs);
-  const title = typeof payload.title === "string" ? payload.title.trim() : "";
-  const content = typeof payload.content === "string" ? payload.content : "";
-  if (!content.trim()) {
-    throw new Error("DeepSeek Fetch returned no page content (the page may be empty or unavailable)");
-  }
-  return { url: url.href, title, content };
-}
-async function postJson(endpoint, body, operation, options, timeoutMs) {
-  const attempts = options.retry.maxRetries + 1;
+async function postJson(endpoint, body, operation, opts) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const attempts = opts.retry.maxRetries + 1;
   let lastError;
   for (let attempt = 0;attempt < attempts; attempt++) {
     try {
-      return await requestOnce(endpoint, body, operation, options, timeoutMs);
+      return await requestOnce(endpoint, body, operation, opts, fetchImpl);
     } catch (error) {
       lastError = error;
       if (!(error instanceof DeepSeekApiError) || !error.retryable || attempt === attempts - 1) {
         throw error;
       }
-      await sleep(retryDelay(error.retryAfterMs, options.retry.baseDelayMs, attempt), options.signal);
+      await sleep(retryDelay(error.retryAfterMs, opts.retry.baseDelayMs, attempt), opts.signal);
     }
   }
   throw lastError;
 }
-async function requestOnce(endpoint, body, operation, options, timeoutMs) {
+async function requestOnce(endpoint, body, operation, opts, fetchImpl) {
   return fetchWithTimeout(endpoint, {
     method: "POST",
     headers: {
-      Authorization: `Bearer ${options.auth.apiKey}`,
+      Authorization: `Bearer ${opts.auth.apiKey}`,
       "Content-Type": "application/json"
     },
     body: JSON.stringify(body)
-  }, options.signal, timeoutMs, operation, async (response) => {
+  }, opts.signal, opts.timeoutMs, operation, fetchImpl, async (response) => {
     if (!response.ok) {
       const text2 = await readBoundedText(response, MAX_ERROR_BODY_CHARS);
       throw new DeepSeekApiError({
@@ -539,7 +4533,7 @@ async function requestOnce(endpoint, body, operation, options, timeoutMs) {
     }
   });
 }
-async function fetchWithTimeout(endpoint, init, signal, timeoutMs, operation, handleResponse) {
+async function fetchWithTimeout(endpoint, init, signal, timeoutMs, operation, fetchImpl, handleResponse) {
   const controller = new AbortController;
   let timedOut = false;
   const forwardAbort = () => controller.abort(signal.reason);
@@ -552,7 +4546,7 @@ async function fetchWithTimeout(endpoint, init, signal, timeoutMs, operation, ha
     controller.abort(new Error("timeout"));
   }, timeoutMs);
   try {
-    const response = await fetch(endpoint, { ...init, signal: controller.signal });
+    const response = await fetchImpl(endpoint, { ...init, signal: controller.signal });
     return await handleResponse(response);
   } catch (error) {
     if (timedOut)
@@ -666,11 +4660,72 @@ async function readResponseText(response, maxBytes, operation) {
   }
   return text;
 }
+
+// src/core/client.ts
+function effectiveTimeout(configuredMs, perCallMs) {
+  return perCallMs === undefined ? configuredMs : Math.min(configuredMs, perCallMs);
+}
+async function searchWeb(query, options, request) {
+  const trimmed = query.trim();
+  if (!trimmed)
+    throw new Error("DeepSeek search query must not be empty");
+  if (Array.from(trimmed).length > MAX_QUERY_CHARS) {
+    throw new Error(`DeepSeek search query must be ${MAX_QUERY_CHARS} characters or fewer`);
+  }
+  const builtQuery = buildQuery(trimmed, options);
+  const builtQueryLength = Array.from(builtQuery).length;
+  if (builtQueryLength > MAX_QUERY_CHARS) {
+    throw new Error(`DeepSeek search query must be ${MAX_QUERY_CHARS} characters or fewer after applying ` + `blockedDomains, includeDomains, and language ` + `(built query is ${builtQueryLength} characters)`);
+  }
+  const timeout = effectiveTimeout(options.timeoutMs, request.timeoutMs);
+  const payload = await postJson(SEARCH_ENDPOINT, {
+    query: builtQuery,
+    count: options.count,
+    need_content: false
+  }, "DeepSeek Search", { signal: request.signal, auth: request.auth, retry: request.retry, timeoutMs: timeout });
+  if (!Array.isArray(payload.results)) {
+    throw new Error("DeepSeek Search returned a response without a results array");
+  }
+  return processResults(payload.results, options);
+}
+async function fetchPage(url, options, request) {
+  assertFetchHostPolicy(url, options);
+  const timeout = effectiveTimeout(options.timeoutMs, request.timeoutMs);
+  const payload = await postJson(FETCH_ENDPOINT, { url: url.href }, "DeepSeek Fetch", { signal: request.signal, auth: request.auth, retry: request.retry, timeoutMs: timeout });
+  const title = typeof payload.title === "string" ? payload.title.trim() : "";
+  const content = typeof payload.content === "string" ? payload.content : "";
+  if (!content.trim()) {
+    throw new Error("DeepSeek Fetch returned no page content (the page may be empty or unavailable)");
+  }
+  return { url: url.href, title, content };
+}
+async function fetchDocument(url, options, request) {
+  if (typeof url !== "string" && !(url instanceof URL))
+    throw new Error('"url" must be a string or URL');
+  const page = await fetchPage(url instanceof URL ? url : parseFetchUrl(url), options, request);
+  const formatted = formatFetchedContent(page.title, page.content, options.maxChars);
+  return {
+    url: page.url,
+    title: page.title,
+    content: formatted.content,
+    truncated: formatted.truncated
+  };
+}
+
+// src/mcp/server.ts
+init_constants();
+
+// src/core/descriptions.ts
+var FETCH_SERVICE_LIMITS = "DeepSeek does not render JavaScript and cannot reach private networks; PDFs, images, and other binary files are unsupported.";
+var FETCH_OUTPUT_TRUNCATED = "Output is truncated to the configured size.";
+var SEARCH_RANKED_FILTERED = "Results are ranked by relevance and source authority, deduplicated by URL, and capped at the configured maximum.";
+var SEARCH_EMPTY_IS_NORMAL = "An empty result list is normal, not an error.";
+var SEARCH_QUERY_OPERATORS = "Use site:/-site: operators in the query to include or exclude domains; the full query must stay within 128 characters.";
 // package.json
 var package_default = {
   $schema: "https://json.schemastore.org/package.json",
   name: "deepseek-web-retrieval",
-  version: "0.2.0",
+  version: "0.3.0",
   description: "Token-efficient DeepSeek Search and Fetch for coding agents, starting with OpenCode v2.",
   type: "module",
   license: "MIT",
@@ -695,7 +4750,7 @@ var package_default = {
     "./mcp": "./src/mcp/server.ts"
   },
   bin: {
-    "deepseek-web-retrieval": "./dist/cli.js"
+    "deepseek-web-retrieval": "dist/cli.js"
   },
   files: [
     "index.ts",
@@ -715,7 +4770,7 @@ var package_default = {
     "test:e2e": "bun run test/e2e/run.ts",
     "docs:matrix": "bun run scripts/render-matrix.ts",
     "test:coverage": "bun test --coverage",
-    check: "bun run typecheck && bun run build && bun test"
+    check: "bun run typecheck && bun run docs:matrix --check && bun run build && bun test"
   },
   peerDependencies: {
     "@opencode/plugin": "^2.0.32"
@@ -733,37 +4788,12 @@ var package_default = {
   },
   dependencies: {
     "@modelcontextprotocol/server": "^2.3.1",
+    "jsonc-parser": "^3.3.1",
+    "smol-toml": "^1.9.1",
     zod: "^4"
   }
 };
 
-// src/mcp/format.ts
-function formatSearchResults(results) {
-  if (results.length === 0)
-    return "No results found.";
-  return results.map((result, index) => {
-    const title = result.title?.trim() || result.url;
-    const lines = [`${index + 1}. [${escapeBrackets(title)}](${result.url})`];
-    if (result.content) {
-      lines.push(`   ${result.content.replaceAll(`
-`, " ")}`);
-    }
-    if (result.time.published !== undefined) {
-      lines.push(`   Published: ${formatPublished(result.time.published)}`);
-    }
-    return lines.join(`
-`);
-  }).join(`
-
-`);
-}
-function escapeBrackets(value) {
-  return value.replaceAll("[", "\\[").replaceAll("]", "\\]");
-}
-function formatPublished(epochMs) {
-  return new Date(epochMs).toISOString().slice(0, 10);
-}
-
 // src/mcp/server.ts
 var MCP_SERVER_NAME = "deepseek-web-retrieval";
 var SEARCH_INPUT = z.object({
@@ -786,54 +4816,55 @@ var FETCH_OUTPUT = z.object({
   content: z.string(),
   truncated: z.boolean()
 });
-var SEARCH_DESCRIPTION = "Search the web with DeepSeek's in-house search engine and return a short, filtered result " + "list (title, URL, summary). Results are ranked by relevance and source authority, deduplicated " + "by URL, and capped at the configured maximum. An empty result list is normal, not an error. " + "Use site:/-site: operators in the query to include or exclude domains; the full query must stay " + "within 128 characters. To read a full page, pass a result URL to the deepseek_fetch tool.";
-var FETCH_DESCRIPTION = "Fetch one web page as clean Markdown through DeepSeek's Fetch API. DeepSeek does not render " + "JavaScript and cannot reach private networks; PDFs, images, and other binary files are " + "unsupported. Output is truncated to the configured size.";
+var SEARCH_DESCRIPTION = "Search the web with DeepSeek's in-house search engine and return a short, filtered result " + "list (title, URL, summary). " + `${SEARCH_RANKED_FILTERED} ` + `${SEARCH_EMPTY_IS_NORMAL} ` + `${SEARCH_QUERY_OPERATORS} ` + "To read a full page, pass a result URL to the deepseek_fetch tool.";
+var FETCH_DESCRIPTION = "Fetch one web page as clean Markdown through DeepSeek's Fetch API. " + `${FETCH_SERVICE_LIMITS} ` + `${FETCH_OUTPUT_TRUNCATED}`;
 function createDeepSeekServer(config, env = process.env) {
   const server = new McpServer({ name: MCP_SERVER_NAME, version: package_default.version });
-  server.registerTool("deepseek_web_search", {
-    title: "DeepSeek Web Search",
-    description: SEARCH_DESCRIPTION,
-    inputSchema: SEARCH_INPUT,
-    outputSchema: SEARCH_OUTPUT,
-    annotations: { readOnlyHint: true }
-  }, async ({ query }, ctx) => {
-    try {
-      const request = requestContext(config, env, ctx.mcpReq.signal);
-      const results = await searchWeb(query, config.search, request);
-      return {
-        content: [{ type: "text", text: formatSearchResults(results) }],
-        structuredContent: { results: results.map(toStructuredResult) }
-      };
-    } catch (error) {
-      return toErrorResult(error);
-    }
-  });
-  server.registerTool("deepseek_fetch", {
-    title: "DeepSeek Fetch",
-    description: FETCH_DESCRIPTION,
-    inputSchema: FETCH_INPUT,
-    outputSchema: FETCH_OUTPUT,
-    annotations: { readOnlyHint: true }
-  }, async ({ url }, ctx) => {
-    try {
-      const request = requestContext(config, env, ctx.mcpReq.signal);
-      const target = parseFetchUrl(url);
-      assertFetchHostPolicy(target, config.fetch);
-      const page = await fetchPage(target, config.fetch, request);
-      const formatted = formatFetchedContent(page.title, page.content, config.fetch.maxChars);
-      return {
-        content: [{ type: "text", text: formatted.content }],
-        structuredContent: {
-          url: page.url,
-          title: page.title,
-          content: formatted.content,
-          truncated: formatted.truncated
-        }
-      };
-    } catch (error) {
-      return toErrorResult(error);
-    }
-  });
+  if (config.search.enabled) {
+    server.registerTool("deepseek_web_search", {
+      title: "DeepSeek Web Search",
+      description: SEARCH_DESCRIPTION,
+      inputSchema: SEARCH_INPUT,
+      outputSchema: SEARCH_OUTPUT,
+      annotations: { readOnlyHint: true }
+    }, async ({ query }, ctx) => {
+      try {
+        const request = requestContext(config, env, ctx.mcpReq.signal);
+        const results = await searchWeb(query, config.search, request);
+        return {
+          content: [{ type: "text", text: formatSearchResults(results) }],
+          structuredContent: { results: results.map(toStructuredResult) }
+        };
+      } catch (error) {
+        return toErrorResult(error);
+      }
+    });
+  }
+  if (config.fetch.enabled) {
+    server.registerTool("deepseek_fetch", {
+      title: "DeepSeek Fetch",
+      description: FETCH_DESCRIPTION,
+      inputSchema: FETCH_INPUT,
+      outputSchema: FETCH_OUTPUT,
+      annotations: { readOnlyHint: true }
+    }, async ({ url }, ctx) => {
+      try {
+        const request = requestContext(config, env, ctx.mcpReq.signal);
+        const page = await fetchDocument(url, config.fetch, request);
+        return {
+          content: [{ type: "text", text: page.content }],
+          structuredContent: {
+            url: page.url,
+            title: page.title,
+            content: page.content,
+            truncated: page.truncated
+          }
+        };
+      } catch (error) {
+        return toErrorResult(error);
+      }
+    });
+  }
   return server;
 }
 function requestContext(config, env, signal) {
@@ -844,22 +4875,41 @@ function toStructuredResult(result) {
     url: result.url,
     ...result.title ? { title: result.title } : {},
     ...result.content ? { content: result.content } : {},
-    ...result.time.published !== undefined ? { published: result.time.published } : {}
+    ...result.published !== undefined ? { published: result.published } : {}
   };
 }
+function servePrecheck(config) {
+  if (config.search.enabled || config.fetch.enabled)
+    return;
+  return `Both tools are disabled (${ENABLE_SEARCH_ENV} and ${ENABLE_FETCH_ENV} are false); ` + "at least one must stay enabled.";
+}
 function toErrorResult(error) {
   const message = error instanceof Error ? error.message : String(error);
   return { content: [{ type: "text", text: message }], isError: true };
 }
 
 // src/mcp/cli.ts
+var subcommand = process.argv[2];
+if (subcommand === "init" || subcommand === "uninstall" || subcommand === "list") {
+  const { runInstallerCli: runInstallerCli2 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
+  process.exit(await runInstallerCli2(process.argv.slice(2)));
+}
 var env = process.env;
 if (!apiKeyFromEnv(env)) {
   console.error(MISSING_API_KEY_MESSAGE);
   process.exit(1);
 }
 var config = resolveEnvOptions(env);
+var precheck = servePrecheck(config);
+if (precheck) {
+  console.error(precheck);
+  process.exit(1);
+}
 var handle = serveStdio(() => createDeepSeekServer(config, env));
-console.error(`deepseek-web-retrieval MCP server on stdio ` + `(search: max ${config.search.maxResults} results, fetch: max ${config.fetch.maxChars} chars)`);
+var tools = [
+  config.search.enabled ? `search (max ${config.search.maxResults} results)` : null,
+  config.fetch.enabled ? `fetch (max ${config.fetch.maxChars} chars)` : null
+].filter(Boolean).join(", ");
+console.error(`deepseek-web-retrieval MCP server on stdio (${tools})`);
 process.on("SIGINT", () => void handle.close());
 process.on("SIGTERM", () => void handle.close());