@blzsky/variant 0.2.0 → 0.3.0-canary.0

package/dist/{run-6PNH4QRA.js → run-44PKMOV5.js}

@@ -2,23 +2,24 @@ import {
   executeTarget,
   renderDryRunPlan,
   reportRunInsights
-} from "./chunk-4LLK2S4R.js";
-import "./chunk-LXKLCLL6.js";
-import "./chunk-ISRF5F3Q.js";
+} from "./chunk-7NC7AO75.js";
+import "./chunk-IHXJ72XA.js";
+import "./chunk-CWF6QXEW.js";
+import "./chunk-QRPI6TJE.js";
 import {
   createContext,
   toRunOptions
-} from "./chunk-SWPVR2DF.js";
+} from "./chunk-CN25SRKD.js";
 import "./chunk-V5CTGXMM.js";
-import "./chunk-RGD422OM.js";
-import "./chunk-YYGCSKIQ.js";
+import "./chunk-RJBFCURK.js";
 import "./chunk-GDSZFIHM.js";
-import "./chunk-MZZOE7L4.js";
+import "./chunk-DMDAJPFJ.js";
 import "./chunk-3E5LBU3O.js";
-import "./chunk-RVXUCJYA.js";
-import "./chunk-XUBWCTJZ.js";
+import "./chunk-YYGCSKIQ.js";
 import "./chunk-6J4XDG44.js";
