opencode-dotenv 0.3.8 → 0.5.0

package/dist/index.js

@@ -1,380 +1,1088 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
+// @bun
+// src/plugin.ts
+import { homedir } from "os";
+import { appendFile, mkdir } from "fs/promises";
+
+// 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;
+(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 = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var 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);
+    })
+  }
 };
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// node_modules/jsonc-parser/lib/umd/main.js
-var require_main = __commonJS((exports, module) => {
-  (function(factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-      var v = factory(__require, exports);
-      if (v !== undefined)
-        module.exports = v;
-    } else if (typeof define === "function" && define.amd) {
-      define(["require", "exports", "./impl/format", "./impl/edit", "./impl/scanner", "./impl/parser"], factory);
-    }
-  })(function(require2, exports2) {
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.applyEdits = exports2.modify = exports2.format = exports2.printParseErrorCode = exports2.ParseErrorCode = exports2.stripComments = exports2.visit = exports2.getNodeValue = exports2.getNodePath = exports2.findNodeAtOffset = exports2.findNodeAtLocation = exports2.parseTree = exports2.parse = exports2.getLocation = exports2.SyntaxKind = exports2.ScanError = exports2.createScanner = undefined;
-    const formatter = require2("./impl/format");
-    const edit = require2("./impl/edit");
-    const scanner = require2("./impl/scanner");
-    const parser = require2("./impl/parser");
-    exports2.createScanner = scanner.createScanner;
-    var ScanError;
-    (function(ScanError2) {
-      ScanError2[ScanError2["None"] = 0] = "None";
-      ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
-      ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
-      ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
-      ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
-      ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
-      ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
-    })(ScanError || (exports2.ScanError = ScanError = {}));
-    var SyntaxKind;
-    (function(SyntaxKind2) {
-      SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
-      SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
-      SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
-      SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
-      SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
-      SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
-      SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
-      SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
-      SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
-      SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
-      SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
-      SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
-      SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
-      SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
-      SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
-      SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
-      SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
-    })(SyntaxKind || (exports2.SyntaxKind = SyntaxKind = {}));
-    exports2.getLocation = parser.getLocation;
-    exports2.parse = parser.parse;
-    exports2.parseTree = parser.parseTree;
-    exports2.findNodeAtLocation = parser.findNodeAtLocation;
-    exports2.findNodeAtOffset = parser.findNodeAtOffset;
-    exports2.getNodePath = parser.getNodePath;
-    exports2.getNodeValue = parser.getNodeValue;
-    exports2.visit = parser.visit;
-    exports2.stripComments = parser.stripComments;
-    var ParseErrorCode;
-    (function(ParseErrorCode2) {
-      ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
-      ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
-      ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
-      ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
-      ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
-      ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
-      ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
-      ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
-      ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
-      ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
-      ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
-      ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
-      ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
-      ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
-      ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
-      ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
-    })(ParseErrorCode || (exports2.ParseErrorCode = ParseErrorCode = {}));
-    function printParseErrorCode(code) {
-      switch (code) {
-        case 1:
-          return "InvalidSymbol";
-        case 2:
-          return "InvalidNumberFormat";
-        case 3:
-          return "PropertyNameExpected";
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
         case 4:
-          return "ValueExpected";
+          handleError(14);
+          break;
         case 5:
-          return "ColonExpected";
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
         case 6:
-          return "CommaExpected";
-        case 7:
-          return "CloseBraceExpected";
-        case 8:
-          return "CloseBracketExpected";
-        case 9:
-          return "EndOfFileExpected";
-        case 10:
-          return "InvalidCommentToken";
-        case 11:
-          return "UnexpectedEndOfComment";
+          handleError(16);
+          break;
+      }
+      switch (token) {
         case 12:
-          return "UnexpectedEndOfString";
         case 13:
-          return "UnexpectedEndOfNumber";
-        case 14:
-          return "InvalidUnicode";
-        case 15:
-          return "InvalidEscapeCharacter";
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
         case 16:
-          return "InvalidCharacter";
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
       }
-      return "<unknown ParseErrorCode>";
-    }
-    exports2.printParseErrorCode = printParseErrorCode;
-    function format(documentText, range, options) {
-      return formatter.format(documentText, range, options);
-    }
-    exports2.format = format;
-    function modify(text, path, value, options) {
-      return edit.setProperty(text, path, value, options);
-    }
-    exports2.modify = modify;
-    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;
+    }
+  }
+  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;
         }
