@blzsky/variant 0.2.1 → 0.3.0-canary.1

package/dist/{chunk-43VLELTL.js → chunk-2UVLKBLV.js}

@@ -1,6 +1,6 @@
 import {
   CacheError
-} from "./chunk-VYWPQKMS.js";
+} from "./chunk-C3NZIFW6.js";
 
 // src/core/cache/store.ts
 import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";

package/dist/chunk-34VGKPEM.js

@@ -0,0 +1,59 @@
+// src/core/history/impact-log.ts
+import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+var MAX_IMPACT_RECORDS = 1e3;
+var LOG_FILENAME = "impact.jsonl";
+var RECONCILIATION_FILENAME = "reconciliation.jsonl";
+function defaultHistoryDir(cwd) {
+  return path.join(cwd, ".variant", "history");
+}
+async function appendImpactPrediction(historyDir, prediction) {
+  return appendRecord(historyDir, LOG_FILENAME, prediction);
+}
+async function appendReconciliation(historyDir, reconciliation) {
+  return appendRecord(historyDir, RECONCILIATION_FILENAME, reconciliation);
+}
+async function appendRecord(historyDir, filename, record) {
+  try {
+    await mkdir(historyDir, { recursive: true });
+    const file = path.join(historyDir, filename);
+    await appendFile(file, `${JSON.stringify(record)}
+`);
+    const lines = (await readFile(file, "utf8")).split("\n").filter((l) => l.trim() !== "");
+    if (lines.length > MAX_IMPACT_RECORDS) {
+      await 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 readFile(path.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;
+}
+
+export {
+  defaultHistoryDir,
+  appendImpactPrediction,
+  appendReconciliation,
+  readImpactPredictions
+};

package/dist/chunk-BNACT47L.js

@@ -0,0 +1,590 @@
+import {
+  createClassifier
+} from "./chunk-JEJRXPCU.js";
+import {
+  buildImportGraph,
+  computeAffectedFiles,
+  importersOfUnindexed,
+  readManifests,
+  workspaceBlindSpots
+} from "./chunk-TRUK3TJF.js";
+import {
+  mapLimit
+} from "./chunk-GDSZFIHM.js";
+import {
+  getChangedFiles
+} from "./chunk-MKUYZIXF.js";
+import {
+  readPathAliases
+} from "./chunk-X3VVGTEV.js";
+import {
+  readFileAtRef,
+  readFilesAtRef
+} from "./chunk-OON6O4S5.js";
+import {
+  updateSymbolGraph
+} from "./chunk-XXMD4NC5.js";
+import {
+  isStarReexportKey
+} from "./chunk-WULBOSG5.js";
+
+// src/core/semantic/verdict.ts
+function deriveVerdict(classifications, options = {}) {
+  if (options.forceBuild === true) return "build-required";
+  let verdict = "safe-to-skip";
+  for (const classification of classifications) {
+    if (classification === "breaking") return "build-required";
+    if (classification === "internal" || classification === "unanalyzed") {
+      verdict = "build-recommended";
+    }
+  }
+  return verdict;
+}
+function resolutionOf(confidence) {
+  if (confidence >= 0.9) return "high";
+  if (confidence >= 0.7) return "medium";
+  return "low";
+}
+var VERDICT_TEXT = {
+  "safe-to-skip": "safe to skip build",
+  "build-recommended": "build recommended",
+  "build-required": "build required"
+};
+function verdictText(verdict) {
+  return VERDICT_TEXT[verdict];
+}
+
+// src/core/semantic/blast-radius.ts
+import { readFile } from "fs/promises";
+import path from "path";
+var TS_FILE = /\.(?:ts|tsx|mts|cts)$/;
+var JS_FILE = /\.(?:[cm]?js|jsx)$/;
+var COMMONJS_EXPORT = /\bmodule\.exports\b|\bexports\.[A-Za-z_$]|\bexports\[/;
+var MODULE_FILE = /\.(?:[cm]?[jt]sx?|json)$/;
+function isModuleFile(file) {
+  return MODULE_FILE.test(file);
+}
+var DECLARATION_FILE = /\.d\.(?:ts|mts|cts)$/;
+var MAX_NOTE_FILES = 3;
+var CLASSIFY_CONCURRENCY = 16;
+function isOutsideWorkspace(file) {
+  return file.startsWith("../");
+}
+function isTypeScriptSource(file) {
+  return TS_FILE.test(file) && !DECLARATION_FILE.test(file);
+}
+function isSource(file) {
+  return isTypeScriptSource(file) || JS_FILE.test(file);
+}
+function isAnalyzable(file) {
+  return isSource(file) && !isOutsideWorkspace(file);
+}
+function widenCommonJs(impact, before, after) {
+  if (!JS_FILE.test(impact.filePath)) return impact;
+  if (impact.classification === "non-impacting") return impact;
+  if (!COMMONJS_EXPORT.test(`${before ?? ""}
+${after ?? ""}`)) return impact;
+  return {
+    ...impact,
+    classification: "breaking",
+    propagates: true,
+    ungated: true
+  };
+}
+function unanalyzedImpact(file) {
+  return {
+    filePath: file,
+    classification: "unanalyzed",
+    impactedSymbols: [],
+    propagates: false,
+    notes: []
+  };
+}
+async function batchedReaderFor(cwd, baseRef, relPaths) {
+  const batch = await readFilesAtRef(cwd, baseRef, relPaths);
+  if (batch === null) return (rel) => readFileAtRef(cwd, baseRef, rel);
+  return async (rel) => batch.get(rel) ?? null;
+}
+async function traceBlastRadius(cwd, options = {}) {
+  const baseRef = options.baseRef ?? "HEAD~1";
+  const changedFiles = options.changedFiles ?? await getChangedFiles({ cwd, baseRef });
+  if (changedFiles === null) return null;
+  const packageDirs = packageDirsFrom(cwd, options.packageGraph);
+  let importGraph = options.importGraph;
+  if (importGraph === void 0) {
+    const [{ graph: symbolGraph }, pathAliases] = await Promise.all([
+      updateSymbolGraph(
+        cwd,
+        options.graphDir === void 0 ? {} : { graphDir: options.graphDir }
+      ),
+      options.pathAliases ?? readPathAliases(cwd)
+    ]);
+    importGraph = buildImportGraph(symbolGraph, {
+      packageDirs,
+      pathAliases,
+      packageExports: packageExportsFrom(options.packageGraph)
+    });
+  }
+  const indexed = importGraph.imports;
+  const files = changedFiles.map(toPosix).sort();
+  const analyzable = files.filter(isAnalyzable);
+  const readBefore = options.readBefore ?? await batchedReaderFor(cwd, baseRef, analyzable);
+  const readAfter = options.readAfter ?? (async (rel) => {
+    try {
+      return await readFile(path.join(cwd, rel), "utf8");
+    } catch {
+      return null;
+    }
+  });
+  const classify = createClassifier();
+  const changed = await mapLimit(files, CLASSIFY_CONCURRENCY, async (file) => {
+    if (!isAnalyzable(file)) return unanalyzedImpact(file);
+    const [before, after] = await Promise.all([
+      readBefore(file),
+      readAfter(file)
+    ]);
+    if (after !== null && !indexed.has(file)) return unanalyzedImpact(file);
+    return widenCommonJs(
+      toFileImpact(
+        await classify({
+          filePath: file,
+          before: before ?? "",
+          after: after ?? ""
+        })
+      ),
+      before,
+      after
+    );
+  });
+  const manifests = options.manifests ?? await readManifests(cwd);
+  const blindSpots = workspaceBlindSpots({
+    externals: importGraph.externals,
+    packageNames: new Set(
+      (options.packageGraph?.packages ?? []).map((pkg) => pkg.manifest.name)
+    ),
+    manifests
+  });
+  return assembleBlastRadius(baseRef, changed, importGraph, {
+    packageDirs,
+    workspaceNotes: blindSpots.notes,
+    undiscoveredPackages: blindSpots.undiscovered,
+    packageRoots: [...manifests.keys()],
+    ...options.tasks === void 0 ? {} : { tasks: options.tasks }
+  });
+}
+function assembleBlastRadius(baseRef, changed, importGraph, options = {}) {
+  const notes = /* @__PURE__ */ new Set();
+  const repositoryNotes = new Set(options.workspaceNotes);
+  const affected = /* @__PURE__ */ new Set();
+  const firstHop = /* @__PURE__ */ new Set();
+  for (const impact of changed) {
+    for (const note of impact.notes) notes.add(note);
+    if (impact.classification === "non-impacting") continue;
+    affected.add(impact.filePath);
+    if (impact.classification === "unanalyzed" || !importGraph.imports.has(impact.filePath)) {
+      for (const importer of importersOfUnindexed(
+        importGraph,
+        impact.filePath
+      )) {
+        firstHop.add(importer);
+      }
+      continue;
+    }
+    if (!impact.propagates) continue;
+    const ungated = impact.ungated === true || impact.impactedSymbols.some(isStarReexportKey);
+    for (const dependent of importGraph.dependents.get(impact.filePath) ?? []) {
+      const edge = importGraph.edges.get(dependent)?.get(impact.filePath);
+      if (edge === void 0) {
+        firstHop.add(dependent);
+        continue;
+      }
+      if (edge.dynamic) {
+        notes.add(
+          `${dependent}: dynamic import of ${impact.filePath} \u2014 names unknowable`
+        );
+        firstHop.add(dependent);
+        continue;
+      }
+      if (ungated || edge.names.has("*")) {
+        firstHop.add(dependent);
+        continue;
+      }
+      if (impact.impactedSymbols.some((s) => edge.names.has(s))) {
+        firstHop.add(dependent);
+      }
+    }
+  }
+  for (const file of computeAffectedFiles(firstHop, importGraph)) {
+    affected.add(file);
+  }
+  const unanalyzed = changed.filter((impact) => impact.classification === "unanalyzed").map((impact) => impact.filePath);
+  const outside = unanalyzed.filter(isOutsideWorkspace);
+  const inside = unanalyzed.filter((file) => !isOutsideWorkspace(file));
+  const unindexed = inside.filter(isSource);
+  const notTypeScript = inside.filter((file) => !isSource(file));
+  if (notTypeScript.length > 0) {
+    const one = notTypeScript.length === 1;
+    notes.add(
+      `${notTypeScript.length} changed ${one ? "file is" : "files are"} not TypeScript or JavaScript and ${one ? "was" : "were"} not analyzed (${listPaths(notTypeScript)})`
+    );
+  }
+  if (unindexed.length > 0) {
+    const one = unindexed.length === 1;
+    notes.add(
+      `${unindexed.length} changed source ${one ? "file is" : "files are"} not in variant's index (ignored by git, in a build directory, or too large) and ${one ? "was" : "were"} not analyzed (${listPaths(unindexed)})`
+    );
+  }
+  if (outside.length > 0) {
+    const one = outside.length === 1;
+    notes.add(
+      `${outside.length} changed ${one ? "file is" : "files are"} outside the directory variant ran in and ${one ? "was" : "were"} not analyzed (${listPaths(outside)})`
+    );
+  }
+  const withUnresolved = [...affected].sort().flatMap((file) => {
+    const specs = importGraph.unresolved.get(file);
+    return specs === void 0 || specs.size === 0 ? [] : [`${file} (${[...specs].sort().join(", ")})`];
+  });
+  if (withUnresolved.length > 0) {
+    const one = withUnresolved.length === 1;
+    notes.add(
+      `${withUnresolved.length} affected ${one ? "file has" : "files have"} unresolved imports: ${listPaths(withUnresolved)}`
+    );
+  }
+  const impacting = changed.filter((impact) => impact.classification !== "non-impacting").map((impact) => impact.filePath);
+  if (importGraph.computed.size > 0) {
+    const loaders = [...importGraph.computed].sort();
+    repositoryNotes.add(
+      `${loaders.length} file(s) load a module through a fully computed import() or require() specifier (${listPaths(loaders)}); a change reached only that way selects no tests`
+    );
+    const touched = new Set(
+      impacting.filter(isModuleFile).map((file) => packageRootOf(file, options.packageRoots))
+    );
+    const near = loaders.filter(
+      (loader) => touched.has(packageRootOf(loader, options.packageRoots))
+    );
+    if (near.length > 0) {
+      notes.add(
+        `${near.length} file(s) in a package this change touches load a module through a fully computed import() or require() specifier (${listPaths(near)}); a changed file reached only that way selects no tests`
+      );
+    }
+  }
+  for (const [name, dir] of options.undiscoveredPackages ?? []) {
+    const prefix = dir === "" ? "" : `${dir}/`;
+    const inside2 = impacting.filter((file) => file.startsWith(prefix));
+    if (inside2.length > 0) {
+      const one = inside2.length === 1;
+      notes.add(
+        `${inside2.length} changed ${one ? "file belongs" : "files belong"} to ${name}, a local package variant did not find as a workspace package (${listPaths(inside2)}); files importing it by name are not reached`
+      );
+    }
+  }
+  const packageDirs = options.packageDirs ?? {};
+  const affectedPackages = /* @__PURE__ */ new Set();
+  for (const file of affected) {
+    const pkg = fileToPackage(file, packageDirs);
+    if (pkg !== void 0) affectedPackages.add(pkg);
+  }
+  const affectedTasks = [];
+  for (const taskName of Object.keys(options.tasks ?? {})) {
+    const sep = taskName.lastIndexOf(":");
+    if (sep === -1) continue;
+    if (affectedPackages.has(taskName.slice(0, sep))) {
+      affectedTasks.push(taskName);
+    }
+  }
+  const noteList = [...notes].sort();
+  const confidence = Math.max(
+    0.3,
+    Math.round((1 - noteList.length * 0.1) * 100) / 100
+  );
+  return {
+    baseRef,
+    changed,
+    affectedFiles: [...affected].sort(),
+    affectedPackages: [...affectedPackages].sort(),
+    affectedTasks: affectedTasks.sort(),
+    confidence,
+    notes: noteList,
+    repositoryNotes: [...repositoryNotes].sort()
+  };
+}
+function packageRootOf(file, packageRoots) {
+  let best = "";
+  for (const root of packageRoots ?? []) {
+    if (root !== "" && file.startsWith(`${root}/`) && root.length > best.length) {
+      best = root;
+    }
+  }
+  return best;
+}
+function toFileImpact(result) {
+  const impactedSymbols = [
+    ...result.exportedSymbols.added.filter(isStarReexportKey),
+    ...result.exportedSymbols.removed,
+    ...result.exportedSymbols.changed.filter((c) => c.kind !== "body").map((c) => c.name)
+  ].sort();
+  const ungated = result.syntaxErrors || impactedSymbols.some(isStarReexportKey);
+  return {
+    filePath: result.filePath,
+    classification: result.classification,
+    impactedSymbols,
+    propagates: result.classification === "breaking",
+    ...ungated && { ungated: true },
+    notes: result.confidenceNotes.map((n) => `${result.filePath}: ${n}`)
+  };
+}
+function packageDirsFrom(cwd, packageGraph) {
+  const out = {};
+  for (const pkg of packageGraph?.packages ?? []) {
+    out[pkg.manifest.name] = toPosix(path.relative(cwd, pkg.dir));
+  }
+  return out;
+}
+function packageExportsFrom(packageGraph) {
+  const out = {};
+  for (const pkg of packageGraph?.packages ?? []) {
+    if (pkg.manifest.exports !== void 0) {
+      out[pkg.manifest.name] = pkg.manifest.exports;
+    }
+  }
+  return out;
+}
+function listPaths(items) {
+  return items.length > MAX_NOTE_FILES ? `${items.slice(0, MAX_NOTE_FILES).join(", ")}, \u2026 ${items.length - MAX_NOTE_FILES} more` : items.join(", ");
+}
+function fileToPackage(file, packageDirs) {
+  let bestName;
+  let bestLength = -1;
+  for (const [name, dir] of Object.entries(packageDirs)) {
+    const prefix = dir === "" ? "" : `${dir}/`;
+    if (file.startsWith(prefix) && prefix.length > bestLength) {
+      bestName = name;
+      bestLength = prefix.length;
+    }
+  }
+  return bestName;
+}
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+
+// src/core/semantic/test-impact.ts
+var JAVASCRIPT_TEST_FILE = /\.(?:test|spec)\.(?:js|jsx|mjs|cjs)$/;
+function isJavaScriptTestFile(file) {
+  return JAVASCRIPT_TEST_FILE.test(file);
+}
+function defaultIsTestFile(file) {
+  return /(^|\/)__tests__\//.test(file) || /\.(test|spec)\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/.test(file);
+}
+var TEST_CONFIG_FILE = /(^|\/)(package\.json|pnpm-lock\.yaml|pnpm-workspace\.yaml|package-lock\.json|npm-shrinkwrap\.json|yarn\.lock|bun\.lockb?|bunfig\.toml|tsconfig[^/]*\.json|(vitest|jest|playwright|vite|babel|next)(\.[^/.]+)?\.config\.[^/.]+(\.[^/]+)?|vitest\.(workspace|projects)\.[^/.]+|\.babelrc(\.[^/]+)?)$/;
+var TEST_SETUP_FILE = /(^|\/)((vitest|jest)\.setup|setup-?tests|global-?(setup|teardown)|tests?\/setup)\.[cm]?[jt]sx?$/i;
+var PROSE_FILE = /\.(?:md|markdown|rst|txt|adoc)$/i;
+var UNREACHED_CONFIDENCE = 0.5;
+function invalidatesAllTests(filePath) {
+  return TEST_CONFIG_FILE.test(filePath) || TEST_SETUP_FILE.test(filePath);
+}
+function buildTestTrace(graph, options = {}) {
+  const isTest = options.isTestFile ?? defaultIsTestFile;
+  const closures = /* @__PURE__ */ new Map();
+  for (const file of [...graph.imports.keys()].sort()) {
+    if (isTest(file)) closures.set(file, closureOf(file, graph));
+  }
+  return { closures };
+}
+function buildCoverageMap(trace) {
+  const testsFor = /* @__PURE__ */ new Map();
+  for (const [test, closure] of trace.closures) {
+    for (const file of closure) {
+      let tests = testsFor.get(file);
+      if (tests === void 0) {
+        tests = /* @__PURE__ */ new Set();
+        testsFor.set(file, tests);
+      }
+      tests.add(test);
+    }
+  }
+  return { testsFor };
+}
+function computeTestImpact(radius, graph, options = {}) {
+  const trace = buildTestTrace(graph, options);
+  const coverage = buildCoverageMap(trace);
+  const allTests = [...trace.closures.keys()];
+  const notes = /* @__PURE__ */ new Set();
+  let selectAll = false;
+  for (const impact of radius.changed) {
+    if (invalidatesAllTests(impact.filePath)) {
+      selectAll = true;
+      notes.add(
+        `${impact.filePath}: build/test configuration changed \u2014 running all tests`
+      );
+    }
+  }
+  const affected = /* @__PURE__ */ new Set();
+  if (selectAll) {
+    for (const test of allTests) affected.add(test);
+  } else {
+    for (const file of radius.affectedFiles) {
+      for (const test of coverage.testsFor.get(file) ?? []) {
+        affected.add(test);
+      }
+    }
+  }
+  const unindexed = (file) => !graph.imports.has(file);
+  const javascriptTests = [...options.javascriptTests ?? []].filter(unindexed).sort();
+  const unselectedTests = radius.changed.map((impact) => impact.filePath).filter((file) => isJavaScriptTestFile(file) && unindexed(file));
+  if (unselectedTests.length > 0) {
+    const one = unselectedTests.length === 1;
+    notes.add(
+      `${unselectedTests.length} changed test ${one ? "file is" : "files are"} JavaScript, which variant does not index, and ${one ? "was" : "were"} not selected (${listPaths(unselectedTests)})`
+    );
+  }
+  const repositoryNotes = [];
+  if (javascriptTests.length > 0) {
+    const one = javascriptTests.length === 1;
+    repositoryNotes.push(
+      `${javascriptTests.length} JavaScript test ${one ? "file is" : "files are"} not indexed (${listPaths(javascriptTests)}); variant cannot select ${one ? "it" : "them"}, and code only ${one ? "it imports" : "they import"} looks untested`
+    );
+    const touched = new Set(
+      radius.changed.filter(
+        (impact) => impact.classification !== "non-impacting" && isModuleFile(impact.filePath) && !isJavaScriptTestFile(impact.filePath)
+      ).map((impact) => packageRootOf(impact.filePath, options.packageRoots))
+    );
+    const near = javascriptTests.filter(
+      (test) => touched.has(packageRootOf(test, options.packageRoots))
+    );
+    if (near.length > 0) {
+      const oneNear = near.length === 1;
+      notes.add(
+        `${near.length} JavaScript test ${oneNear ? "file" : "files"} in a package this change touches cannot be selected (${listPaths(near)})`
+      );
+    }
+  }
+  const tested = (file) => (coverage.testsFor.get(file)?.size ?? 0) > 0;
+  const unreached = [];
+  if (!selectAll) {
+    for (const impact of radius.changed) {
+      if (impact.classification === "non-impacting") continue;
+      if (PROSE_FILE.test(impact.filePath)) continue;
+      if (unselectedTests.includes(impact.filePath)) continue;
+      if (graph.imports.has(impact.filePath)) {
+        if (!tested(impact.filePath)) unreached.push(impact.filePath);
+        continue;
+      }
+      if (impact.classification !== "unanalyzed") continue;
+      const reached = [...importersOfUnindexed(graph, impact.filePath)].some(
+        tested
+      );
+      if (!reached) unreached.push(impact.filePath);
+    }
+  }
+  let blindSpots = 0;
+  for (const test of affected) {
+    const closure = trace.closures.get(test);
+    if (closure === void 0) continue;
+    for (const file of closure) {
+      const unresolvedForFile = graph.unresolved.get(file);
+      if (unresolvedForFile !== void 0 && unresolvedForFile.size > 0) {
+        blindSpots++;
+        break;
+      }
+    }
+  }
+  if (blindSpots > 0) {
+    notes.add(
+      `${blindSpots} selected test file(s) have unresolved imports in their closure \u2014 fixtures or assets may be missed`
+    );
+  }
+  const noteList = [...notes].sort();
+  const resolved = Math.max(
+    0.3,
+    Math.round((radius.confidence - noteList.length * 0.1) * 100) / 100
+  );
+  const confidence = selectAll ? 1 : unreached.length > 0 || unselectedTests.length > 0 ? Math.min(resolved, UNREACHED_CONFIDENCE) : resolved;
+  return {
+    affectedTests: [...affected].sort(),
+    totalTests: allTests.length,
+    selectAll,
+    unreached,
+    unselectedTests,
+    javascriptTests: javascriptTests.length,
+    confidence,
+    resolution: resolutionOf(confidence),
+    notes: noteList,
+    repositoryNotes
+  };
+}
+async function traceTestImpact(cwd, options = {}) {
+  let importGraph = options.importGraph;
+  if (importGraph === void 0) {
+    const [{ graph: symbolGraph }, pathAliases] = await Promise.all([
+      updateSymbolGraph(
+        cwd,
+        options.graphDir === void 0 ? {} : { graphDir: options.graphDir }
+      ),
+      options.pathAliases ?? readPathAliases(cwd)
+    ]);
+    importGraph = buildImportGraph(symbolGraph, {
+      packageDirs: packageDirsFrom(cwd, options.packageGraph),
+      pathAliases,
+      packageExports: packageExportsFrom(options.packageGraph)
+    });
+  }
+  const [manifests, javascriptTests] = await Promise.all([
+    options.manifests ?? readManifests(cwd),
+    options.javascriptTests ?? findJavaScriptTests(cwd)
+  ]);
+  const radius = await traceBlastRadius(cwd, {
+    ...options,
+    importGraph,
+    manifests
+  });
+  if (radius === null) return null;
+  return {
+    radius,
+    graph: importGraph,
+    tests: computeTestImpact(radius, importGraph, {
+      ...options.isTestFile !== void 0 && {
+        isTestFile: options.isTestFile
+      },
+      javascriptTests,
+      packageRoots: [...manifests.keys()]
+    })
+  };
+}
+async function findJavaScriptTests(cwd) {
+  const fg = (await import("fast-glob")).default;
+  const found = await fg("**/*.{test,spec}.{js,jsx,mjs,cjs}", {
+    cwd,
+    onlyFiles: true,
+    ignore: ["**/node_modules/**", "**/dist/**", ".git/**", ".variant/**"]
+  });
+  return found.map((file) => file.replace(/\\/g, "/")).sort();
+}
+function closureOf(start, graph) {
+  const closure = /* @__PURE__ */ new Set([start]);
+  let frontier = /* @__PURE__ */ new Set([start]);
+  while (frontier.size > 0) {
+    const next = /* @__PURE__ */ new Set();
+    for (const file of frontier) {
+      for (const target of graph.imports.get(file) ?? []) {
+        if (!closure.has(target)) {
+          closure.add(target);
+          next.add(target);
+        }
+      }
+    }
+    frontier = next;
+  }
+  return closure;
+}
+
+export {
+  packageRootOf,
+  deriveVerdict,
+  verdictText,
+  isJavaScriptTestFile,
+  defaultIsTestFile,
+  PROSE_FILE,
+  invalidatesAllTests,
+  traceTestImpact
+};