archal 0.9.7 → 0.9.9

package/dist/vitest/index.js

@@ -0,0 +1,2669 @@
+import {
+  ARCHAL_VITEST_CONFIG_ENV,
+  assertSupportedArchalVitestServices,
+  bootstrapArchalVitestRouting,
+  fetchArchalTwin,
+  getInstalledArchalVitestRuntime,
+  getInstalledArchalVitestSession,
+  readArchalVitestConfig,
+  resetArchalTwins,
+  resolveRuntimeModule
+} from "./chunk-RKYS44AS.js";
+import {
+  encodeConfig,
+  getSessionIdFilePath
+} from "./chunk-YV6BH6DO.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-YJICENME.js";
+
+// ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/constants.js
+var require_constants = __commonJS({
+  "../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/constants.js"(exports, module) {
+    "use strict";
+    var WIN_SLASH = "\\\\/";
+    var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+    var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
+    var DOT_LITERAL = "\\.";
+    var PLUS_LITERAL = "\\+";
+    var QMARK_LITERAL = "\\?";
+    var SLASH_LITERAL = "\\/";
+    var ONE_CHAR = "(?=.)";
+    var QMARK = "[^/]";
+    var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+    var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+    var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+    var NO_DOT = `(?!${DOT_LITERAL})`;
+    var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+    var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+    var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+    var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+    var STAR = `${QMARK}*?`;
+    var SEP = "/";
+    var POSIX_CHARS = {
+      DOT_LITERAL,
+      PLUS_LITERAL,
+      QMARK_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      QMARK,
+      END_ANCHOR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOTS,
+      NO_DOT_SLASH,
+      NO_DOTS_SLASH,
+      QMARK_NO_DOT,
+      STAR,
+      START_ANCHOR,
+      SEP
+    };
+    var WINDOWS_CHARS = {
+      ...POSIX_CHARS,
+      SLASH_LITERAL: `[${WIN_SLASH}]`,
+      QMARK: WIN_NO_SLASH,
+      STAR: `${WIN_NO_SLASH}*?`,
+      DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+      NO_DOT: `(?!${DOT_LITERAL})`,
+      NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+      NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+      NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+      QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+      START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+      END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+      SEP: "\\"
+    };
+    var POSIX_REGEX_SOURCE = {
+      __proto__: null,
+      alnum: "a-zA-Z0-9",
+      alpha: "a-zA-Z",
+      ascii: "\\x00-\\x7F",
+      blank: " \\t",
+      cntrl: "\\x00-\\x1F\\x7F",
+      digit: "0-9",
+      graph: "\\x21-\\x7E",
+      lower: "a-z",
+      print: "\\x20-\\x7E ",
+      punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+      space: " \\t\\r\\n\\v\\f",
+      upper: "A-Z",
+      word: "A-Za-z0-9_",
+      xdigit: "A-Fa-f0-9"
+    };
+    module.exports = {
+      DEFAULT_MAX_EXTGLOB_RECURSION,
+      MAX_LENGTH: 1024 * 64,
+      POSIX_REGEX_SOURCE,
+      // regular expressions
+      REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+      REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+      REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+      REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+      REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+      REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+      // Replace globs with equivalent patterns to reduce parsing time.
+      REPLACEMENTS: {
+        __proto__: null,
+        "***": "*",
+        "**/**": "**",
+        "**/**/**": "**"
+      },
+      // Digits
+      CHAR_0: 48,
+      /* 0 */
+      CHAR_9: 57,
+      /* 9 */
+      // Alphabet chars.
+      CHAR_UPPERCASE_A: 65,
+      /* A */
+      CHAR_LOWERCASE_A: 97,
+      /* a */
+      CHAR_UPPERCASE_Z: 90,
+      /* Z */
+      CHAR_LOWERCASE_Z: 122,
+      /* z */
+      CHAR_LEFT_PARENTHESES: 40,
+      /* ( */
+      CHAR_RIGHT_PARENTHESES: 41,
+      /* ) */
+      CHAR_ASTERISK: 42,
+      /* * */
+      // Non-alphabetic chars.
+      CHAR_AMPERSAND: 38,
+      /* & */
+      CHAR_AT: 64,
+      /* @ */
+      CHAR_BACKWARD_SLASH: 92,
+      /* \ */
+      CHAR_CARRIAGE_RETURN: 13,
+      /* \r */
+      CHAR_CIRCUMFLEX_ACCENT: 94,
+      /* ^ */
+      CHAR_COLON: 58,
+      /* : */
+      CHAR_COMMA: 44,
+      /* , */
+      CHAR_DOT: 46,
+      /* . */
+      CHAR_DOUBLE_QUOTE: 34,
+      /* " */
+      CHAR_EQUAL: 61,
+      /* = */
+      CHAR_EXCLAMATION_MARK: 33,
+      /* ! */
+      CHAR_FORM_FEED: 12,
+      /* \f */
+      CHAR_FORWARD_SLASH: 47,
+      /* / */
+      CHAR_GRAVE_ACCENT: 96,
+      /* ` */
+      CHAR_HASH: 35,
+      /* # */
+      CHAR_HYPHEN_MINUS: 45,
+      /* - */
+      CHAR_LEFT_ANGLE_BRACKET: 60,
+      /* < */
+      CHAR_LEFT_CURLY_BRACE: 123,
+      /* { */
+      CHAR_LEFT_SQUARE_BRACKET: 91,
+      /* [ */
+      CHAR_LINE_FEED: 10,
+      /* \n */
+      CHAR_NO_BREAK_SPACE: 160,
+      /* \u00A0 */
+      CHAR_PERCENT: 37,
+      /* % */
+      CHAR_PLUS: 43,
+      /* + */
+      CHAR_QUESTION_MARK: 63,
+      /* ? */
+      CHAR_RIGHT_ANGLE_BRACKET: 62,
+      /* > */
+      CHAR_RIGHT_CURLY_BRACE: 125,
+      /* } */
+      CHAR_RIGHT_SQUARE_BRACKET: 93,
+      /* ] */
+      CHAR_SEMICOLON: 59,
+      /* ; */
+      CHAR_SINGLE_QUOTE: 39,
+      /* ' */
+      CHAR_SPACE: 32,
+      /*   */
+      CHAR_TAB: 9,
+      /* \t */
+      CHAR_UNDERSCORE: 95,
+      /* _ */
+      CHAR_VERTICAL_LINE: 124,
+      /* | */
+      CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+      /* \uFEFF */
+      /**
+       * Create EXTGLOB_CHARS
+       */
+      extglobChars(chars) {
+        return {
+          "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
+          "?": { type: "qmark", open: "(?:", close: ")?" },
+          "+": { type: "plus", open: "(?:", close: ")+" },
+          "*": { type: "star", open: "(?:", close: ")*" },
+          "@": { type: "at", open: "(?:", close: ")" }
+        };
+      },
+      /**
+       * Create GLOB_CHARS
+       */
+      globChars(win32) {
+        return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/utils.js"(exports) {
+    "use strict";
+    var {
+      REGEX_BACKSLASH,
+      REGEX_REMOVE_BACKSLASH,
+      REGEX_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_GLOBAL
+    } = require_constants();
+    exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+    exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+    exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
+    exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+    exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+    exports.isWindows = () => {
+      if (typeof navigator !== "undefined" && navigator.platform) {
+        const platform = navigator.platform.toLowerCase();
+        return platform === "win32" || platform === "windows";
+      }
+      if (typeof process !== "undefined" && process.platform) {
+        return process.platform === "win32";
+      }
+      return false;
+    };
+    exports.removeBackslashes = (str) => {
+      return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+        return match === "\\" ? "" : match;
+      });
+    };
+    exports.escapeLast = (input, char, lastIdx) => {
+      const idx = input.lastIndexOf(char, lastIdx);
+      if (idx === -1) return input;
+      if (input[idx - 1] === "\\") return exports.escapeLast(input, char, idx - 1);
+      return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+    };
+    exports.removePrefix = (input, state = {}) => {
+      let output = input;
+      if (output.startsWith("./")) {
+        output = output.slice(2);
+        state.prefix = "./";
+      }
+      return output;
+    };
+    exports.wrapOutput = (input, state = {}, options = {}) => {
+      const prepend = options.contains ? "" : "^";
+      const append = options.contains ? "" : "$";
+      let output = `${prepend}(?:${input})${append}`;
+      if (state.negated === true) {
+        output = `(?:^(?!${output}).*$)`;
+      }
+      return output;
+    };
+    exports.basename = (path, { windows } = {}) => {
+      const segs = path.split(windows ? /[\\/]/ : "/");
+      const last = segs[segs.length - 1];
+      if (last === "") {
+        return segs[segs.length - 2];
+      }
+      return last;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/scan.js
+var require_scan = __commonJS({
+  "../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/scan.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var {
+      CHAR_ASTERISK,
+      /* * */
+      CHAR_AT,
+      /* @ */
+      CHAR_BACKWARD_SLASH,
+      /* \ */
+      CHAR_COMMA,
+      /* , */
+      CHAR_DOT,
+      /* . */
+      CHAR_EXCLAMATION_MARK,
+      /* ! */
+      CHAR_FORWARD_SLASH,
+      /* / */
+      CHAR_LEFT_CURLY_BRACE,
+      /* { */
+      CHAR_LEFT_PARENTHESES,
+      /* ( */
+      CHAR_LEFT_SQUARE_BRACKET,
+      /* [ */
+      CHAR_PLUS,
+      /* + */
+      CHAR_QUESTION_MARK,
+      /* ? */
+      CHAR_RIGHT_CURLY_BRACE,
+      /* } */
+      CHAR_RIGHT_PARENTHESES,
+      /* ) */
+      CHAR_RIGHT_SQUARE_BRACKET
+      /* ] */
+    } = require_constants();
+    var isPathSeparator = (code) => {
+      return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+    };
+    var depth = (token) => {
+      if (token.isPrefix !== true) {
+        token.depth = token.isGlobstar ? Infinity : 1;
+      }
+    };
+    var scan = (input, options) => {
+      const opts = options || {};
+      const length = input.length - 1;
+      const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+      const slashes = [];
+      const tokens = [];
+      const parts = [];
+      let str = input;
+      let index = -1;
+      let start = 0;
+      let lastIndex = 0;
+      let isBrace = false;
+      let isBracket = false;
+      let isGlob = false;
+      let isExtglob = false;
+      let isGlobstar = false;
+      let braceEscaped = false;
+      let backslashes = false;
+      let negated = false;
+      let negatedExtglob = false;
+      let finished = false;
+      let braces = 0;
+      let prev;
+      let code;
+      let token = { value: "", depth: 0, isGlob: false };
+      const eos = () => index >= length;
+      const peek = () => str.charCodeAt(index + 1);
+      const advance = () => {
+        prev = code;
+        return str.charCodeAt(++index);
+      };
+      while (index < length) {
+        code = advance();
+        let next;
+        if (code === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          code = advance();
+          if (code === CHAR_LEFT_CURLY_BRACE) {
+            braceEscaped = true;
+          }
+          continue;
+        }
+        if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+          braces++;
+          while (eos() !== true && (code = advance())) {
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              advance();
+              continue;
+            }
+            if (code === CHAR_LEFT_CURLY_BRACE) {
+              braces++;
+              continue;
+            }
+            if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+              isBrace = token.isBrace = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (braceEscaped !== true && code === CHAR_COMMA) {
+              isBrace = token.isBrace = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_RIGHT_CURLY_BRACE) {
+              braces--;
+              if (braces === 0) {
+                braceEscaped = false;
+                isBrace = token.isBrace = true;
+                finished = true;
+                break;
+              }
+            }
+          }
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_FORWARD_SLASH) {
+          slashes.push(index);
+          tokens.push(token);
+          token = { value: "", depth: 0, isGlob: false };
+          if (finished === true) continue;
+          if (prev === CHAR_DOT && index === start + 1) {
+            start += 2;
+            continue;
+          }
+          lastIndex = index + 1;
+          continue;
+        }
+        if (opts.noext !== true) {
+          const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+          if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+            isGlob = token.isGlob = true;
+            isExtglob = token.isExtglob = true;
+            finished = true;
+            if (code === CHAR_EXCLAMATION_MARK && index === start) {
+              negatedExtglob = true;
+            }
+            if (scanToEnd === true) {
+              while (eos() !== true && (code = advance())) {
+                if (code === CHAR_BACKWARD_SLASH) {
+                  backslashes = token.backslashes = true;
+                  code = advance();
+                  continue;
+                }
+                if (code === CHAR_RIGHT_PARENTHESES) {
+                  isGlob = token.isGlob = true;
+                  finished = true;
+                  break;
+                }
+              }
+              continue;
+            }
+            break;
+          }
+        }
+        if (code === CHAR_ASTERISK) {
+          if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_QUESTION_MARK) {
+          isGlob = token.isGlob = true;
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_LEFT_SQUARE_BRACKET) {
+          while (eos() !== true && (next = advance())) {
+            if (next === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              advance();
+              continue;
+            }
+            if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+              isBracket = token.isBracket = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              break;
+            }
+          }
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+          negated = token.negated = true;
+          start++;
+          continue;
+        }
+        if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+          isGlob = token.isGlob = true;
+          if (scanToEnd === true) {
+            while (eos() !== true && (code = advance())) {
+              if (code === CHAR_LEFT_PARENTHESES) {
+                backslashes = token.backslashes = true;
+                code = advance();
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES) {
+                finished = true;
+                break;
+              }
+            }
+            continue;
+          }
+          break;
+        }
+        if (isGlob === true) {
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+      }
+      if (opts.noext === true) {
+        isExtglob = false;
+        isGlob = false;
+      }
+      let base = str;
+      let prefix = "";
+      let glob = "";
+      if (start > 0) {
+        prefix = str.slice(0, start);
+        str = str.slice(start);
+        lastIndex -= start;
+      }
+      if (base && isGlob === true && lastIndex > 0) {
+        base = str.slice(0, lastIndex);
+        glob = str.slice(lastIndex);
+      } else if (isGlob === true) {
+        base = "";
+        glob = str;
+      } else {
+        base = str;
+      }
+      if (base && base !== "" && base !== "/" && base !== str) {
+        if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+          base = base.slice(0, -1);
+        }
+      }
+      if (opts.unescape === true) {
+        if (glob) glob = utils.removeBackslashes(glob);
+        if (base && backslashes === true) {
+          base = utils.removeBackslashes(base);
+        }
+      }
+      const state = {
+        prefix,
+        input,
+        start,
+        base,
+        glob,
+        isBrace,
+        isBracket,
+        isGlob,
+        isExtglob,
+        isGlobstar,
+        negated,
+        negatedExtglob
+      };
+      if (opts.tokens === true) {
+        state.maxDepth = 0;
+        if (!isPathSeparator(code)) {
+          tokens.push(token);
+        }
+        state.tokens = tokens;
+      }
+      if (opts.parts === true || opts.tokens === true) {
+        let prevIndex;
+        for (let idx = 0; idx < slashes.length; idx++) {
+          const n = prevIndex ? prevIndex + 1 : start;
+          const i = slashes[idx];
+          const value = input.slice(n, i);
+          if (opts.tokens) {
+            if (idx === 0 && start !== 0) {
+              tokens[idx].isPrefix = true;
+              tokens[idx].value = prefix;
+            } else {
+              tokens[idx].value = value;
+            }
+            depth(tokens[idx]);
+            state.maxDepth += tokens[idx].depth;
+          }
+          if (idx !== 0 || value !== "") {
+            parts.push(value);
+          }
+          prevIndex = i;
+        }
+        if (prevIndex && prevIndex + 1 < input.length) {
+          const value = input.slice(prevIndex + 1);
+          parts.push(value);
+          if (opts.tokens) {
+            tokens[tokens.length - 1].value = value;
+            depth(tokens[tokens.length - 1]);
+            state.maxDepth += tokens[tokens.length - 1].depth;
+          }
+        }
+        state.slashes = slashes;
+        state.parts = parts;
+      }
+      return state;
+    };
+    module.exports = scan;
+  }
+});
+
+// ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/parse.js"(exports, module) {
+    "use strict";
+    var constants = require_constants();
+    var utils = require_utils();
+    var {
+      MAX_LENGTH,
+      POSIX_REGEX_SOURCE,
+      REGEX_NON_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_BACKREF,
+      REPLACEMENTS
+    } = constants;
+    var expandRange = (args, options) => {
+      if (typeof options.expandRange === "function") {
+        return options.expandRange(...args, options);
+      }
+      args.sort();
+      const value = `[${args.join("-")}]`;
+      try {
+        new RegExp(value);
+      } catch (ex) {
+        return args.map((v) => utils.escapeRegex(v)).join("..");
+      }
+      return value;
+    };
+    var syntaxError = (type, char) => {
+      return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+    };
+    var splitTopLevel = (input) => {
+      const parts = [];
+      let bracket = 0;
+      let paren = 0;
+      let quote = 0;
+      let value = "";
+      let escaped = false;
+      for (const ch of input) {
+        if (escaped === true) {
+          value += ch;
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          value += ch;
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          value += ch;
+          continue;
+        }
+        if (quote === 0) {
+          if (ch === "[") {
+            bracket++;
+          } else if (ch === "]" && bracket > 0) {
+            bracket--;
+          } else if (bracket === 0) {
+            if (ch === "(") {
+              paren++;
+            } else if (ch === ")" && paren > 0) {
+              paren--;
+            } else if (ch === "|" && paren === 0) {
+              parts.push(value);
+              value = "";
+              continue;
+            }
+          }
+        }
+        value += ch;
+      }
+      parts.push(value);
+      return parts;
+    };
+    var isPlainBranch = (branch) => {
+      let escaped = false;
+      for (const ch of branch) {
+        if (escaped === true) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (/[?*+@!()[\]{}]/.test(ch)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var normalizeSimpleBranch = (branch) => {
+      let value = branch.trim();
+      let changed = true;
+      while (changed === true) {
+        changed = false;
+        if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+          value = value.slice(2, -1);
+          changed = true;
+        }
+      }
+      if (!isPlainBranch(value)) {
+        return;
+      }
+      return value.replace(/\\(.)/g, "$1");
+    };
+    var hasRepeatedCharPrefixOverlap = (branches) => {
+      const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+      for (let i = 0; i < values.length; i++) {
+        for (let j = i + 1; j < values.length; j++) {
+          const a = values[i];
+          const b = values[j];
+          const char = a[0];
+          if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
+            continue;
+          }
+          if (a === b || a.startsWith(b) || b.startsWith(a)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    };
+    var parseRepeatedExtglob = (pattern, requireEnd = true) => {
+      if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
+        return;
+      }
+      let bracket = 0;
+      let paren = 0;
+      let quote = 0;
+      let escaped = false;
+      for (let i = 1; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (escaped === true) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          continue;
+        }
+        if (quote === 1) {
+          continue;
+        }
+        if (ch === "[") {
+          bracket++;
+          continue;
+        }
+        if (ch === "]" && bracket > 0) {
+          bracket--;
+          continue;
+        }
+        if (bracket > 0) {
+          continue;
+        }
+        if (ch === "(") {
+          paren++;
+          continue;
+        }
+        if (ch === ")") {
+          paren--;
+          if (paren === 0) {
+            if (requireEnd === true && i !== pattern.length - 1) {
+              return;
+            }
+            return {
+              type: pattern[0],
+              body: pattern.slice(2, i),
+              end: i
+            };
+          }
+        }
+      }
+    };
+    var getStarExtglobSequenceOutput = (pattern) => {
+      let index = 0;
+      const chars = [];
+      while (index < pattern.length) {
+        const match = parseRepeatedExtglob(pattern.slice(index), false);
+        if (!match || match.type !== "*") {
+          return;
+        }
+        const branches = splitTopLevel(match.body).map((branch2) => branch2.trim());
+        if (branches.length !== 1) {
+          return;
+        }
+        const branch = normalizeSimpleBranch(branches[0]);
+        if (!branch || branch.length !== 1) {
+          return;
+        }
+        chars.push(branch);
+        index += match.end + 1;
+      }
+      if (chars.length < 1) {
+        return;
+      }
+      const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
+      return `${source}*`;
+    };
+    var repeatedExtglobRecursion = (pattern) => {
+      let depth = 0;
+      let value = pattern.trim();
+      let match = parseRepeatedExtglob(value);
+      while (match) {
+        depth++;
+        value = match.body.trim();
+        match = parseRepeatedExtglob(value);
+      }
+      return depth;
+    };
+    var analyzeRepeatedExtglob = (body, options) => {
+      if (options.maxExtglobRecursion === false) {
+        return { risky: false };
+      }
+      const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+      const branches = splitTopLevel(body).map((branch) => branch.trim());
+      if (branches.length > 1) {
+        if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
+          return { risky: true };
+        }
+      }
+      for (const branch of branches) {
+        const safeOutput = getStarExtglobSequenceOutput(branch);
+        if (safeOutput) {
+          return { risky: true, safeOutput };
+        }
+        if (repeatedExtglobRecursion(branch) > max) {
+          return { risky: true };
+        }
+      }
+      return { risky: false };
+    };
+    var parse = (input, options) => {
+      if (typeof input !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      input = REPLACEMENTS[input] || input;
+      const opts = { ...options };
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      let len = input.length;
+      if (len > max) {
+        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+      }
+      const bos = { type: "bos", value: "", output: opts.prepend || "" };
+      const tokens = [bos];
+      const capture = opts.capture ? "" : "?:";
+      const PLATFORM_CHARS = constants.globChars(opts.windows);
+      const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+      const {
+        DOT_LITERAL,
+        PLUS_LITERAL,
+        SLASH_LITERAL,
+        ONE_CHAR,
+        DOTS_SLASH,
+        NO_DOT,
+        NO_DOT_SLASH,
+        NO_DOTS_SLASH,
+        QMARK,
+        QMARK_NO_DOT,
+        STAR,
+        START_ANCHOR
+      } = PLATFORM_CHARS;
+      const globstar = (opts2) => {
+        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+      };
+      const nodot = opts.dot ? "" : NO_DOT;
+      const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+      let star = opts.bash === true ? globstar(opts) : STAR;
+      if (opts.capture) {
+        star = `(${star})`;
+      }
+      if (typeof opts.noext === "boolean") {
+        opts.noextglob = opts.noext;
+      }
+      const state = {
+        input,
+        index: -1,
+        start: 0,
+        dot: opts.dot === true,
+        consumed: "",
+        output: "",
+        prefix: "",
+        backtrack: false,
+        negated: false,
+        brackets: 0,
+        braces: 0,
+        parens: 0,
+        quotes: 0,
+        globstar: false,
+        tokens
+      };
+      input = utils.removePrefix(input, state);
+      len = input.length;
+      const extglobs = [];
+      const braces = [];
+      const stack = [];
+      let prev = bos;
+      let value;
+      const eos = () => state.index === len - 1;
+      const peek = state.peek = (n = 1) => input[state.index + n];
+      const advance = state.advance = () => input[++state.index] || "";
+      const remaining = () => input.slice(state.index + 1);
+      const consume = (value2 = "", num = 0) => {
+        state.consumed += value2;
+        state.index += num;
+      };
+      const append = (token) => {
+        state.output += token.output != null ? token.output : token.value;
+        consume(token.value);
+      };
+      const negate = () => {
+        let count = 1;
+        while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+          advance();
+          state.start++;
+          count++;
+        }
+        if (count % 2 === 0) {
+          return false;
+        }
+        state.negated = true;
+        state.start++;
+        return true;
+      };
+      const increment = (type) => {
+        state[type]++;
+        stack.push(type);
+      };
+      const decrement = (type) => {
+        state[type]--;
+        stack.pop();
+      };
+      const push = (tok) => {
+        if (prev.type === "globstar") {
+          const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+          const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+          if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+            state.output = state.output.slice(0, -prev.output.length);
+            prev.type = "star";
+            prev.value = "*";
+            prev.output = star;
+            state.output += prev.output;
+          }
+        }
+        if (extglobs.length && tok.type !== "paren") {
+          extglobs[extglobs.length - 1].inner += tok.value;
+        }
+        if (tok.value || tok.output) append(tok);
+        if (prev && prev.type === "text" && tok.type === "text") {
+          prev.output = (prev.output || prev.value) + tok.value;
+          prev.value += tok.value;
+          return;
+        }
+        tok.prev = prev;
+        tokens.push(tok);
+        prev = tok;
+      };
+      const extglobOpen = (type, value2) => {
+        const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
+        token.prev = prev;
+        token.parens = state.parens;
+        token.output = state.output;
+        token.startIndex = state.index;
+        token.tokensIndex = tokens.length;
+        const output = (opts.capture ? "(" : "") + token.open;
+        increment("parens");
+        push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+        push({ type: "paren", extglob: true, value: advance(), output });
+        extglobs.push(token);
+      };
+      const extglobClose = (token) => {
+        const literal = input.slice(token.startIndex, state.index + 1);
+        const body = input.slice(token.startIndex + 2, state.index);
+        const analysis = analyzeRepeatedExtglob(body, opts);
+        if ((token.type === "plus" || token.type === "star") && analysis.risky) {
+          const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
+          const open = tokens[token.tokensIndex];
+          open.type = "text";
+          open.value = literal;
+          open.output = safeOutput || utils.escapeRegex(literal);
+          for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
+            tokens[i].value = "";
+            tokens[i].output = "";
+            delete tokens[i].suffix;
+          }
+          state.output = token.output + open.output;
+          state.backtrack = true;
+          push({ type: "paren", extglob: true, value, output: "" });
+          decrement("parens");
+          return;
+        }
+        let output = token.close + (opts.capture ? ")" : "");
+        let rest;
+        if (token.type === "negate") {
+          let extglobStar = star;
+          if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+            extglobStar = globstar(opts);
+          }
+          if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+            output = token.close = `)$))${extglobStar}`;
+          }
+          if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+            const expression = parse(rest, { ...options, fastpaths: false }).output;
+            output = token.close = `)${expression})${extglobStar})`;
+          }
+          if (token.prev.type === "bos") {
+            state.negatedExtglob = true;
+          }
+        }
+        push({ type: "paren", extglob: true, value, output });
+        decrement("parens");
+      };
+      if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+        let backslashes = false;
+        let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+          if (first === "\\") {
+            backslashes = true;
+            return m;
+          }
+          if (first === "?") {
+            if (esc) {
+              return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+            }
+            if (index === 0) {
+              return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+            }
+            return QMARK.repeat(chars.length);
+          }
+          if (first === ".") {
+            return DOT_LITERAL.repeat(chars.length);
+          }
+          if (first === "*") {
+            if (esc) {
+              return esc + first + (rest ? star : "");
+            }
+            return star;
+          }
+          return esc ? m : `\\${m}`;
+        });
+        if (backslashes === true) {
+          if (opts.unescape === true) {
+            output = output.replace(/\\/g, "");
+          } else {
+            output = output.replace(/\\+/g, (m) => {
+              return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+            });
+          }
+        }
+        if (output === input && opts.contains === true) {
+          state.output = input;
+          return state;
+        }
+        state.output = utils.wrapOutput(output, state, options);
+        return state;
+      }
+      while (!eos()) {
+        value = advance();
+        if (value === "\0") {
+          continue;
+        }
+        if (value === "\\") {
+          const next = peek();
+          if (next === "/" && opts.bash !== true) {
+            continue;
+          }
+          if (next === "." || next === ";") {
+            continue;
+          }
+          if (!next) {
+            value += "\\";
+            push({ type: "text", value });
+            continue;
+          }
+          const match = /^\\+/.exec(remaining());
+          let slashes = 0;
+          if (match && match[0].length > 2) {
+            slashes = match[0].length;
+            state.index += slashes;
+            if (slashes % 2 !== 0) {
+              value += "\\";
+            }
+          }
+          if (opts.unescape === true) {
+            value = advance();
+          } else {
+            value += advance();
+          }
+          if (state.brackets === 0) {
+            push({ type: "text", value });
+            continue;
+          }
+        }
+        if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+          if (opts.posix !== false && value === ":") {
+            const inner = prev.value.slice(1);
+            if (inner.includes("[")) {
+              prev.posix = true;
+              if (inner.includes(":")) {
+                const idx = prev.value.lastIndexOf("[");
+                const pre = prev.value.slice(0, idx);
+                const rest2 = prev.value.slice(idx + 2);
+                const posix = POSIX_REGEX_SOURCE[rest2];
+                if (posix) {
+                  prev.value = pre + posix;
+                  state.backtrack = true;
+                  advance();
+                  if (!bos.output && tokens.indexOf(prev) === 1) {
+                    bos.output = ONE_CHAR;
+                  }
+                  continue;
+                }
+              }
+            }
+          }
+          if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+            value = `\\${value}`;
+          }
+          if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+            value = `\\${value}`;
+          }
+          if (opts.posix === true && value === "!" && prev.value === "[") {
+            value = "^";
+          }
+          prev.value += value;
+          append({ value });
+          continue;
+        }
+        if (state.quotes === 1 && value !== '"') {
+          value = utils.escapeRegex(value);
+          prev.value += value;
+          append({ value });
+          continue;
+        }
+        if (value === '"') {
+          state.quotes = state.quotes === 1 ? 0 : 1;
+          if (opts.keepQuotes === true) {
+            push({ type: "text", value });
+          }
+          continue;
+        }
+        if (value === "(") {
+          increment("parens");
+          push({ type: "paren", value });
+          continue;
+        }
+        if (value === ")") {
+          if (state.parens === 0 && opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("opening", "("));
+          }
+          const extglob = extglobs[extglobs.length - 1];
+          if (extglob && state.parens === extglob.parens + 1) {
+            extglobClose(extglobs.pop());
+            continue;
+          }
+          push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+          decrement("parens");
+          continue;
+        }
+        if (value === "[") {
+          if (opts.nobracket === true || !remaining().includes("]")) {
+            if (opts.nobracket !== true && opts.strictBrackets === true) {
+              throw new SyntaxError(syntaxError("closing", "]"));
+            }
+            value = `\\${value}`;
+          } else {
+            increment("brackets");
+          }
+          push({ type: "bracket", value });
+          continue;
+        }
+        if (value === "]") {
+          if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+            push({ type: "text", value, output: `\\${value}` });
+            continue;
+          }
+          if (state.brackets === 0) {
+            if (opts.strictBrackets === true) {
+              throw new SyntaxError(syntaxError("opening", "["));
+            }
+            push({ type: "text", value, output: `\\${value}` });
+            continue;
+          }
+          decrement("brackets");
+          const prevValue = prev.value.slice(1);
+          if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+            value = `/${value}`;
+          }
+          prev.value += value;
+          append({ value });
+          if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+            continue;
+          }
+          const escaped = utils.escapeRegex(prev.value);
+          state.output = state.output.slice(0, -prev.value.length);
+          if (opts.literalBrackets === true) {
+            state.output += escaped;
+            prev.value = escaped;
+            continue;
+          }
+          prev.value = `(${capture}${escaped}|${prev.value})`;
+          state.output += prev.value;
+          continue;
+        }
+        if (value === "{" && opts.nobrace !== true) {
+          increment("braces");
+          const open = {
+            type: "brace",
+            value,
+            output: "(",
+            outputIndex: state.output.length,
+            tokensIndex: state.tokens.length
+          };
+          braces.push(open);
+          push(open);
+          continue;
+        }
+        if (value === "}") {
+          const brace = braces[braces.length - 1];
+          if (opts.nobrace === true || !brace) {
+            push({ type: "text", value, output: value });
+            continue;
+          }
+          let output = ")";
+          if (brace.dots === true) {
+            const arr = tokens.slice();
+            const range = [];
+            for (let i = arr.length - 1; i >= 0; i--) {
+              tokens.pop();
+              if (arr[i].type === "brace") {
+                break;
+              }
+              if (arr[i].type !== "dots") {
+                range.unshift(arr[i].value);
+              }
+            }
+            output = expandRange(range, opts);
+            state.backtrack = true;
+          }
+          if (brace.comma !== true && brace.dots !== true) {
+            const out = state.output.slice(0, brace.outputIndex);
+            const toks = state.tokens.slice(brace.tokensIndex);
+            brace.value = brace.output = "\\{";
+            value = output = "\\}";
+            state.output = out;
+            for (const t of toks) {
+              state.output += t.output || t.value;
+            }
+          }
+          push({ type: "brace", value, output });
+          decrement("braces");
+          braces.pop();
+          continue;
+        }
+        if (value === "|") {
+          if (extglobs.length > 0) {
+            extglobs[extglobs.length - 1].conditions++;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (value === ",") {
+          let output = value;
+          const brace = braces[braces.length - 1];
+          if (brace && stack[stack.length - 1] === "braces") {
+            brace.comma = true;
+            output = "|";
+          }
+          push({ type: "comma", value, output });
+          continue;
+        }
+        if (value === "/") {
+          if (prev.type === "dot" && state.index === state.start + 1) {
+            state.start = state.index + 1;
+            state.consumed = "";
+            state.output = "";
+            tokens.pop();
+            prev = bos;
+            continue;
+          }
+          push({ type: "slash", value, output: SLASH_LITERAL });
+          continue;
+        }
+        if (value === ".") {
+          if (state.braces > 0 && prev.type === "dot") {
+            if (prev.value === ".") prev.output = DOT_LITERAL;
+            const brace = braces[braces.length - 1];
+            prev.type = "dots";
+            prev.output += value;
+            prev.value += value;
+            brace.dots = true;
+            continue;
+          }
+          if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+            push({ type: "text", value, output: DOT_LITERAL });
+            continue;
+          }
+          push({ type: "dot", value, output: DOT_LITERAL });
+          continue;
+        }
+        if (value === "?") {
+          const isGroup = prev && prev.value === "(";
+          if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            extglobOpen("qmark", value);
+            continue;
+          }
+          if (prev && prev.type === "paren") {
+            const next = peek();
+            let output = value;
+            if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+              output = `\\${value}`;
+            }
+            push({ type: "text", value, output });
+            continue;
+          }
+          if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+            push({ type: "qmark", value, output: QMARK_NO_DOT });
+            continue;
+          }
+          push({ type: "qmark", value, output: QMARK });
+          continue;
+        }
+        if (value === "!") {
+          if (opts.noextglob !== true && peek() === "(") {
+            if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+              extglobOpen("negate", value);
+              continue;
+            }
+          }
+          if (opts.nonegate !== true && state.index === 0) {
+            negate();
+            continue;
+          }
+        }
+        if (value === "+") {
+          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            extglobOpen("plus", value);
+            continue;
+          }
+          if (prev && prev.value === "(" || opts.regex === false) {
+            push({ type: "plus", value, output: PLUS_LITERAL });
+            continue;
+          }
+          if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+            push({ type: "plus", value });
+            continue;
+          }
+          push({ type: "plus", value: PLUS_LITERAL });
+          continue;
+        }
+        if (value === "@") {
+          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            push({ type: "at", extglob: true, value, output: "" });
+            continue;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (value !== "*") {
+          if (value === "$" || value === "^") {
+            value = `\\${value}`;
+          }
+          const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+          if (match) {
+            value += match[0];
+            state.index += match[0].length;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (prev && (prev.type === "globstar" || prev.star === true)) {
+          prev.type = "star";
+          prev.star = true;
+          prev.value += value;
+          prev.output = star;
+          state.backtrack = true;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        let rest = remaining();
+        if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+          extglobOpen("star", value);
+          continue;
+        }
+        if (prev.type === "star") {
+          if (opts.noglobstar === true) {
+            consume(value);
+            continue;
+          }
+          const prior = prev.prev;
+          const before = prior.prev;
+          const isStart = prior.type === "slash" || prior.type === "bos";
+          const afterStar = before && (before.type === "star" || before.type === "globstar");
+          if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+            push({ type: "star", value, output: "" });
+            continue;
+          }
+          const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+          const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+          if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+            push({ type: "star", value, output: "" });
+            continue;
+          }
+          while (rest.slice(0, 3) === "/**") {
+            const after = input[state.index + 4];
+            if (after && after !== "/") {
+              break;
+            }
+            rest = rest.slice(3);
+            consume("/**", 3);
+          }
+          if (prior.type === "bos" && eos()) {
+            prev.type = "globstar";
+            prev.value += value;
+            prev.output = globstar(opts);
+            state.output = prev.output;
+            state.globstar = true;
+            consume(value);
+            continue;
+          }
+          if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            prior.output = `(?:${prior.output}`;
+            prev.type = "globstar";
+            prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+            prev.value += value;
+            state.globstar = true;
+            state.output += prior.output + prev.output;
+            consume(value);
+            continue;
+          }
+          if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+            const end = rest[1] !== void 0 ? "|$" : "";
+            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            prior.output = `(?:${prior.output}`;
+            prev.type = "globstar";
+            prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+            prev.value += value;
+            state.output += prior.output + prev.output;
+            state.globstar = true;
+            consume(value + advance());
+            push({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          if (prior.type === "bos" && rest[0] === "/") {
+            prev.type = "globstar";
+            prev.value += value;
+            prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+            state.output = prev.output;
+            state.globstar = true;
+            consume(value + advance());
+            push({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          state.output = state.output.slice(0, -prev.output.length);
+          prev.type = "globstar";
+          prev.output = globstar(opts);
+          prev.value += value;
+          state.output += prev.output;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        const token = { type: "star", value, output: star };
+        if (opts.bash === true) {
+          token.output = ".*?";
+          if (prev.type === "bos" || prev.type === "slash") {
+            token.output = nodot + token.output;
+          }
+          push(token);
+          continue;
+        }
+        if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+          token.output = value;
+          push(token);
+          continue;
+        }
+        if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+          if (prev.type === "dot") {
+            state.output += NO_DOT_SLASH;
+            prev.output += NO_DOT_SLASH;
+          } else if (opts.dot === true) {
+            state.output += NO_DOTS_SLASH;
+            prev.output += NO_DOTS_SLASH;
+          } else {
+            state.output += nodot;
+            prev.output += nodot;
+          }
+          if (peek() !== "*") {
+            state.output += ONE_CHAR;
+            prev.output += ONE_CHAR;
+          }
+        }
+        push(token);
+      }
+      while (state.brackets > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+        state.output = utils.escapeLast(state.output, "[");
+        decrement("brackets");
+      }
+      while (state.parens > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+        state.output = utils.escapeLast(state.output, "(");
+        decrement("parens");
+      }
+      while (state.braces > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+        state.output = utils.escapeLast(state.output, "{");
+        decrement("braces");
+      }
+      if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+        push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+      }
+      if (state.backtrack === true) {
+        state.output = "";
+        for (const token of state.tokens) {
+          state.output += token.output != null ? token.output : token.value;
+          if (token.suffix) {
+            state.output += token.suffix;
+          }
+        }
+      }
+      return state;
+    };
+    parse.fastpaths = (input, options) => {
+      const opts = { ...options };
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      const len = input.length;
+      if (len > max) {
+        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+      }
+      input = REPLACEMENTS[input] || input;
+      const {
+        DOT_LITERAL,
+        SLASH_LITERAL,
+        ONE_CHAR,
+        DOTS_SLASH,
+        NO_DOT,
+        NO_DOTS,
+        NO_DOTS_SLASH,
+        STAR,
+        START_ANCHOR
+      } = constants.globChars(opts.windows);
+      const nodot = opts.dot ? NO_DOTS : NO_DOT;
+      const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+      const capture = opts.capture ? "" : "?:";
+      const state = { negated: false, prefix: "" };
+      let star = opts.bash === true ? ".*?" : STAR;
+      if (opts.capture) {
+        star = `(${star})`;
+      }
+      const globstar = (opts2) => {
+        if (opts2.noglobstar === true) return star;
+        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+      };
+      const create = (str) => {
+        switch (str) {
+          case "*":
+            return `${nodot}${ONE_CHAR}${star}`;
+          case ".*":
+            return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "*.*":
+            return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "*/*":
+            return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+          case "**":
+            return nodot + globstar(opts);
+          case "**/*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+          case "**/*.*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "**/.*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+          default: {
+            const match = /^(.*?)\.(\w+)$/.exec(str);
+            if (!match) return;
+            const source2 = create(match[1]);
+            if (!source2) return;
+            return source2 + DOT_LITERAL + match[2];
+          }
+        }
+      };
+      const output = utils.removePrefix(input, state);
+      let source = create(output);
+      if (source && opts.strictSlashes !== true) {
+        source += `${SLASH_LITERAL}?`;
+      }
+      return source;
+    };
+    module.exports = parse;
+  }
+});
+
+// ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/picomatch.js
+var require_picomatch = __commonJS({
+  "../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/picomatch.js"(exports, module) {
+    "use strict";
+    var scan = require_scan();
+    var parse = require_parse();
+    var utils = require_utils();
+    var constants = require_constants();
+    var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+    var picomatch2 = (glob, options, returnState = false) => {
+      if (Array.isArray(glob)) {
+        const fns = glob.map((input) => picomatch2(input, options, returnState));
+        const arrayMatcher = (str) => {
+          for (const isMatch of fns) {
+            const state2 = isMatch(str);
+            if (state2) return state2;
+          }
+          return false;
+        };
+        return arrayMatcher;
+      }
+      const isState = isObject(glob) && glob.tokens && glob.input;
+      if (glob === "" || typeof glob !== "string" && !isState) {
+        throw new TypeError("Expected pattern to be a non-empty string");
+      }
+      const opts = options || {};
+      const posix = opts.windows;
+      const regex = isState ? picomatch2.compileRe(glob, options) : picomatch2.makeRe(glob, options, false, true);
+      const state = regex.state;
+      delete regex.state;
+      let isIgnored = () => false;
+      if (opts.ignore) {
+        const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+        isIgnored = picomatch2(opts.ignore, ignoreOpts, returnState);
+      }
+      const matcher = (input, returnObject = false) => {
+        const { isMatch, match, output } = picomatch2.test(input, regex, options, { glob, posix });
+        const result = { glob, state, regex, posix, input, output, match, isMatch };
+        if (typeof opts.onResult === "function") {
+          opts.onResult(result);
+        }
+        if (isMatch === false) {
+          result.isMatch = false;
+          return returnObject ? result : false;
+        }
+        if (isIgnored(input)) {
+          if (typeof opts.onIgnore === "function") {
+            opts.onIgnore(result);
+          }
+          result.isMatch = false;
+          return returnObject ? result : false;
+        }
+        if (typeof opts.onMatch === "function") {
+          opts.onMatch(result);
+        }
+        return returnObject ? result : true;
+      };
+      if (returnState) {
+        matcher.state = state;
+      }
+      return matcher;
+    };
+    picomatch2.test = (input, regex, options, { glob, posix } = {}) => {
+      if (typeof input !== "string") {
+        throw new TypeError("Expected input to be a string");
+      }
+      if (input === "") {
+        return { isMatch: false, output: "" };
+      }
+      const opts = options || {};
+      const format = opts.format || (posix ? utils.toPosixSlashes : null);
+      let match = input === glob;
+      let output = match && format ? format(input) : input;
+      if (match === false) {
+        output = format ? format(input) : input;
+        match = output === glob;
+      }
+      if (match === false || opts.capture === true) {
+        if (opts.matchBase === true || opts.basename === true) {
+          match = picomatch2.matchBase(input, regex, options, posix);
+        } else {
+          match = regex.exec(output);
+        }
+      }
+      return { isMatch: Boolean(match), match, output };
+    };
+    picomatch2.matchBase = (input, glob, options) => {
+      const regex = glob instanceof RegExp ? glob : picomatch2.makeRe(glob, options);
+      return regex.test(utils.basename(input));
+    };
+    picomatch2.isMatch = (str, patterns, options) => picomatch2(patterns, options)(str);
+    picomatch2.parse = (pattern, options) => {
+      if (Array.isArray(pattern)) return pattern.map((p) => picomatch2.parse(p, options));
+      return parse(pattern, { ...options, fastpaths: false });
+    };
+    picomatch2.scan = (input, options) => scan(input, options);
+    picomatch2.compileRe = (state, options, returnOutput = false, returnState = false) => {
+      if (returnOutput === true) {
+        return state.output;
+      }
+      const opts = options || {};
+      const prepend = opts.contains ? "" : "^";
+      const append = opts.contains ? "" : "$";
+      let source = `${prepend}(?:${state.output})${append}`;
+      if (state && state.negated === true) {
+        source = `^(?!${source}).*$`;
+      }
+      const regex = picomatch2.toRegex(source, options);
+      if (returnState === true) {
+        regex.state = state;
+      }
+      return regex;
+    };
+    picomatch2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+      if (!input || typeof input !== "string") {
+        throw new TypeError("Expected a non-empty string");
+      }
+      let parsed = { negated: false, fastpaths: true };
+      if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+        parsed.output = parse.fastpaths(input, options);
+      }
+      if (!parsed.output) {
+        parsed = parse(input, options);
+      }
+      return picomatch2.compileRe(parsed, options, returnOutput, returnState);
+    };
+    picomatch2.toRegex = (source, options) => {
+      try {
+        const opts = options || {};
+        return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+      } catch (err) {
+        if (options && options.debug === true) throw err;
+        return /$^/;
+      }
+    };
+    picomatch2.constants = constants;
+    module.exports = picomatch2;
+  }
+});
+
+// ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/index.js
+var require_picomatch2 = __commonJS({
+  "../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/index.js"(exports, module) {
+    "use strict";
+    var pico = require_picomatch();
+    var utils = require_utils();
+    function picomatch2(glob, options, returnState = false) {
+      if (options && (options.windows === null || options.windows === void 0)) {
+        options = { ...options, windows: utils.isWindows() };
+      }
+      return pico(glob, options, returnState);
+    }
+    Object.assign(picomatch2, pico);
+    module.exports = picomatch2;
+  }
+});
+
+// src/index.ts
+import { createHash as createHash2 } from "crypto";
+import { dirname, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { defineProject, defineWorkspace } from "vitest/config";
+
+// src/misuse-detector.ts
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+function parseSelectedProjectNames(argv) {
+  const selected = /* @__PURE__ */ new Set();
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--project" || arg === "-p") {
+      const next = argv[index + 1];
+      if (!next || next.startsWith("-")) {
+        continue;
+      }
+      selected.add(next);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--project=")) {
+      const value = arg.slice("--project=".length);
+      if (value.length > 0) {
+        selected.add(value);
+      }
+      continue;
+    }
+    if (arg.startsWith("-p=")) {
+      const value = arg.slice("-p=".length);
+      if (value.length > 0) {
+        selected.add(value);
+      }
+    }
+  }
+  return selected;
+}
+function shouldInstallMisuseDetector(projectName, argv = process.argv) {
+  const selectedProjects = parseSelectedProjectNames(argv);
+  if (selectedProjects.size === 0) {
+    return true;
+  }
+  return selectedProjects.has(projectName);
+}
+var WIRING_MARKER_DIR = join(tmpdir(), "archal-vitest-wiring");
+var wiringMarkers = /* @__PURE__ */ new Set();
+var wiringCheckInstalled = false;
+var REPORTER_MARKER_DIR = join(tmpdir(), "archal-vitest-reporter-lifecycle");
+var reporterMarkers = /* @__PURE__ */ new Set();
+var reporterCheckInstalled = false;
+var WORKSPACE_REPORTER_MARKER_DIR = join(tmpdir(), "archal-vitest-workspace-reporter");
+var workspaceReporterMarkers = /* @__PURE__ */ new Set();
+var workspaceReporterCheckInstalled = false;
+var reporterMarkerSeq = 0;
+var workspaceReporterMarkerSeq = 0;
+function installMisuseDetector(projectName) {
+  if (!shouldInstallMisuseDetector(projectName)) {
+    return "";
+  }
+  if (!existsSync(WIRING_MARKER_DIR)) {
+    try {
+      mkdirSync(WIRING_MARKER_DIR, { recursive: true, mode: 448 });
+    } catch {
+    }
+  }
+  const markerPath = join(
+    WIRING_MARKER_DIR,
+    `${process.pid}-${projectName}-${Date.now()}.marker`
+  );
+  try {
+    writeFileSync(markerPath, projectName, { mode: 384 });
+  } catch {
+  }
+  wiringMarkers.add(markerPath);
+  if (!wiringCheckInstalled) {
+    wiringCheckInstalled = true;
+    const warnIfUnwired = () => {
+      const survivors = [...wiringMarkers].filter((path) => existsSync(path));
+      if (survivors.length === 0) {
+        return;
+      }
+      process.stderr.write(
+        "\n\x1B[33m\x1B[1m\u2500\u2500\u2500 Archal Vitest: route-mode was not installed \u2500\u2500\u2500\n\x1B[0m\x1B[33mYour vitest config called archalVitestProject() but vitest didn't\nwire its setup files. Requests to hosted twin services probably\nleaked to real SaaS APIs.\n\nFix: either use withArchal() for a single vitest.config.ts:\n\n    import { defineConfig } from 'vitest/config';\n    import { withArchal } from 'archal/vitest';\n    export default defineConfig({\n      test: withArchal({}, { services: { ... } }),\n    });\n\nOr move archalVitestProject() into vitest.workspace.ts:\n\n    import { archalVitestProject } from 'archal/vitest';\n    export default [archalVitestProject({ services: { ... } })];\n\x1B[0m\n"
+      );
+      for (const survivor of survivors) {
+        try {
+          rmSync(survivor);
+        } catch {
+        }
+      }
+    };
+    process.on("beforeExit", warnIfUnwired);
+    process.on("SIGINT", () => {
+      warnIfUnwired();
+      setImmediate(() => process.exit(130));
+    });
+    process.on("SIGTERM", () => {
+      warnIfUnwired();
+      setImmediate(() => process.exit(143));
+    });
+  }
+  return markerPath;
+}
+function installReporterLifecycleCheck(projectName) {
+  if (!existsSync(REPORTER_MARKER_DIR)) {
+    try {
+      mkdirSync(REPORTER_MARKER_DIR, { recursive: true, mode: 448 });
+    } catch {
+    }
+  }
+  reporterMarkerSeq += 1;
+  const markerPath = join(
+    REPORTER_MARKER_DIR,
+    `${process.pid}-${projectName}-${Date.now()}-${reporterMarkerSeq}.marker`
+  );
+  try {
+    writeFileSync(markerPath, projectName, { mode: 384 });
+  } catch {
+  }
+  reporterMarkers.add(markerPath);
+  if (!reporterCheckInstalled) {
+    reporterCheckInstalled = true;
+    const warnIfReporterNeverFired = () => {
+      const survivors = [...reporterMarkers].filter((path) => existsSync(path));
+      if (survivors.length === 0) {
+        return;
+      }
+      process.stderr.write(
+        '\n\x1B[33m\x1B[1m\u2500\u2500\u2500 Archal Vitest: reporter end-of-run hook never fired \u2500\u2500\u2500\n\x1B[0m\x1B[33mArchalReporter.onInit ran, but its end-of-run hook (onFinished / onTestRunEnd) never fired, so dashboard upload was\nsilently skipped. Test results will NOT appear on /dashboard/tests.\n\nCommon causes:\n  - A Vitest upgrade changed per-project reporter lifecycle timing.\n  - A consumer config filtered out reporters (look for reporter overrides).\n  - The ArchalReporter threw before reaching collectAndReport.\n\nWhat to check:\n  1. Grep stderr for "[archal/reporter]" \u2014 if any line appears, the\n     reporter did run and this warning is a false positive.\n  2. If no [archal/reporter] lines exist at all, the reporter was\n     installed but never called. Verify your vitest config wires it\n     at the level Vitest actually honors (workspace root vs project).\n'
+      );
+      process.stderr.write("\x1B[0m\n");
+      for (const survivor of survivors) {
+        try {
+          rmSync(survivor);
+        } catch {
+        }
+      }
+    };
+    process.on("beforeExit", warnIfReporterNeverFired);
+    process.on("SIGINT", () => {
+      warnIfReporterNeverFired();
+      setImmediate(() => process.exit(130));
+    });
+    process.on("SIGTERM", () => {
+      warnIfReporterNeverFired();
+      setImmediate(() => process.exit(143));
+    });
+  }
+  return markerPath;
+}
+function installWorkspaceReporterCheck(projectNames) {
+  if (!existsSync(WORKSPACE_REPORTER_MARKER_DIR)) {
+    try {
+      mkdirSync(WORKSPACE_REPORTER_MARKER_DIR, { recursive: true, mode: 448 });
+    } catch {
+    }
+  }
+  workspaceReporterMarkerSeq += 1;
+  const normalizedNames = projectNames.length > 0 ? [...projectNames].sort().join(",") : "archal";
+  const markerPath = join(
+    WORKSPACE_REPORTER_MARKER_DIR,
+    `${process.pid}-${Date.now()}-${workspaceReporterMarkerSeq}.marker`
+  );
+  try {
+    writeFileSync(markerPath, normalizedNames, { mode: 384 });
+  } catch {
+  }
+  workspaceReporterMarkers.add(markerPath);
+  if (!workspaceReporterCheckInstalled) {
+    workspaceReporterCheckInstalled = true;
+    const warnIfWorkspaceReporterMissing = () => {
+      const survivors = [...workspaceReporterMarkers].filter((path) => existsSync(path));
+      if (survivors.length === 0) {
+        return;
+      }
+      process.stderr.write(
+        "\n\x1B[33m\x1B[1m\u2500\u2500\u2500 Archal Vitest: workspace projects ran without the dashboard reporter \u2500\u2500\u2500\n\x1B[0m\x1B[33marchalVitestWorkspace() configured hosted route-mode projects, but no\nroot-level Archal reporter was registered. Requests were routed to the\nhosted twins, yet /dashboard/tests upload was skipped.\n\nFix: add a root vitest.config.ts alongside vitest.workspace.ts:\n\n    import { defineConfig } from 'vitest/config';\n    import { archalVitestRootConfig } from 'archal/vitest';\n\n    export default defineConfig(archalVitestRootConfig());\n\nIf you do not need workspace mode, use withArchal() instead.\n\x1B[0m\n"
+      );
+      for (const survivor of survivors) {
+        try {
+          rmSync(survivor);
+        } catch {
+        }
+      }
+    };
+    process.on("beforeExit", warnIfWorkspaceReporterMissing);
+    process.on("SIGINT", () => {
+      warnIfWorkspaceReporterMissing();
+      setImmediate(() => process.exit(130));
+    });
+    process.on("SIGTERM", () => {
+      warnIfWorkspaceReporterMissing();
+      setImmediate(() => process.exit(143));
+    });
+  }
+  return markerPath;
+}
+function markReporterFired(markerPath) {
+  if (!markerPath) return;
+  reporterMarkers.delete(markerPath);
+  try {
+    rmSync(markerPath);
+  } catch {
+  }
+}
+function markWorkspaceReporterInstalled(markerPath) {
+  if (!markerPath) return;
+  workspaceReporterMarkers.delete(markerPath);
+  try {
+    rmSync(markerPath);
+  } catch {
+  }
+}
+
+// src/reporter.ts
+var import_picomatch = __toESM(require_picomatch2(), 1);
+var LOG_PREFIX = "[archal/reporter]";
+var STRICT_ENV = "ARCHAL_REPORTER_STRICT";
+var REPORTER_TOKEN_ENV = "ARCHAL_REPORTER_TOKEN";
+var REPORTER_AUTH_URL_ENV = "ARCHAL_REPORTER_AUTH_URL";
+var REPORTER_AUTH_BASE_URL_ENV = "ARCHAL_REPORTER_AUTH_BASE_URL";
+var REPORTER_BYPASS_SECRET_ENV = "ARCHAL_REPORTER_VERCEL_AUTOMATION_BYPASS_SECRET";
+var WORKSPACE_REPORTER_MARKER_ENV = "ARCHAL_VITEST_WORKSPACE_REPORTER_MARKER";
+function isStrict() {
+  return process.env[STRICT_ENV] === "1";
+}
+function warn(message) {
+  const line = `${LOG_PREFIX} ${message}
+`;
+  if (isStrict()) {
+    throw new Error(line.trimEnd());
+  }
+  process.stderr.write(line);
+}
+function info(message) {
+  process.stderr.write(`${LOG_PREFIX} ${message}
+`);
+}
+async function resolveReporterToken() {
+  const explicitReporterToken = process.env[REPORTER_TOKEN_ENV]?.trim();
+  if (explicitReporterToken) {
+    return explicitReporterToken;
+  }
+  try {
+    const { getCredentials } = await import("./src-JGHX6UKK.js");
+    const creds = getCredentials();
+    return creds?.token ?? process.env["ARCHAL_TOKEN"]?.trim();
+  } catch (authErr) {
+    warn(`auth resolution failed: ${authErr instanceof Error ? authErr.message : String(authErr)}`);
+    return void 0;
+  }
+}
+function resolveReporterBaseUrl() {
+  return (process.env[REPORTER_AUTH_URL_ENV]?.trim() || process.env[REPORTER_AUTH_BASE_URL_ENV]?.trim() || process.env["ARCHAL_AUTH_URL"]?.trim() || process.env["ARCHAL_AUTH_BASE_URL"]?.trim() || "https://www.archal.ai").replace(/\/+$/, "");
+}
+function buildReporterHeaders(token) {
+  const headers = new Headers({
+    "content-type": "application/json",
+    authorization: `Bearer ${token}`
+  });
+  const bypassSecret = process.env[REPORTER_BYPASS_SECRET_ENV]?.trim();
+  if (bypassSecret) {
+    headers.set("x-vercel-protection-bypass", bypassSecret);
+  }
+  return headers;
+}
+function normalizePathForMatch(path) {
+  return path.replaceAll("\\", "/");
+}
+function buildIncludeMatcher(pattern) {
+  const normalizedPattern = normalizePathForMatch(pattern).replace(/^\.?\//, "");
+  const patterns = normalizedPattern.startsWith("**/") ? [normalizedPattern] : [normalizedPattern, `**/${normalizedPattern}`];
+  const matchers = patterns.map((candidate) => (0, import_picomatch.default)(candidate, { dot: true }));
+  return (filePath) => {
+    const normalizedFile = normalizePathForMatch(filePath);
+    return matchers.some((matcher) => matcher(normalizedFile));
+  };
+}
+function readEncodedConfigFromTarget(target) {
+  const env = target?.config?.env;
+  return env?.[ARCHAL_VITEST_CONFIG_ENV];
+}
+function readProjectIncludePatterns(project) {
+  const config = project?.config;
+  const include = Array.isArray(config?.include) ? config.include : Array.isArray(config?.test?.include) ? config.test.include : [];
+  return include.filter((pattern) => typeof pattern === "string" && pattern.length > 0);
+}
+var ArchalReporter = class {
+  startTime = 0;
+  ctx = null;
+  lifecycleMarkerPath = "";
+  workspaceReporterMarkerPath = "";
+  projects = [];
+  onInit(ctx) {
+    this.startTime = Date.now();
+    this.ctx = ctx;
+    this.projects = this.resolveProjects();
+    const projectName = this.projects[0]?.config.projectName ?? "vitest";
+    this.lifecycleMarkerPath = installReporterLifecycleCheck(projectName);
+    this.workspaceReporterMarkerPath = process.env[WORKSPACE_REPORTER_MARKER_ENV] ?? "";
+    markWorkspaceReporterInstalled(this.workspaceReporterMarkerPath);
+    this.workspaceReporterMarkerPath = "";
+  }
+  decodeConfig(encoded) {
+    try {
+      return readArchalVitestConfig(encoded);
+    } catch {
+      return null;
+    }
+  }
+  buildProjectContext(config, includePatterns) {
+    return {
+      config,
+      includePatterns,
+      includeMatchers: includePatterns.map(buildIncludeMatcher)
+    };
+  }
+  resolveProjects() {
+    const resolvedProjects = (this.ctx?.projects ?? []).map((project) => {
+      const config = this.decodeConfig(readEncodedConfigFromTarget(project));
+      return config ? this.buildProjectContext(config, readProjectIncludePatterns(project)) : null;
+    }).filter((project) => project !== null);
+    if (resolvedProjects.length > 0) {
+      return resolvedProjects;
+    }
+    const rootConfig = this.decodeConfig(
+      readEncodedConfigFromTarget(this.ctx) ?? process.env[ARCHAL_VITEST_CONFIG_ENV]
+    );
+    return rootConfig ? [this.buildProjectContext(rootConfig, [])] : [];
+  }
+  /**
+   * vitest v2 calls onFinished with an array of File objects (from @vitest/runner).
+   * Each File extends Suite which has `tasks: Task[]`, and each Task has
+   * `.type` ('test' | 'suite'), `.name`, `.result?.state`, `.result?.duration`.
+   */
+  async onFinished(files, _errors) {
+    await this.collectAndReport(files ?? [], "v2");
+  }
+  /**
+   * vitest v4 calls onTestRunEnd (not onFinished) for custom reporters.
+   * The argument is an array of test modules, each with nested children.
+   */
+  async onTestRunEnd(testModules) {
+    await this.collectAndReport(testModules ?? [], "v4");
+  }
+  async collectAndReport(items, version) {
+    markReporterFired(this.lifecycleMarkerPath);
+    this.lifecycleMarkerPath = "";
+    if (this.projects.length === 0) {
+      this.projects = this.resolveProjects();
+    }
+    if (this.projects.length === 0) {
+      warn(
+        "Archal vitest config could not be decoded from the env \u2014 falling back to default project name. If this persists, make sure withArchal() or archalVitestProject() wraps your test config."
+      );
+      this.projects = [
+        this.buildProjectContext({
+          projectName: "vitest",
+          services: {}
+        }, [])
+      ];
+    }
+    if (items.length === 0) {
+      warn(`no ${version === "v2" ? "files" : "test modules"} received \u2014 nothing to upload.`);
+      return;
+    }
+    const results = version === "v2" ? this.collectV2Files(items) : this.collectV4Modules(items);
+    if (results.length === 0) {
+      warn("collected 0 tests after walking the test tree \u2014 nothing to upload.");
+      return;
+    }
+    const buckets = this.partitionResults(results);
+    if (buckets.length === 0) {
+      warn("collected tests but could not map them to an Archal Vitest project.");
+      return;
+    }
+    try {
+      for (const bucket of buckets) {
+        await this.sendResults(bucket.project, bucket.results);
+      }
+    } catch (err) {
+      warn(
+        `failed to upload test results: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  /**
+   * vitest v2: File extends Suite { tasks: Task[] }.
+   * Task.type is 'test' | 'suite' | 'custom'. Suite tasks recurse.
+   */
+  collectV2Files(files) {
+    const results = [];
+    const collectTasks = (tasks, fileName) => {
+      for (const task of tasks) {
+        if (task.type === "test" || task.type === "custom") {
+          const state = task.result?.state;
+          results.push({
+            name: task.name ?? "unnamed",
+            file: fileName,
+            status: state === "pass" ? "passed" : state === "fail" ? "failed" : "skipped",
+            duration: task.result?.duration ?? 0,
+            error: state === "fail" && task.result?.errors?.[0] ? task.result.errors[0].message ?? String(task.result.errors[0]) : void 0
+          });
+        } else if (task.type === "suite" && Array.isArray(task.tasks)) {
+          collectTasks(task.tasks, fileName);
+        }
+      }
+    };
+    for (const file of files) {
+      const f = file;
+      const fileName = f.filepath ?? f.name ?? "unknown";
+      if (Array.isArray(f.tasks)) {
+        collectTasks(f.tasks, fileName);
+      }
+    }
+    return results;
+  }
+  /**
+   * vitest v4: TestModule.children() → TestSuite[].children() → TestCase[]
+   * All accessors are methods (not properties) in v4.
+   */
+  collectV4Modules(testModules) {
+    const results = [];
+    const collectTests = (node, fileName) => {
+      const children = typeof node.children === "function" ? node.children() : node.children ?? [];
+      for (const child of children) {
+        if (child.type === "test") {
+          const result = typeof child.result === "function" ? child.result() : child.result;
+          const diag = typeof child.diagnostic === "function" ? child.diagnostic() : child.diagnostic;
+          const state = result?.state;
+          results.push({
+            name: child.name ?? "unnamed",
+            file: fileName,
+            status: state === "passed" ? "passed" : state === "failed" ? "failed" : "skipped",
+            duration: diag?.duration ?? result?.duration ?? 0,
+            error: state === "failed" && result?.errors?.[0] ? result.errors[0].message ?? String(result.errors[0]) : void 0
+          });
+        } else {
+          collectTests(child, fileName);
+        }
+      }
+    };
+    for (const mod of testModules) {
+      const m = mod;
+      const fileName = m.moduleId ?? m.id ?? "unknown";
+      collectTests(m, fileName);
+    }
+    return results;
+  }
+  resolveProjectForFile(fileName) {
+    const normalizedFile = normalizePathForMatch(fileName);
+    const onlyProject = this.projects[0] ?? null;
+    if (this.projects.length === 1) {
+      if (!onlyProject) {
+        return null;
+      }
+      if (onlyProject.includeMatchers.length === 0) {
+        return onlyProject;
+      }
+      return onlyProject.includeMatchers.some((matcher) => matcher(normalizedFile)) ? onlyProject : null;
+    }
+    let bestMatch = null;
+    let bestSpecificity = -1;
+    for (const project of this.projects) {
+      for (const [index, matcher] of project.includeMatchers.entries()) {
+        if (!matcher(normalizedFile)) {
+          continue;
+        }
+        const specificity = project.includePatterns[index]?.length ?? 0;
+        if (specificity > bestSpecificity) {
+          bestMatch = project;
+          bestSpecificity = specificity;
+        }
+      }
+    }
+    return bestMatch;
+  }
+  partitionResults(results) {
+    const buckets = /* @__PURE__ */ new Map();
+    for (const result of results) {
+      const project = this.resolveProjectForFile(result.file);
+      if (!project) {
+        warn(
+          `could not map ${result.file} to a Vitest project config \u2014 skipping reporter upload for that file.`
+        );
+        continue;
+      }
+      const key = project.config.projectName;
+      const bucket = buckets.get(key);
+      if (bucket) {
+        bucket.results.push(result);
+        continue;
+      }
+      buckets.set(key, {
+        project,
+        results: [result]
+      });
+    }
+    return [...buckets.values()];
+  }
+  async sendResults(project, results) {
+    const summary = {
+      total: results.length,
+      passed: results.filter((result) => result.status === "passed").length,
+      failed: results.filter((result) => result.status === "failed").length,
+      skipped: results.filter((result) => result.status === "skipped").length,
+      duration: Date.now() - this.startTime
+    };
+    const token = await resolveReporterToken();
+    if (!token) {
+      warn(
+        `skipped upload (no auth token found). Set ${REPORTER_TOKEN_ENV} or ARCHAL_TOKEN, or run \`archal login\` to populate ~/.archal/credentials.json.`
+      );
+      return;
+    }
+    const baseUrl = resolveReporterBaseUrl();
+    const sessionId = await this.readSessionId(project.config.sessionKey);
+    const payload = {
+      sessionId,
+      projectName: project.config.projectName,
+      services: Object.keys(project.config.services),
+      results,
+      summary,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const res = await fetch(`${baseUrl}/api/test-results`, {
+      method: "POST",
+      headers: buildReporterHeaders(token),
+      body: JSON.stringify(payload)
+    });
+    if (res.ok) {
+      info(
+        `uploaded ${summary.passed}/${summary.total} tests (project=${project.config.projectName}, sessionId=${sessionId ?? "none"})`
+      );
+      if (sessionId) {
+        try {
+          const syncRes = await fetch(`${baseUrl}/api/sessions/sync`, {
+            method: "POST",
+            headers: buildReporterHeaders(token),
+            body: JSON.stringify({
+              sessionId,
+              twinIds: Object.keys(project.config.services),
+              status: summary.failed > 0 ? "failed" : "ended",
+              endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              runtimeStartedAt: new Date(Date.now() - summary.duration).toISOString(),
+              source: "test",
+              evidence: {
+                reportSummary: {
+                  scenarioTitle: project.config.projectName,
+                  satisfactionScore: summary.total > 0 ? Math.round(summary.passed / summary.total * 100) : null,
+                  runCount: 1
+                }
+              }
+            })
+          });
+          if (!syncRes.ok) {
+            const body = await syncRes.text().catch(() => "");
+            warn(`session sync failed (${syncRes.status}): ${body.slice(0, 200)}`);
+          }
+        } catch (syncErr) {
+          warn(
+            `session sync failed: ${syncErr instanceof Error ? syncErr.message : String(syncErr)}`
+          );
+        }
+      } else {
+        warn(
+          "uploaded test results without a sessionId \u2014 the Activity row will not get scenarioTitle/endedAt/satisfactionScore. Usually this means the bootstrap session-id temp file was missing."
+        );
+      }
+    } else {
+      const body = await res.text().catch(() => "");
+      warn(`upload failed (${res.status}): ${body.slice(0, 200)}`);
+    }
+  }
+  async readSessionId(sessionKey) {
+    const { readFileSync: readFileSync2, readdirSync, statSync } = await import("fs");
+    const { dirname: dirname2, join: join2 } = await import("path");
+    if (sessionKey?.trim()) {
+      try {
+        const keyed = readFileSync2(
+          getSessionIdFilePath(sessionKey),
+          "utf-8"
+        ).trim();
+        if (keyed) return keyed;
+      } catch {
+      }
+    }
+    if (sessionKey?.trim()) {
+      return void 0;
+    }
+    try {
+      const sessionsDir = dirname2(getSessionIdFilePath("any"));
+      const entries = readdirSync(sessionsDir);
+      let newest;
+      for (const name of entries) {
+        if (!name.endsWith(".session-id")) continue;
+        const path = join2(sessionsDir, name);
+        try {
+          const st = statSync(path);
+          if (!newest || st.mtimeMs > newest.mtimeMs) {
+            newest = { path, mtimeMs: st.mtimeMs };
+          }
+        } catch {
+        }
+      }
+      if (newest) {
+        const content = readFileSync2(newest.path, "utf-8").trim();
+        if (content) return content;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+};
+
+// src/seed-files.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { extname, resolve } from "path";
+var MAX_SEED_FILE_BYTES = 256 * 1024;
+function classifySeed(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("/")) {
+    const ext = extname(trimmed).toLowerCase();
+    if (ext === ".json") return { type: "file", path: trimmed, format: "json" };
+    if (ext === ".md") return { type: "file", path: trimmed, format: "markdown" };
+    throw new Error(
+      `Seed file must be .json or .md, got "${ext || "(no extension)"}": ${trimmed}
+  .json \u2192 exact twin state loaded directly
+  .md   \u2192 plain-English description, Archal generates the state`
+    );
+  }
+  if (trimmed.endsWith(".json") || trimmed.endsWith(".md")) {
+    const ext = extname(trimmed).toLowerCase();
+    const format = ext === ".json" ? "json" : "markdown";
+    return { type: "file", path: trimmed, format };
+  }
+  return { type: "named", name: trimmed };
+}
+function readSeedFile(seedPath, serviceName) {
+  const resolved = resolve(seedPath);
+  if (!existsSync2(resolved)) {
+    throw new Error(
+      `Seed file not found for ${serviceName}: ${resolved}
+  Check the path relative to your project root.`
+    );
+  }
+  const content = readFileSync(resolved, "utf-8");
+  if (Buffer.byteLength(content, "utf-8") > MAX_SEED_FILE_BYTES) {
+    throw new Error(
+      `Seed file for ${serviceName} exceeds ${MAX_SEED_FILE_BYTES / 1024}KB limit: ${resolved}`
+    );
+  }
+  return content;
+}
+function computeStableSessionKey(projectName, services, fileSeedContents, fileSeedFormats) {
+  const sortedServices = Object.keys(services).sort().map((name) => {
+    const svc = services[name];
+    const fileContent = fileSeedContents?.[name];
+    const format = fileSeedFormats?.[name];
+    return {
+      name,
+      mode: svc?.mode,
+      seed: fileContent ? createHash("sha256").update(fileContent).digest("hex").slice(0, 16) : svc?.seed ?? null,
+      ...format ? { seedFormat: format } : {}
+    };
+  });
+  const payload = JSON.stringify({ projectName, services: sortedServices });
+  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
+}
+
+// src/webhooks.ts
+function normalizeMatcher(matcher, options) {
+  const merged = typeof matcher === "string" ? { eventType: matcher, ...options } : { ...options, ...matcher };
+  return {
+    ...merged,
+    timeout: merged.timeout ?? 2e3,
+    consume: merged.consume ?? false
+  };
+}
+function wrapDelivery(serviceName, raw) {
+  return {
+    service: serviceName,
+    eventType: raw.eventType,
+    payload: raw.payload,
+    body: raw.body,
+    headers: raw.headers,
+    url: raw.url,
+    queuedAt: raw.queuedAt
+  };
+}
+async function listArchalWebhooks(serviceName) {
+  const res = await fetchArchalTwin(serviceName, "/webhooks/pending");
+  if (res.status === 404) return [];
+  if (!res.ok) {
+    throw new Error(
+      `Failed to list pending webhooks for "${serviceName}": ${res.status} ${res.statusText}`
+    );
+  }
+  const raw = await res.json();
+  return raw.map((d) => wrapDelivery(serviceName, d));
+}
+async function clearArchalWebhooks(serviceName) {
+  const res = await fetchArchalTwin(serviceName, "/webhooks/pending", { method: "DELETE" });
+  if (res.status === 404) return;
+  if (!res.ok) {
+    throw new Error(
+      `Failed to clear pending webhooks for "${serviceName}": ${res.status} ${res.statusText}`
+    );
+  }
+}
+async function waitForArchalWebhook(serviceName, matcher, options = {}) {
+  const opts = normalizeMatcher(matcher, options);
+  const startTime = Date.now();
+  const deadline = startTime + opts.timeout;
+  let interval = 50;
+  let lastSeen = [];
+  while (true) {
+    const pending = await listArchalWebhooks(serviceName);
+    lastSeen = pending;
+    const match = pending.find(
+      (d) => (!opts.eventType || d.eventType === opts.eventType) && (!opts.where || opts.where(d))
+    );
+    if (match) {
+      if (opts.consume) await clearArchalWebhooks(serviceName);
+      return match;
+    }
+    if (Date.now() + interval >= deadline) break;
+    await new Promise((resolve3) => setTimeout(resolve3, interval));
+    interval = Math.min(250, Math.round(interval * 1.5));
+  }
+  const elapsed = Date.now() - startTime;
+  const lines = lastSeen.length === 0 ? "  (none)" : lastSeen.map((d) => `  - ${d.eventType} \u2192 ${d.url}`).join("\n");
+  const filterDesc = opts.eventType ? `eventType: "${opts.eventType}"${opts.where ? " + custom predicate" : ""}` : opts.where ? "custom predicate" : "(any event)";
+  throw new Error(
+    `waitForArchalWebhook timed out after ${elapsed}ms (limit: ${opts.timeout}ms).
+  service: ${serviceName}
+  matcher: ${filterDesc}
+  queued during wait (${lastSeen.length}):
+${lines}`
+  );
+}
+
+// src/index.ts
+var DEFAULT_ARCHAL_HOOK_TIMEOUT_MS = 12e4;
+var DEFAULT_ARCHAL_TEST_TIMEOUT_MS = 12e4;
+var DEFAULT_EXCLUDE_PATTERNS = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/cypress/**",
+  "**/.{idea,git,cache,output,temp}/**"
+];
+var ARCHAL_VITEST_WIRING_MARKER_ENV = "ARCHAL_VITEST_WIRING_MARKER";
+var ARCHAL_VITEST_WORKSPACE_REPORTER_MARKER_ENV = "ARCHAL_VITEST_WORKSPACE_REPORTER_MARKER";
+var ARCHAL_TEST_SANDBOX_ID_ENV = "ARCHAL_TEST_SANDBOX_ID";
+var SHARED_AUTH_SANDBOX_ID = `archal-vitest-${process.pid}-${createHash2("sha256").update(`${process.pid}-${process.cwd()}`).digest("hex").slice(0, 8)}`;
+var currentModuleFile = typeof __filename === "string" ? __filename : fileURLToPath(import.meta.url);
+var reporterEntryModule = resolve2(dirname(currentModuleFile), "../reporter-entry.js");
+function buildTestConfig(options, testOptions) {
+  assertSupportedArchalVitestServices(options.services);
+  const projectName = options.name ?? "archal";
+  const markerPath = installMisuseDetector(projectName);
+  const fileSeedContents = {};
+  const fileSeedFormats = {};
+  for (const [serviceName, svcConfig] of Object.entries(options.services)) {
+    if (!svcConfig?.seed) continue;
+    const classified = classifySeed(svcConfig.seed);
+    if (classified.type === "file") {
+      const content = readSeedFile(classified.path, serviceName);
+      fileSeedContents[serviceName] = content;
+      fileSeedFormats[serviceName] = classified.format;
+    }
+  }
+  const hasFileSeeds = Object.keys(fileSeedContents).length > 0;
+  const encodedConfig = encodeConfig({
+    projectName,
+    services: options.services,
+    sessionKey: computeStableSessionKey(
+      projectName,
+      options.services,
+      hasFileSeeds ? fileSeedContents : void 0,
+      hasFileSeeds ? fileSeedFormats : void 0
+    ),
+    runnerPid: process.pid,
+    ...hasFileSeeds ? { fileSeedContents, fileSeedFormats } : {}
+  });
+  const exclude = testOptions.exclude ?? DEFAULT_EXCLUDE_PATTERNS;
+  const built = {
+    name: projectName,
+    exclude,
+    hookTimeout: testOptions.hookTimeout ?? DEFAULT_ARCHAL_HOOK_TIMEOUT_MS,
+    testTimeout: testOptions.testTimeout ?? DEFAULT_ARCHAL_TEST_TIMEOUT_MS,
+    env: {
+      ...testOptions.env ?? {},
+      [ARCHAL_VITEST_CONFIG_ENV]: encodedConfig,
+      [ARCHAL_TEST_SANDBOX_ID_ENV]: testOptions.env?.[ARCHAL_TEST_SANDBOX_ID_ENV] ?? process.env[ARCHAL_TEST_SANDBOX_ID_ENV] ?? SHARED_AUTH_SANDBOX_ID
+    },
+    setupFiles: [
+      resolveRuntimeModule("./runtime/setup-files.js", ".js")
+    ]
+  };
+  if (testOptions.include !== void 0) built.include = testOptions.include;
+  if (testOptions.globals !== void 0) built.globals = testOptions.globals;
+  if (testOptions.pool !== void 0) built.pool = testOptions.pool;
+  if (markerPath.length > 0) built.env[ARCHAL_VITEST_WIRING_MARKER_ENV] = markerPath;
+  if (options.testIsolation === "serial") {
+    built.maxWorkers = 1;
+    built.fileParallelism = false;
+  }
+  if (testOptions.maxWorkers !== void 0) built.maxWorkers = testOptions.maxWorkers;
+  if (testOptions.fileParallelism !== void 0) built.fileParallelism = testOptions.fileParallelism;
+  return built;
+}
+function archalVitestProject(options, testOptions = {}) {
+  const test = buildTestConfig(options, testOptions);
+  return defineProject({ test });
+}
+function archalVitestConfig(options, testOptions = {}) {
+  const built = buildTestConfig(options, testOptions);
+  built.reporters = ["default", new ArchalReporter()];
+  return built;
+}
+function archalVitestRootConfig() {
+  return {
+    test: {
+      reporters: ["default", reporterEntryModule]
+    }
+  };
+}
+function withArchal(existingTest, options) {
+  const passthrough = {};
+  if (existingTest["include"] !== void 0) passthrough.include = existingTest["include"];
+  if (existingTest["exclude"] !== void 0) passthrough.exclude = existingTest["exclude"];
+  if (existingTest["env"] !== void 0) passthrough.env = existingTest["env"];
+  if (existingTest["globals"] !== void 0) passthrough.globals = existingTest["globals"];
+  if (existingTest["pool"] !== void 0) passthrough.pool = existingTest["pool"];
+  if (existingTest["hookTimeout"] !== void 0) passthrough.hookTimeout = existingTest["hookTimeout"];
+  if (existingTest["testTimeout"] !== void 0) passthrough.testTimeout = existingTest["testTimeout"];
+  if (existingTest["maxWorkers"] !== void 0) passthrough.maxWorkers = existingTest["maxWorkers"];
+  if (existingTest["fileParallelism"] !== void 0) passthrough.fileParallelism = existingTest["fileParallelism"];
+  const effectiveOptions = {
+    ...options,
+    name: options.name ?? (typeof existingTest["name"] === "string" ? existingTest["name"] : void 0)
+  };
+  const archal = buildTestConfig(effectiveOptions, passthrough);
+  const existingSetupFiles = toArray(existingTest["setupFiles"]);
+  const existingReporters = toArray(existingTest["reporters"]);
+  const hasArchalReporter = existingReporters.some(
+    (entry) => entry instanceof ArchalReporter
+  );
+  const mergedReporters = existingReporters.length > 0 ? hasArchalReporter ? existingReporters : [...existingReporters, new ArchalReporter()] : ["default", new ArchalReporter()];
+  return {
+    ...existingTest,
+    ...archal,
+    setupFiles: [...existingSetupFiles, ...archal.setupFiles],
+    reporters: mergedReporters
+  };
+}
+function toArray(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function archalVitestWorkspace(projects) {
+  const archalProjectNames = Array.isArray(projects) ? projects.flatMap((project) => {
+    if (!project || typeof project !== "object" || !("test" in project)) {
+      return [];
+    }
+    const test = project.test;
+    if (!test?.env?.[ARCHAL_VITEST_CONFIG_ENV]) {
+      return [];
+    }
+    return [test.name?.trim() || "archal"];
+  }) : [];
+  if (archalProjectNames.length > 0) {
+    process.env[ARCHAL_VITEST_WORKSPACE_REPORTER_MARKER_ENV] = installWorkspaceReporterCheck(archalProjectNames);
+  }
+  return defineWorkspace(projects);
+}
+export {
+  ArchalReporter,
+  archalVitestConfig,
+  archalVitestProject,
+  archalVitestRootConfig,
+  archalVitestWorkspace,
+  bootstrapArchalVitestRouting,
+  classifySeed,
+  clearArchalWebhooks,
+  getInstalledArchalVitestRuntime,
+  getInstalledArchalVitestSession,
+  listArchalWebhooks,
+  resetArchalTwins,
+  waitForArchalWebhook,
+  withArchal
+};