-        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 = edit.applyEdit(text, e);
-        } else {
-          throw new Error("Overlapping edit");
+        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;
         }
-        lastModifiedOffset = e.offset;
+        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]);
       }
-      return text;
+    } else {
+      handleError(5, [], [2, 5]);
     }
-    exports2.applyEdits = applyEdits;
-  });
-});
-
-// src/index.ts
-var import_jsonc_parser = __toESM(require_main(), 1);
-import { resolve, normalize } from "node:path";
-import { homedir as osHomedir } from "node:os";
-var LOG_FILE = "/tmp/opencode-dotenv.log";
-var LOAD_GUARD = "__opencodeDotenvLoaded";
-var VALID_ENV_KEY = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-function getHomeDir() {
-  return process.env.HOME ?? osHomedir();
-}
-function parseDotenv(content) {
-  const result = {};
-  if (typeof content !== "string")
-    return result;
-  const lines = content.split(`
-`);
-  let i = 0;
-  while (i < lines.length) {
-    let line = lines[i].trim();
-    i++;
-    if (!line || line.startsWith("#"))
-      continue;
-    while (line.endsWith("\\") && i < lines.length) {
-      line = line.slice(0, -1) + lines[i];
-      i++;
+    _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;
     }
-    const exportMatch = line.match(/^export\s+(.*)$/);
-    if (exportMatch) {
-      line = exportMatch[1];
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
     }
-    const eqIndex = line.indexOf("=");
-    if (eqIndex === -1)
-      continue;
-    const key = line.substring(0, eqIndex).trim();
-    const value = parseValue(line.substring(eqIndex + 1));
-    if (key && isValidEnvKey(key)) {
-      result[key] = value;
+    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;
   }
-  return result;
-}
-function parseValue(raw) {
-  if (typeof raw !== "string")
-    return "";
-  let value = raw.trim();
-  if (value.startsWith('"')) {
-    const endQuote = findClosingQuote(value, '"');
-    if (endQuote !== -1) {
-      value = value.substring(1, endQuote);
-      return value.replace(/\\n/g, `
-`).replace(/\\r/g, "\r").replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-    }
-    return value;
-  }
-  if (value.startsWith("'")) {
-    const endQuote = findClosingQuote(value, "'");
-    if (endQuote !== -1) {
-      return value.substring(1, endQuote);
-    }
-    return value;
-  }
-  const inlineCommentIndex = value.indexOf(" #");
-  if (inlineCommentIndex !== -1) {
-    value = value.substring(0, inlineCommentIndex);
-  }
-  return value.trim();
-}
-function findClosingQuote(str, quote) {
-  let i = 1;
-  while (i < str.length) {
-    if (str[i] === "\\" && i + 1 < str.length) {
-      i += 2;
-      continue;
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
     }
-    if (str[i] === quote) {
-      return i;
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
     }
-    i++;
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
   }
-  return -1;
+  return true;
 }
-function isValidEnvKey(key) {
-  return VALID_ENV_KEY.test(key);
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
+// src/profiler/profiler.ts
+function percentile(sorted, p) {
+  if (sorted.length === 0)
+    return 0;
+  const index = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, index)];
 }