-import "./chunk-V22IPJ7A.js";
+import "./chunk-EISTWXDW.js";
+import "./chunk-RSIOYQOQ.js";
+import "./chunk-ACTY42RE.js";
 
 // src/cli/commands/run.ts
 async function registerRunAction(taskName, opts = {}) {

package/dist/{symbol-graph-YYUEMZGR.js → symbol-graph-OB4AJCLW.js}

@@ -7,9 +7,9 @@ import {
   loadSymbolGraph,
   saveSymbolGraph,
   updateSymbolGraph
-} from "./chunk-VTJ67TT5.js";
-import "./chunk-RVXUCJYA.js";
-import "./chunk-O4LZKXNZ.js";
+} from "./chunk-NFFXYYM6.js";
+import "./chunk-DSQDMFQ6.js";
+import "./chunk-ACTY42RE.js";
 export {
   SYMBOL_GRAPH_VERSION,
   buildSymbolGraph,

package/dist/{tsconfig-paths-E3UEDGXZ.js → tsconfig-paths-SV3PULCW.js}

@@ -1,9 +1,11 @@
 import {
+  aliasesInScope,
   matchPathAlias,
   readPathAliases,
   toPathAliases
-} from "./chunk-KSHWC2XN.js";
+} from "./chunk-X3VVGTEV.js";
 export {
+  aliasesInScope,
   matchPathAlias,
   readPathAliases,
   toPathAliases

package/dist/vitest.cjs

@@ -0,0 +1,629 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/reporters/vitest.ts
+var vitest_exports = {};
+__export(vitest_exports, {
+  default: () => vitest_default,
+  variantReporter: () => variantReporter,
+  variantReporters: () => variantReporters
+});
+module.exports = __toCommonJS(vitest_exports);
+
+// node_modules/.pnpm/tsup@8.5.1_jiti@2.7.0_postc_52d3d9bdf3fa9c3b5dab7ba3f63ab42b/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/reporters/shadow.ts
+var import_node_child_process = require("child_process");
+var import_promises4 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+
+// src/core/history/impact-log.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var MAX_IMPACT_RECORDS = 1e3;
+var LOG_FILENAME = "impact.jsonl";
+var RECONCILIATION_FILENAME = "reconciliation.jsonl";
+function defaultHistoryDir(cwd) {
+  return import_node_path.default.join(cwd, ".variant", "history");
+}
+async function appendReconciliation(historyDir, reconciliation) {
+  return appendRecord(historyDir, RECONCILIATION_FILENAME, reconciliation);
+}
+async function appendRecord(historyDir, filename, record) {
+  try {
+    await (0, import_promises.mkdir)(historyDir, { recursive: true });
+    const file = import_node_path.default.join(historyDir, filename);
+    await (0, import_promises.appendFile)(file, `${JSON.stringify(record)}
+`);
+    const lines = (await (0, import_promises.readFile)(file, "utf8")).split("\n").filter((l) => l.trim() !== "");
+    if (lines.length > MAX_IMPACT_RECORDS) {
+      await (0, import_promises.writeFile)(file, `${lines.slice(-MAX_IMPACT_RECORDS).join("\n")}
+`);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readImpactPredictions(historyDir) {
+  return readRecords(historyDir, LOG_FILENAME);
+}
+async function readRecords(historyDir, filename) {
+  let raw;
+  try {
+    raw = await (0, import_promises.readFile)(import_node_path.default.join(historyDir, filename), "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/core/impact/verify.ts
+var import_node_fs = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+function realpathOrSelf(target) {
+  try {
+    return import_node_fs.realpathSync.native(target);
+  } catch {
+    return target;
+  }
+}
+function escapes(relative) {
+  return relative === ".." || relative.startsWith(`..${import_node_path2.default.sep}`) || import_node_path2.default.isAbsolute(relative);
+}
+function toRelativePosix(cwd, testPath, realpath) {
+  let relative = testPath;
+  if (import_node_path2.default.isAbsolute(testPath)) {
+    relative = import_node_path2.default.relative(cwd, testPath);
+    if (escapes(relative)) {
+      relative = import_node_path2.default.relative(realpath(cwd), realpath(testPath));
+    }
+  }
+  return relative.replace(/\\/g, "/");
+}
+function testRunFrom(cwd, results, realpath = realpathOrSelf) {
+  const ran = /* @__PURE__ */ new Set();
+  const failed = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    const file = toRelativePosix(cwd, result.file, realpath);
+    ran.add(file);
+    if (result.failed) failed.add(file);
+  }
+  return { ran: [...ran].sort(), failed: [...failed].sort() };
+}
+function reconcile(prediction, failedTests) {
+  const selected = new Set(prediction.affectedTests);
+  const caught = [];
+  const falseSkips = [];
+  for (const test of failedTests) {
+    if (prediction.selectAll || selected.has(test)) caught.push(test);
+    else falseSkips.push(test);
+  }
+  return {
+    caught,
+    falseSkips,
+    falseSkipRate: failedTests.length === 0 ? 0 : falseSkips.length / failedTests.length
+  };
+}
+function selectPrediction(predictions, headSha) {
+  if (headSha !== void 0) {
+    for (let i = predictions.length - 1; i >= 0; i--) {
+      const candidate = predictions[i];
+      if (candidate?.headSha === headSha) {
+        return { prediction: candidate, matchedBy: "head-sha" };
+      }
+    }
+    return null;
+  }
+  const latest = predictions[predictions.length - 1];
+  return latest === void 0 ? null : { prediction: latest, matchedBy: "most-recent" };
+}
+async function verifyRun(cwd, runs, options = {}) {
+  const historyDir = defaultHistoryDir(cwd);
+  const predictions = options.predictions ?? await readImpactPredictions(historyDir);
+  const match = selectPrediction(predictions, options.headSha);
+  if (match === null) return null;
+  const resolved = typeof runs === "function" ? await runs() : Array.isArray(runs) ? runs : [runs];
+  const failedTests = [
+    ...new Set(resolved.flatMap((run) => run.failed))
+  ].sort();
+  const ran = new Set(resolved.flatMap((run) => run.ran));
+  const selected = new Set(match.prediction.affectedTests);
+  const predictedRan = match.prediction.selectAll ? ran.size : [...ran].filter((test) => selected.has(test)).length;
+  const { caught, falseSkips, falseSkipRate } = reconcile(
+    match.prediction,
+    failedTests
+  );
+  const historyLogged = options.log === false ? true : await appendReconciliation(historyDir, {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    headSha: match.prediction.headSha,
+    baseRef: match.prediction.baseRef,
+    predictedTests: match.prediction.affectedTests.length,
+    totalTests: match.prediction.totalTests,
+    failedTests: failedTests.length,
+    caught: caught.length,
+    falseSkips: falseSkips.length,
+    confidence: match.prediction.confidence,
+    selectAll: match.prediction.selectAll,
+    ranTests: ran.size,
+    predictedRan
+  });
+  return {
+    prediction: match.prediction,
+    matchedBy: match.matchedBy,
+    failedTests,
+    caught,
+    falseSkips,
+    falseSkipRate,
+    ranTests: ran.size,
+    predictedRan,
+    historyLogged
+  };
+}
+
+// src/core/vcs/change-base.ts
+var import_promises3 = require("fs/promises");
+
+// src/core/vcs/git.ts
+var import_node_path3 = __toESM(require("path"), 1);
+async function git(cwd, args) {
+  try {
+    const { execa } = await import("execa");
+    const { stdout } = await execa("git", args, { cwd });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+function isOptionLike(ref) {
+  return ref.startsWith("-");
+}
+async function resolveCommit(cwd, ref) {
+  if (isOptionLike(ref)) return null;
+  const stdout = await git(cwd, [
+    "rev-parse",
+    "--verify",
+    "--quiet",
+    `${ref}^{commit}`
+  ]);
+  const sha = stdout?.trim();
+  return sha === void 0 || sha === "" ? null : sha;
+}
+async function mergeBase(cwd, a, b) {
+  if (isOptionLike(a) || isOptionLike(b)) return null;
+  const sha = (await git(cwd, ["merge-base", a, b]))?.trim();
+  return sha === void 0 || sha === "" ? null : sha;
+}
+var DEFAULT_BRANCH_GUESSES = [
+  "origin/main",
+  "origin/master",
+  "main",
+  "master"
+];
+async function defaultBranchRef(cwd) {
+  const head = (await git(cwd, [
+    "symbolic-ref",
+    "--quiet",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ]))?.trim();
+  if (head !== void 0 && head !== "") return head;
+  for (const guess of DEFAULT_BRANCH_GUESSES) {
+    if (await resolveCommit(cwd, guess) !== null) return guess;
+  }
+  return null;
+}
+async function repositoryRoot(cwd) {
+  const top = (await git(cwd, ["rev-parse", "--show-toplevel"]))?.trim();
+  return top === void 0 || top === "" ? null : top;
+}
+
+// src/core/vcs/change-base.ts
+function changeBaseDeps(cwd) {
+  return {
+    env: process.env,
+    readEvent: async (path5) => {
+      try {
+        return JSON.parse(await (0, import_promises3.readFile)(path5, "utf8"));
+      } catch {
+        return void 0;
+      }
+    },
+    resolveCommit: (ref) => resolveCommit(cwd, ref),
+    mergeBase: (a, b) => mergeBase(cwd, a, b),
+    defaultBranch: () => defaultBranchRef(cwd)
+  };
+}
+function field(value, ...keys) {
+  let current = value;
+  for (const key of keys) {
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function isPullRequest(env) {
+  const event = env["GITHUB_EVENT_NAME"];
+  return env["GITHUB_ACTIONS"] === "true" && (event === "pull_request" || event === "pull_request_target") && (env["GITHUB_BASE_REF"] ?? "") !== "";
+}
+async function readEvent(deps) {
+  const path5 = deps.env["GITHUB_EVENT_PATH"];
+  return path5 === void 0 || path5 === "" ? void 0 : deps.readEvent(path5);
+}
+async function detectHeadSha(deps) {
+  if (deps.env["GITHUB_ACTIONS"] !== "true") return void 0;
+  if (isPullRequest(deps.env)) {
+    const pushed = field(await readEvent(deps), "pull_request", "head", "sha");
+    return typeof pushed === "string" && pushed !== "" ? pushed : void 0;
+  }
+  const sha = deps.env["GITHUB_SHA"];
+  return deps.env["GITHUB_EVENT_NAME"] === "push" && sha !== void 0 && sha !== "" ? sha : void 0;
+}
+
+// src/reporters/shadow.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var STALE_LOCK_MS = 10 * 6e4;
+var POLL_MS = 200;
+var KEEP_OUTCOME_MS = 60 * 6e4;
+var DISABLED = { finish: async () => {
+}, cancel: () => {
+} };
+function inCi(env) {
+  const ci = env["CI"];
+  return ci !== void 0 && ci !== "" && ci !== "false" && ci !== "0";
+}
+function isEnabled(options, env) {
+  if (env["VARIANT_SHADOW"] === "0") return false;
+  if (options.local === true || env["VARIANT_SHADOW"] === "1") return true;
+  return inCi(env);
+}
+function count(n, noun) {
+  return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+function summaryLines(summary, result) {
+  const why = summary.unreached > 0 ? `: ${count(summary.unreached, "changed file")} reach${summary.unreached === 1 ? "es" : ""} no test` : summary.unselectedTests > 0 ? `: ${count(summary.unselectedTests, "changed JavaScript test")} could not be selected` : "";
+  const predicted = summary.selectAll ? `variant: selected all ${count(result.ranTests, "test file")}, because configuration changed.` : `variant: predicted ${result.predictedRan} of ${count(result.ranTests, "test file")} (${summary.resolution}${why}).`;
+  const failed = result.failedTests.length;
+  if (failed === 0) {
+    return [`${predicted} No failures, so nothing to check.`];
+  }
+  const missed = result.falseSkips.length;
+  if (missed === 0) {
+    return [
+      `${predicted} ${failed} failed, ${failed === 1 ? "and it was" : "all"} predicted.`
+    ];
+  }
+  return [
+    `${predicted} ${failed} failed, ${missed} NOT predicted:`,
+    ...result.falseSkips.map((file) => `  ${file}`),
+    "  Nothing was skipped. This is a false skip; please report it."
+  ];
+}
+function pendingPaths(root, headSha) {
+  const dir = import_node_path4.default.join(defaultHistoryDir(root), "pending");
+  return {
+    dir,
+    lock: import_node_path4.default.join(dir, `${headSha}.lock`),
+    done: import_node_path4.default.join(dir, `${headSha}.json`)
+  };
+}
+async function acquire(lock, dir, now) {
+  await (0, import_promises4.mkdir)(dir, { recursive: true });
+  let takenAt = now();
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const handle = await (0, import_promises4.open)(lock, "wx");
+      await handle.writeFile(String(now()));
+      await handle.close();
+      return true;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      takenAt = await (0, import_promises4.stat)(lock).then(
+        (stats) => stats.mtimeMs,
+        () => now()
+      );
+      if (now() - takenAt < STALE_LOCK_MS) return takenAt;
+      await (0, import_promises4.unlink)(lock).catch(() => {
+      });
+    }
+  }
+  return takenAt;
+}
+async function prune(dir, now) {
+  const names = await (0, import_promises4.readdir)(dir).catch(() => []);
+  await Promise.all(
+    names.map(async (name) => {
+      const file = import_node_path4.default.join(dir, name);
+      const age = await (0, import_promises4.stat)(file).then(
+        (stats) => now() - stats.mtimeMs,
+        () => 0
+      );
+      if (age > KEEP_OUTCOME_MS) await (0, import_promises4.unlink)(file).catch(() => {
+      });
+    })
+  );
+}
+async function readDone(done, since) {
+  try {
+    const parsed = JSON.parse(await (0, import_promises4.readFile)(done, "utf8"));
+    return parsed.at >= since ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function startShadow(cwd, options = {}, deps = shadowDeps()) {
+  if (!isEnabled(options, deps.env)) return DISABLED;
+  const startedAt = deps.now();
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  let cancelled = false;
+  let handle;
+  let held;
+  const say = (lines) => {
+    if (options.silent !== true) deps.write(`${lines.join("\n")}
+`);
+  };
+  const release = async () => {
+    if (held === void 0) return;
+    const lock = held;
+    held = void 0;
+    await (0, import_promises4.unlink)(lock).catch(() => {
+    });
+  };
+  const prediction = (async () => {
+    const root = await deps.repositoryRoot(cwd);
+    const headSha = await deps.headSha(root);
+    if (headSha === null || cancelled) return null;
+    const paths = pendingPaths(root, headSha);
+    if (inCi(deps.env)) {
+      const earlier = await readDone(paths.done, startedAt - STALE_LOCK_MS);
+      if (earlier !== null) return { root, headSha, outcome: earlier.outcome };
+    }
+    const lock = await acquire(paths.lock, paths.dir, deps.now);
+    if (lock === true) {
+      held = paths.lock;
+      if (cancelled) {
+        await release();
+        return null;
+      }
+      void prune(paths.dir, deps.now);
+      handle = deps.predict(root, headSha);
+      const outcome = await handle.result;
+      const done = { at: deps.now(), outcome };
+      await (0, import_promises4.writeFile)(paths.done, JSON.stringify(done)).catch(() => {
+      });
+      await release();
+      return { root, headSha, outcome };
+    }
+    while (!cancelled) {
+      const lockGone = await (0, import_promises4.stat)(paths.lock).then(
+        () => false,
+        () => true
+      );
+      if (lockGone) {
+        const done = await readDone(paths.done, lock - 1e3);
+        return {
+          root,
+          headSha,
+          outcome: done?.outcome ?? {
+            kind: "failed",
+            reason: "another test process was predicting and left no result"
+          }
+        };
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+    }
+    return null;
+  })();
+  prediction.catch(() => {
+  });
+  const stop = () => {
+    cancelled = true;
+    handle?.cancel();
+    void release();
+  };
+  return {
+    cancel: stop,
+    finish: async (results) => {
+      try {
+        let timer;
+        const timedOut = new Promise((resolve) => {
+          timer = setTimeout(() => resolve("timeout"), timeoutMs);
+        });
+        const settled = await Promise.race([prediction, timedOut]);
+        clearTimeout(timer);
+        if (settled === "timeout") {
+          stop();
+          say([
+            `variant: skipped (the prediction did not finish within ${Math.round(timeoutMs / 1e3)} s of the tests)`
+          ]);
+          return;
+        }
+        if (settled === null) return;
+        const { root, headSha, outcome } = settled;
+        if (outcome.kind === "none") {
+          say([`variant: no prediction (${outcome.reason})`]);
+          return;
+        }
+        if (outcome.kind === "failed") {
+          say([`variant: skipped (${outcome.reason})`]);
+          return;
+        }
+        const result = await deps.reconcile(root, results, headSha);
+        if (result === null) {
+          say(["variant: skipped (the prediction was not recorded)"]);
+          return;
+        }
+        const lines = summaryLines(outcome.summary, result);
+        say(lines);
+        const summaryFile = deps.env["GITHUB_STEP_SUMMARY"];
+        if (summaryFile !== void 0 && summaryFile !== "") {
+          await deps.appendSummary(summaryFile, `${lines.join("\n")}
+`).catch(() => {
+          });
+        }
+      } catch (error) {
+        stop();
+        say([
+          `variant: skipped (${error instanceof Error ? error.message : String(error)})`
+        ]);
+      }
+    }
+  };
+}
+function firstLine(text) {
+  return text.split("\n").map((line) => line.trim()).find((line) => line !== "") ?? "variant impact failed";
+}
+function parsePrediction(exitCode, stdout, stderr) {
+  if (exitCode !== 0) return { kind: "failed", reason: firstLine(stderr) };
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return { kind: "failed", reason: "variant impact printed no result" };
+  }
+  if (parsed.prediction === null) {
+    return { kind: "none", reason: parsed.reason ?? "nothing to compare" };
+  }
+  if (parsed.tests === void 0) {
+    return { kind: "failed", reason: "variant impact printed no result" };
+  }
+  return {
+    kind: "predicted",
+    summary: {
+      resolution: parsed.tests.resolution,
+      selectAll: parsed.tests.selectAll,
+      unreached: parsed.tests.unreached.length,
+      unselectedTests: parsed.tests.unselectedTests.length
+    }
+  };
+}
+function defaultCliPath() {
+  return (0, import_node_url.fileURLToPath)(new URL("./cli.js", importMetaUrl));
+}
+function shadowDeps(cliPath = defaultCliPath()) {
+  return {
+    env: process.env,
+    now: () => Date.now(),
+    repositoryRoot: async (cwd) => await repositoryRoot(cwd) ?? cwd,
+    headSha: async (root) => await detectHeadSha(changeBaseDeps(root)) ?? await resolveCommit(root, "HEAD"),
+    predict: (root, headSha) => {
+      const child = (0, import_node_child_process.spawn)(
+        process.execPath,
+        [cliPath, "impact", "--json", "--head-sha", headSha],
+        { cwd: root, stdio: ["ignore", "pipe", "pipe"] }
+      );
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += new TextDecoder().decode(chunk);
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += new TextDecoder().decode(chunk);
+      });
+      const result = new Promise((resolve) => {
+        child.on(
+          "error",
+          (error) => resolve({ kind: "failed", reason: error.message })
+        );
+        child.on(
+          "close",
+          (code) => resolve(parsePrediction(code, stdout, stderr))
+        );
+      });
+      return { result, cancel: () => void child.kill("SIGKILL") };
+    },
+    reconcile: (root, results, headSha) => verifyRun(root, testRunFrom(root, results), { headSha }),
+    write: (line) => void process.stdout.write(line),
+    appendSummary: (file, text) => (0, import_promises4.appendFile)(file, text)
+  };
+}
+
+// src/reporters/vitest.ts
+function variantReporter(options = {}, deps) {
+  let root = process.cwd();
+  let watching = false;
+  let log;
+  let run;
+  return {
+    onInit(vitest) {
+      root = vitest.config.root;
+      watching = vitest.config.watch === true;
+      log = (line) => vitest.logger.log(line.replace(/\n$/, ""));
+    },
+    onTestRunStart() {
+      if (watching) return;
+      const effects = deps ?? shadowDeps();
+      run = startShadow(root, options, {
+        ...effects,
+        ...log !== void 0 && deps === void 0 && { write: log }
+      });
+    },
+    async onTestRunEnd(testModules, _unhandledErrors, reason) {
+      const current = run;
+      run = void 0;
+      if (current === void 0) return;
+      if (reason === "interrupted") {
+        current.cancel();
+        return;
+      }
+      await current.finish(
+        testModules.map((testModule) => ({
+          file: testModule.moduleId,
+          failed: testModule.state() === "failed"
+        }))
+      );
+    }
+  };
+}
+function variantReporters(options = {}) {
+  return [
+    "default",
+    ...process.env["GITHUB_ACTIONS"] === "true" ? ["github-actions"] : [],
+    variantReporter(options)
+  ];
+}
+var vitest_default = variantReporter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  variantReporter,
+  variantReporters
+});