-function expandPath(rawPath) {
-  if (typeof rawPath !== "string") {
+function calculateStats(measurements) {
+  if (measurements.length === 0)
     return null;
-  }
-  const home = getHomeDir();
-  const expanded = rawPath.replace(/^~/, home);
-  const resolved = resolve(expanded);
-  const normalized = normalize(resolved);
-  const cwd = process.cwd();
-  const isWithinAllowedDirectory = normalized.startsWith(home) || normalized.startsWith(cwd);
-  return isWithinAllowedDirectory ? normalized : null;
+  const sorted = [...measurements].sort((a, b) => a - b);
+  const total = sorted.reduce((sum, v) => sum + v, 0);
+  return {
+    count: sorted.length,
+    min: sorted[0],
+    max: sorted[sorted.length - 1],
+    avg: total / sorted.length,
+    p50: percentile(sorted, 50),
+    p95: percentile(sorted, 95),
+    p99: percentile(sorted, 99),
+    total
+  };
 }
-var loggingEnabled = true;
-var logBuffer = [];
-var flushScheduled = false;
-function logToFile(message) {
-  if (!loggingEnabled)
-    return;
-  const timestamp = new Date().toISOString();
-  logBuffer.push(`[${timestamp}] ${message}`);
-  if (!flushScheduled) {
-    flushScheduled = true;
-    queueMicrotask(flushLogs);
+
+class Profiler {
+  marks = new Map;
+  measures = new Map;
+  fileMetrics = [];
+  initStartTime = null;
+  initEndTime = null;
+  initState = "idle";
+  configLoadTime = null;
+  configPath = null;
+  totalVars = 0;
+  startTime = performance.now();
+  mark(name) {
+    this.marks.set(name, performance.now());
+  }
+  measure(name, startMark) {
+    const start = this.marks.get(startMark);
+    if (start === undefined) {
+      return -1;
+    }
+    const duration = performance.now() - start;
+    const existing = this.measures.get(name) || [];
+    existing.push(duration);
+    this.measures.set(name, existing);
+    return duration;
+  }
+  record(name, duration) {
+    const existing = this.measures.get(name) || [];
+    existing.push(duration);
+    this.measures.set(name, existing);
+  }
+  getStats(name) {
+    const measurements = this.measures.get(name);
+    if (!measurements)
+      return null;
+    return calculateStats(measurements);
+  }
+  initStart() {
+    this.initStartTime = performance.now();
+    this.initState = "loading";
+  }
+  initComplete(state) {
+    this.initEndTime = performance.now();
+    this.initState = state;
+  }
+  recordConfigLoad(duration, path) {
+    this.configLoadTime = duration;
+    this.configPath = path;
+  }
+  recordFileLoad(path, duration, varCount, success, error) {
+    this.fileMetrics.push({
+      path,
+      duration,
+      varCount,
+      success,
+      error
+    });
+    if (success) {
+      this.totalVars += varCount;
+      this.record("file.load", duration);
+    }
+  }
+  getInitState() {
+    return this.initState;
+  }
+  getInitDuration() {
+    if (this.initStartTime === null)
+      return null;
+    if (this.initEndTime !== null) {
+      return this.initEndTime - this.initStartTime;
+    }
+    return performance.now() - this.initStartTime;
+  }
+  getTotalVars() {
+    return this.totalVars;
+  }
+  getFileMetrics() {
+    return [...this.fileMetrics];
+  }
+  export() {
+    return {
+      timestamp: new Date().toISOString(),
+      uptime: performance.now() - this.startTime,
+      initialization: {
+        startTime: this.initStartTime || 0,
+        endTime: this.initEndTime,
+        duration: this.getInitDuration(),
+        state: this.initState
+      },
+      config: {
+        loadTime: this.configLoadTime,
+        path: this.configPath
+      },
+      files: {
+        loadTimes: this.getStats("file.load"),
+        details: this.fileMetrics,
+        totalVars: this.totalVars
+      }
+    };
+  }
+  reset() {
+    this.marks.clear();
+    this.measures.clear();
+    this.fileMetrics = [];
+    this.initStartTime = null;
+    this.initEndTime = null;
+    this.initState = "idle";
+    this.configLoadTime = null;
+    this.configPath = null;
+    this.totalVars = 0;
+  }
+  startTimer(name) {
+    const start = performance.now();
+    return () => {
+      const duration = performance.now() - start;
+      this.record(name, duration);
+      return duration;
+    };
   }
 }
-async function flushLogs() {
-  if (logBuffer.length === 0) {
-    flushScheduled = false;
+var globalProfiler = new Profiler;
+// src/plugin.ts
+var CONFIG_NAME = "dotenv.jsonc";
+var LOG_DIR = `${homedir()}/.local/share/opencode`;
+var LOG_FILE = `${LOG_DIR}/dotenv.log`;
+var LOAD_GUARD = "__opencodeDotenvLoaded";
+var isTestEnv = !!process.env.BUN_TEST;
+var loggingEnabled = false;
+function log(message) {
+  if (!loggingEnabled || isTestEnv)
     return;
-  }
-  const messages = logBuffer.join(`
-`) + `
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] ${message}
 `;
-  logBuffer = [];
-  flushScheduled = false;
-  try {
-    const file = Bun.file(LOG_FILE);
-    const existing = await file.exists() ? await file.text() : "";
-    await Bun.write(LOG_FILE, existing + messages);
-  } catch {
-    loggingEnabled = false;
+  mkdir(LOG_DIR, { recursive: true }).then(() => appendFile(LOG_FILE, line)).catch(() => {});
+}
+function parseDotenv(content) {
+  const result = {};
+  if (typeof content !== "string")
+    return result;
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const match = trimmed.match(/^export\s+([^=]+)=(.*)$/);
+    const key = match ? match[1] : trimmed.split("=")[0];
+    if (!key)
+      continue;
+    const value = match ? match[2] : trimmed.substring(key.length + 1);
+    if (value === undefined)
+      continue;
+    let parsedValue = value.trim();
+    if (!parsedValue.startsWith('"') && !parsedValue.startsWith("'")) {
+      const inlineCommentIndex = parsedValue.indexOf(" #");
+      if (inlineCommentIndex !== -1) {
+        parsedValue = parsedValue.substring(0, inlineCommentIndex).trim();
+      }
+    }
+    if (parsedValue.startsWith('"') && parsedValue.endsWith('"') || parsedValue.startsWith("'") && parsedValue.endsWith("'")) {
+      parsedValue = parsedValue.slice(1, -1);
+    }
+    result[key.trim()] = parsedValue;
   }
+  return result;
+}
+function expandPath(path) {
+  return path.replace(/^~/, homedir());
 }
 async function loadConfig() {
-  const configPath = `${getHomeDir()}/.config/opencode/opencode-dotenv.jsonc`;
-  try {
-    const file = Bun.file(configPath);
-    if (await file.exists()) {
+  const timer = globalProfiler.startTimer("config.load");
+  const configPaths = [
+    `${process.cwd()}/${CONFIG_NAME}`,
+    `${homedir()}/.config/opencode/${CONFIG_NAME}`
+  ];
+  for (const configPath of configPaths) {
+    try {
+      const file = Bun.file(configPath);
       const content = await file.text();
-      const config = import_jsonc_parser.parse(content, [], {
+      if (!content || typeof content !== "string") {
+        continue;
+      }
+      const config = parse2(content, [], {
         allowTrailingComma: true
       });
-      if (!config || !Array.isArray(config.files)) {
-        logToFile("Invalid config format, using defaults");
-        return { files: [], load_cwd_env: true };
+      if (config && typeof config === "object" && Array.isArray(config.files)) {
+        loggingEnabled = config.logging?.enabled === true;
+        const duration = timer();
+        globalProfiler.recordConfigLoad(duration, configPath);
+        return { config, path: configPath };
       }
-      loggingEnabled = config.logging?.enabled !== false;
-      return config;
-    }
-  } catch (e) {
-    logToFile(`Failed to load config: ${e}`);
+    } catch {}
   }
-  return { files: [], load_cwd_env: true };
+  timer();
+  return { config: { files: [], load_cwd_env: true }, path: null };
 }
-async function loadDotenvFile(filePath, prefix) {
+async function loadDotenvFile(filePath) {
+  const start = performance.now();
   try {
     const file = Bun.file(filePath);
-    if (!await file.exists()) {
-      logToFile(`File not found: ${filePath}`);
+    const content = await file.text();
+    if (typeof content !== "string" || !content) {
+      const duration2 = performance.now() - start;
+      globalProfiler.recordFileLoad(filePath, duration2, 0, false, "Empty or invalid content");
+      log(`Invalid or empty content from ${filePath}`);
       return { count: 0, success: false };
     }
-    const content = await file.text();
     const envVars = parseDotenv(content);
+    const count = Object.keys(envVars).length;
     for (const [key, value] of Object.entries(envVars)) {
-      const envKey = prefix ? `${prefix}${key}` : key;
-      process.env[envKey] = value;
+      process.env[key] = value;
     }
-    return { count: Object.keys(envVars).length, success: true };
+    const duration = performance.now() - start;
+    globalProfiler.recordFileLoad(filePath, duration, count, true);
+    return { count, success: true };
   } catch (error) {
-    logToFile(`Failed to load ${filePath}: ${error}`);
+    const duration = performance.now() - start;
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    globalProfiler.recordFileLoad(filePath, duration, 0, false, errorMsg);
+    log(`Failed to load ${filePath}: ${errorMsg}`);
     return { count: 0, success: false };
   }
 }
-var DotEnvPlugin = async (_input) => {
+var DotEnvPlugin = async (_ctx) => {
   if (globalThis[LOAD_GUARD]) {
     return {};
   }
   globalThis[LOAD_GUARD] = true;
-  logToFile("Plugin started");
-  const config = await loadConfig();
-  logToFile(`Config loaded: ${config.files.length} files, load_cwd_env=${config.load_cwd_env}, prefix=${config.prefix ?? "(none)"}, logging=${loggingEnabled}`);
+  globalProfiler.initStart();
+  log("Plugin started");
+  const { config, path: configPath } = await loadConfig();
+  log(`Config loaded from ${configPath || "default"}: ${config.files.length} files, load_cwd_env=${config.load_cwd_env}, logging=${loggingEnabled}`);
+  const filesToLoad = [...config.files.map(expandPath)];
+  if (config.load_cwd_env !== false) {
+    filesToLoad.push(`${process.cwd()}/.env`);
+  }
   let totalFiles = 0;
   let totalVars = 0;
-  for (const rawPath of config.files) {
-    const filePath = expandPath(rawPath);
-    if (!filePath) {
-      logToFile(`SECURITY: Rejected path outside allowed directories: ${rawPath}`);
-      continue;
-    }
-    logToFile(`Loading: ${filePath}`);
-    const result = await loadDotenvFile(filePath, config.prefix);
-    if (result.success) {
-      totalFiles++;
-      totalVars += result.count;
-      logToFile(`Loaded ${result.count} vars`);
-    }
-  }
-  if (config.load_cwd_env !== false) {
-    const cwdEnvPath = `${process.cwd()}/.env`;
-    logToFile(`Loading cwd: ${cwdEnvPath}`);
-    const result = await loadDotenvFile(cwdEnvPath, config.prefix);
+  for (const filePath of filesToLoad) {
+    log(`Loading: ${filePath}`);
+    const result = await loadDotenvFile(filePath);
     if (result.success) {
       totalFiles++;
       totalVars += result.count;
-      logToFile(`Loaded ${result.count} vars from cwd`);
+      log(`Loaded ${result.count} vars from ${filePath}`);
     }
   }
-  logToFile(`Plugin finished: ${totalFiles} files, ${totalVars} vars`);
-  await flushLogs();
+  globalProfiler.initComplete("ready");
+  const initDuration = globalProfiler.getInitDuration();
+  log(`Plugin finished: ${totalFiles} files, ${totalVars} vars in ${initDuration?.toFixed(2)}ms`);
   return {};
 };
-var src_default = DotEnvPlugin;
 export {
-  parseValue,
-  parseDotenv,
-  isValidEnvKey,
-  expandPath,
-  src_default as default,
+  DotEnvPlugin as default,
   DotEnvPlugin
 };