module-spec 0.0.0-stage → 0.2.0

package/lib/languages/python/mutate.js

@@ -0,0 +1,72 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { scratchCopy } from "../../files.js";
+import { pythonOf, toolBeside } from "./environment.js";
+import { pythonPackageOf } from "./package.js";
+
+const OUTPUT_LIMIT = 512 * 1024 * 1024;
+/** mutmut's statuses: a timeout counts as caught, and a mutant no test reaches counts as live. */
+const CAUGHT = new Set(["killed", "timeout"]);
+const LIVE = new Set(["survived", "no tests"]);
+
+/** setup.cfg's [mutmut] section, with any section the project had replaced, and any [tool.mutmut] in pyproject.toml dropped. */
+function configure(copy, { sourcePath, files, tests }) {
+  const list = (items) => items.map((item) => `\n    ${item}`).join("");
+  const section = `[mutmut]\nsource_paths=${list([sourcePath])}\nonly_mutate=${list(files)}\npytest_add_cli_args_test_selection=${list(tests)}\n`;
+  const setupCfg = path.join(copy, "setup.cfg");
+  const own = fs.existsSync(setupCfg) ? fs.readFileSync(setupCfg, "utf8").replace(/^\[mutmut\][^[]*/m, "") : "";
+  fs.writeFileSync(setupCfg, `${own}\n${section}`);
+  const pyproject = path.join(copy, "pyproject.toml");
+  if (fs.existsSync(pyproject)) fs.writeFileSync(pyproject, fs.readFileSync(pyproject, "utf8").replace(/^\[tool\.mutmut\][^[]*/m, ""));
+}
+
+function mutmut(tool, args, cwd) {
+  const run = spawnSync(tool, args, { cwd, encoding: "utf8", maxBuffer: OUTPUT_LIMIT });
+  if (run.error || run.status !== 0) {
+    throw new Error(`mutmut ${args[0]} failed; the project's environment needs mutmut:\n${run.stderr || run.stdout || run.error}`);
+  }
+  return run.stdout;
+}
+
+/**
+ * Where a live mutant is, from `mutmut show`: its diff numbers lines from the function's start, so the
+ * function's original lines are found in the file to place it.
+ */
+function locate(copy, shown) {
+  const lines = shown.split("\n");
+  const file = lines.find((line) => line.startsWith("--- ")).slice(4);
+  const body = lines.slice(lines.findIndex((line) => line.startsWith("@@")) + 1);
+  const before = body.filter((line) => line.startsWith(" ") || line.startsWith("-"));
+  const original = before.map((line) => line.slice(1));
+  const source = fs.readFileSync(path.join(copy, file), "utf8").split("\n");
+  const start = source.findIndex((_, index) => original.every((line, offset) => source[index + offset] === line));
+  const removed = before.findIndex((line) => line.startsWith("-"));
+  const added = body.find((line) => line.startsWith("+"));
+  return {
+    file,
+    line: start + removed + 1,
+    detail: added ? added.slice(1).trim() : `removed: ${original[removed].trim()}`,
+  };
+}
+
+/** Mutation testing by mutmut from the project's environment, in a scratch copy, since mutmut writes beside the code. */
+export async function mutate({ root, config, module, files, tests }) {
+  const tool = toolBeside(pythonOf(root, config), "mutmut");
+  const { sourceRoot, topPackage } = pythonPackageOf(root, module.dir);
+  const copy = scratchCopy(root);
+  try {
+    configure(copy, { sourcePath: `${path.posix.join(sourceRoot, topPackage)}/`, files, tests });
+    mutmut(tool, ["run"], copy);
+    const statuses = mutmut(tool, ["results", "--all", "true"], copy)
+      .split("\n")
+      .map((line) => /^\s*(\S+): (.+)$/.exec(line))
+      .filter(Boolean);
+    return {
+      killed: statuses.filter(([, , status]) => CAUGHT.has(status)).length,
+      survivors: statuses.filter(([, , status]) => LIVE.has(status)).map(([, name]) => locate(copy, mutmut(tool, ["show", name], copy))),
+    };
+  } finally {
+    fs.rmSync(copy, { recursive: true, force: true });
+  }
+}

package/lib/languages/python/package.js

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Where a Python folder sits in its package tree, the way Python itself decides: the package climbs
+ * while the parent folder has an __init__.py, and the folder above the top package is the source root.
+ */
+export function pythonPackageOf(root, dir) {
+  let top = dir;
+  while (path.posix.dirname(top) !== "." && fs.existsSync(path.join(root, path.posix.dirname(top), "__init__.py"))) {
+    top = path.posix.dirname(top);
+  }
+  const sourceRoot = path.posix.dirname(top);
+  const inside = sourceRoot === "." ? dir : dir.slice(sourceRoot.length + 1);
+  return { sourceRoot, dotted: inside.split("/").join("."), topPackage: inside.split("/")[0] };
+}

package/lib/languages/python/read.js

@@ -0,0 +1,81 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { toPosix } from "../../files.js";
+import { pythonOf, toolBeside } from "./environment.js";
+import { pythonPackageOf } from "./package.js";
+
+const READ_PROJECT = path.join(path.dirname(fileURLToPath(import.meta.url)), "read_project.py");
+const OUTPUT_LIMIT = 512 * 1024 * 1024;
+
+const doorOf = (module) => `${module.dir}/${module.language.door}`;
+
+/** The plan's lists cut down to `files`. */
+function planWithin(plan, files) {
+  const own = new Set(files);
+  return Object.fromEntries(Object.entries(plan).map(([scan, value]) => [scan, Array.isArray(value) ? value.filter((file) => own.has(file)) : value]));
+}
+
+/** Python reads one source root at a time, since grimp builds one import graph per root. */
+function inspectAll(root, config, modules, plan) {
+  const bySourceRoot = Map.groupBy(modules, (module) => pythonPackageOf(root, module.dir).sourceRoot);
+  const merged = { edges: [], sightings: [], all: {} };
+  for (const [sourceRoot, own] of bySourceRoot) {
+    const read = inspect(root, config, sourceRoot, own, planWithin(plan, own.flatMap((module) => module.files)));
+    merged.edges.push(...read.edges);
+    merged.sightings.push(...read.sightings);
+    Object.assign(merged.all, read.all);
+  }
+  return merged;
+}
+
+function inspect(root, config, sourceRoot, modules, plan) {
+  const request = {
+    projectRoot: root,
+    sourceRoot,
+    packages: [...new Set(modules.map((module) => pythonPackageOf(root, module.dir).topPackage))],
+    plan,
+    doors: modules.map(doorOf),
+  };
+  const run = spawnSync(pythonOf(root, config), ["-I", READ_PROJECT], {
+    cwd: root,
+    input: JSON.stringify(request),
+    encoding: "utf8",
+    maxBuffer: OUTPUT_LIMIT,
+  });
+  if (run.status !== 0) {
+    throw new Error(`reading the Python modules failed; the project's environment needs import-linter, which brings grimp:\n${run.stderr}`);
+  }
+  return JSON.parse(run.stdout);
+}
+
+/** The complexity scan, by ruff's C901. */
+function complexitySightings(root, config, plan) {
+  if (plan.complexity.length === 0) return [];
+  const run = spawnSync(
+    toolBeside(pythonOf(root, config), "ruff"),
+    ["check", "--isolated", "--select", "C901", "--config", `lint.mccabe.max-complexity = ${plan.maxComplexity}`,
+      "--output-format", "json", ...plan.complexity],
+    { cwd: root, encoding: "utf8", maxBuffer: OUTPUT_LIMIT },
+  );
+  if (run.error || run.status > 1) throw new Error(`Python modules need ruff for the complexity check:\n${run.stderr ?? run.error}`);
+  return JSON.parse(run.stdout).map((finding) => ({
+    scan: "complexity",
+    file: toPosix(path.relative(root, finding.filename)),
+    line: finding.location.row,
+    detail: finding.message.replaceAll("`", ""),
+  }));
+}
+
+/** @type {import("../index.js").Language["analyze"]} */
+export async function analyze({ root, config, modules, plan }) {
+  const read = inspectAll(root, config, modules, plan);
+  const findings = [];
+  const api = new Map();
+  for (const module of modules) {
+    const names = read.all[doorOf(module)];
+    if (names) api.set(module.name, names);
+    else findings.push({ id: "C4", file: doorOf(module), line: null, detail: "declares no __all__, so its door has no fixed list of exports" });
+  }
+  return { edges: read.edges, sightings: [...read.sightings, ...complexitySightings(root, config, plan)], findings, api };
+}

package/lib/languages/python/read_project.py

@@ -0,0 +1,145 @@
+"""Reads a Python project for module-spec: import edges through grimp, what the scan plan's scans see, and __all__.
+
+Takes one JSON request on stdin and prints one JSON answer on stdout.
+"""
+
+import ast
+import functools
+import json
+import sys
+from pathlib import Path
+
+ASYNC_NODES = (ast.AsyncFunctionDef, ast.Await, ast.AsyncFor, ast.AsyncWith)
+ENV_NAMES = {"environ", "getenv", "putenv", "environb", "getenvb"}
+# Builtins that reach the outside without an import, so the import check cannot see them.
+IO_BUILTINS = {"open", "input"}
+# pytest fixtures whose only job is to patch.
+PATCH_FIXTURES = {"monkeypatch", "mocker"}
+
+
+def file_of(source_root, module_name):
+    base = source_root.joinpath(*module_name.split("."))
+    if base.with_suffix(".py").is_file():
+        return base.with_suffix(".py")
+    if (base / "__init__.py").is_file():
+        return base / "__init__.py"
+    return None
+
+
+def names_type_checking(test):
+    return (isinstance(test, ast.Name) and test.id == "TYPE_CHECKING") or (isinstance(test, ast.Attribute) and test.attr == "TYPE_CHECKING")
+
+
+@functools.cache
+def type_checking_lines(file):
+    """The lines of imports under `if TYPE_CHECKING:`, which never run."""
+    lines = set()
+    for node in ast.walk(ast.parse(file.read_text(encoding="utf-8"))):
+        if isinstance(node, ast.If) and names_type_checking(node.test):
+            lines.update(inner.lineno for statement in node.body for inner in ast.walk(statement) if isinstance(inner, (ast.Import, ast.ImportFrom)))
+    return lines
+
+
+def read_edges(project_root, source_root, packages):
+    import grimp
+
+    graph = grimp.build_graph(*packages, include_external_packages=True, cache_dir=None)
+    edges = []
+    for importer in sorted(graph.modules):
+        importer_file = file_of(source_root, importer)
+        if importer_file is None:
+            continue
+        for imported in sorted(graph.find_modules_directly_imported_by(importer)):
+            details = graph.get_import_details(importer=importer, imported=imported)
+            edge = {"from": importer_file.relative_to(project_root).as_posix(), "line": details[0]["line_number"] if details else None}
+            target = file_of(source_root, imported)
+            if target is None:
+                edge["external"] = imported.split(".")[0]
+                edge["std"] = edge["external"] in sys.stdlib_module_names
+            else:
+                edge["to"] = target.relative_to(project_root).as_posix()
+                if details and all(detail["line_number"] in type_checking_lines(importer_file) for detail in details):
+                    edge["typeOnly"] = True
+            edges.append(edge)
+    return edges
+
+
+def parsed(project_root, file):
+    return ast.parse((project_root / file).read_text(encoding="utf-8"), filename=file)
+
+
+def sightings(project_root, files, scan, seen):
+    """Every node in `files` that `seen` reports, as a sighting of `scan`. `seen` returns a detail, or None."""
+    return [
+        {"scan": scan, "file": file, "line": node.lineno, "detail": detail}
+        for file in files
+        for node in ast.walk(parsed(project_root, file))
+        if (detail := seen(node))
+    ]
+
+
+def waits(node):
+    return "waits" if isinstance(node, ASYNC_NODES) else None
+
+
+def uses_io_builtin(node):
+    if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id in IO_BUILTINS:
+        return f"uses {node.func.id}"
+    return None
+
+
+def patch_of(node):
+    """The patching tool a node uses, or None: unittest.mock's patch, or a patching pytest fixture."""
+    if isinstance(node, ast.ImportFrom) and node.module == "unittest.mock" and any(alias.name == "patch" for alias in node.names):
+        return "patches with unittest.mock.patch"
+    if isinstance(node, ast.Attribute) and node.attr == "patch":
+        owner = node.value
+        if (isinstance(owner, ast.Name) and owner.id == "mock") or (isinstance(owner, ast.Attribute) and owner.attr == "mock"):
+            return "patches with mock.patch"
+    if isinstance(node, ast.arg) and node.arg in PATCH_FIXTURES:
+        return f"patches with {node.arg}"
+    return None
+
+
+def reads_env(node):
+    if isinstance(node, ast.Attribute):
+        found = isinstance(node.value, ast.Name) and node.value.id == "os" and node.attr in ENV_NAMES
+    elif isinstance(node, ast.ImportFrom):
+        found = node.module == "os" and any(alias.name in ENV_NAMES for alias in node.names)
+    else:
+        found = False
+    return "reads os.environ" if found else None
+
+
+def all_names(project_root, door):
+    for node in parsed(project_root, door).body:
+        targets = node.targets if isinstance(node, ast.Assign) else [node.target] if isinstance(node, ast.AnnAssign) else []
+        if any(isinstance(target, ast.Name) and target.id == "__all__" for target in targets):
+            if isinstance(node.value, (ast.List, ast.Tuple)):
+                return sorted(element.value for element in node.value.elts if isinstance(element, ast.Constant))
+    return None
+
+
+def main():
+    request = json.load(sys.stdin)
+    project_root = Path(request["projectRoot"]).resolve()
+    source_root = (project_root / request["sourceRoot"]).resolve()
+    sys.path.insert(0, str(source_root))
+    plan = request["plan"]
+    json.dump(
+        {
+            "edges": read_edges(project_root, source_root, request["packages"]),
+            "sightings": [
+                *sightings(project_root, plan["wait"], "wait", waits),
+                *sightings(project_root, plan["io"], "io", uses_io_builtin),
+                *sightings(project_root, plan["env"], "env", reads_env),
+                *sightings(project_root, plan["patch"], "patch", patch_of),
+            ],
+            "all": {door: all_names(project_root, door) for door in request["doors"]},
+        },
+        sys.stdout,
+    )
+
+
+if __name__ == "__main__":
+    main()

package/lib/languages/python/scaffold.js

@@ -0,0 +1,19 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { copyTemplates, writeNew } from "../../templating.js";
+import { pythonPackageOf } from "./package.js";
+
+const TEMPLATES = path.join(path.dirname(fileURLToPath(import.meta.url)), "templates");
+
+export function newModule(root, dir, values) {
+  const written = [];
+  copyTemplates(root, path.join(TEMPLATES, "module"), dir, { ...values, package: pythonPackageOf(root, dir).dotted }, written);
+  return written;
+}
+
+export function newPort(root, dir, values) {
+  const written = [];
+  for (const part of ["ports", "adapters", "tests"]) writeNew(root, path.join(dir, part, "__init__.py"), "", written);
+  copyTemplates(root, path.join(TEMPLATES, "port"), dir, { ...values, package: pythonPackageOf(root, dir).dotted }, written);
+  return written;
+}

package/lib/languages/python/templates/module/__init__.py

@@ -0,0 +1,3 @@
+from .shell.create import {{Name}}, {{Name}}Deps, create_{{snake}}
+
+__all__ = ["{{Name}}", "{{Name}}Deps", "create_{{snake}}"]

package/lib/languages/python/templates/module/shell/create.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class {{Name}}Deps:
+    pass
+
+
+@dataclass(frozen=True)
+class {{Name}}:
+    pass
+
+
+def create_{{snake}}(deps: {{Name}}Deps) -> {{Name}}:
+    del deps
+    return {{Name}}()

package/lib/languages/python/templates/module/tests/test_{{snake}}.py

@@ -0,0 +1,5 @@
+from {{package}} import {{Name}}, {{Name}}Deps, create_{{snake}}
+
+
+def test_create_{{snake}}_builds_it_from_its_deps() -> None:
+    assert create_{{snake}}({{Name}}Deps()) == {{Name}}()

package/lib/languages/python/templates/port/adapters/in_memory_{{portSnake}}.py

@@ -0,0 +1,9 @@
+from ..ports.{{portSnake}} import {{Port}}
+
+
+class InMemory{{Port}}:
+    pass
+
+
+def in_memory_{{portSnake}}() -> {{Port}}:
+    return InMemory{{Port}}()

package/lib/languages/python/templates/port/ports/{{portSnake}}.py

@@ -0,0 +1,5 @@
+from typing import Protocol
+
+
+class {{Port}}(Protocol):
+    pass

package/lib/languages/python/templates/port/tests/test_{{portSnake}}_contract.py

@@ -0,0 +1,11 @@
+"""One test per promise {{Port}} makes. Every adapter joins the fixture's params, so the fake cannot drift from the real one."""
+
+import pytest
+
+from {{package}}.adapters.in_memory_{{portSnake}} import in_memory_{{portSnake}}
+from {{package}}.ports.{{portSnake}} import {{Port}}
+
+
+@pytest.fixture(params=[in_memory_{{portSnake}}])
+def {{portSnake}}(request: pytest.FixtureRequest) -> {{Port}}:
+    return request.param()

package/lib/languages/typescript/index.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import path from "node:path";
+import { mutate } from "./mutate.js";
+import { analyze } from "./read.js";
+import { newModule, newPort, newViewModule } from "./scaffold.js";
+
+const SOURCE = /\.(ts|tsx|mts|cts)$/;
+const TEST = /\.test\.[cm]?[jt]sx?$/;
+const CONTRACT_TEST = /\.contract\.test\.[cm]?[jt]sx?$/;
+
+/** @type {import("../index.js").Language} */
+export default {
+  name: "typescript",
+  aliases: ["ts"],
+  door: "index.ts",
+  isDoor: (inner) => inner === "index.ts",
+  partsDir: "",
+  isSource: (file) => SOURCE.test(file) && !file.endsWith(".d.ts"),
+  isTest: (segments) => segments.includes("__tests__") || TEST.test(segments.at(-1)),
+  isContractTest: (name) => CONTRACT_TEST.test(name),
+  contractTestFor: (file) => (file === "index.ts" ? null : `${file.replace(/\.[^.]+$/, "")}.contract.test.ts`),
+  stdlib: {
+    io: [
+      "fs", "fs/promises", "net", "http", "https", "http2", "child_process", "dgram", "dns", "dns/promises",
+      "tls", "cluster", "worker_threads", "readline", "readline/promises", "os", "process", "sqlite", "inspector", "vm",
+    ],
+    ui: [],
+  },
+  viewUi: ["react"],
+  configDefaults: {},
+  detect: (root) => ["package.json", "tsconfig.json"].some((file) => fs.existsSync(path.join(root, file))),
+  analyze,
+  mutate,
+  newModule,
+  newPort,
+  newViewModule,
+};

package/lib/languages/typescript/mutate.js

@@ -0,0 +1,95 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { kitPackageDir } from "../../tools.js";
+import { environmentForTests, testRunnerOf } from "./project.js";
+
+const OUTPUT_LIMIT = 512 * 1024 * 1024;
+/** Stryker's statuses: a timeout counts as caught, and a mutant that never compiled or ran counts as neither. */
+const CAUGHT = new Set(["Killed", "Timeout"]);
+const LIVE = new Set(["Survived", "NoCoverage"]);
+
+/** The shell command that runs only `tests`, with the project's own runner. Stryker runs it once per mutant. */
+function testCommand(root, tests) {
+  const files = tests.map((file) => JSON.stringify(file)).join(" ");
+  return testRunnerOf(root) === "vitest" ? `node_modules/.bin/vitest run ${files}` : `${JSON.stringify(process.execPath)} --test ${files}`;
+}
+
+const oneLine = (text) => {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > 80 ? `${flat.slice(0, 77)}...` : flat;
+};
+
+/**
+ * How Stryker runs the module's own tests. Under vitest, Stryker's vitest runner keeps its workers alive and runs
+ * only the tests that cover each mutant, where a command would start vitest again for every mutant. `testFiles`
+ * keeps other modules' tests out, so they cannot kill this module's mutants.
+ */
+function runnerConfig(root, tests) {
+  if (testRunnerOf(root) !== "vitest") {
+    return { testRunner: "command", commandRunner: { command: testCommand(root, tests) }, coverageAnalysis: "off", plugins: [] };
+  }
+  return {
+    testRunner: "vitest",
+    vitest: { related: false },
+    testFiles: tests,
+    coverageAnalysis: "perTest",
+    plugins: [fileURLToPath(import.meta.resolve("@stryker-mutator/vitest-runner"))],
+  };
+}
+
+/**
+ * Under vitest, Stryker keeps each mutant's verdict and the tests that covered it, so a rerun tests again only the
+ * mutants whose code or covering tests changed. The command runner reports no tests, so a weakened test would keep
+ * its old verdict there, and it reruns everything. The file sits under node_modules/.cache, which no project commits.
+ */
+function incrementalConfig(root, module) {
+  if (testRunnerOf(root) !== "vitest") return {};
+  const file = `${module.dir.replaceAll("/", "_")}.json`;
+  return { incremental: true, incrementalFile: path.join(root, "node_modules", ".cache", "module-spec", "mutate", file) };
+}
+
+/** Mutation testing by the kit's own StrykerJS, in a sandbox under the system temp folder. */
+export async function mutate({ root, module, files, tests }) {
+  const work = fs.mkdtempSync(path.join(os.tmpdir(), "module-spec-stryker-"));
+  try {
+    const report = path.join(work, "report.json");
+    const configFile = path.join(work, "stryker.config.json");
+    fs.writeFileSync(configFile, JSON.stringify({
+      ...runnerConfig(root, tests),
+      mutate: files,
+      reporters: ["json"],
+      jsonReporter: { fileName: report },
+      tempDirName: path.join(work, "sandbox"),
+      cleanTempDir: "always",
+      checkers: [],
+      // Stryker rewrites tsconfig.json with the project's own TypeScript, which from version 7 has no JS API. The kit's
+      // runners read TypeScript without it, so the rewrite is skipped by naming a file that does not exist.
+      tsconfigFile: "module-spec-skips-the-tsconfig-rewrite.json",
+      logLevel: "error",
+      ...incrementalConfig(root, module),
+    }));
+    const dir = kitPackageDir("@stryker-mutator/core");
+    const bin = path.join(dir, JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).bin.stryker);
+    const run = spawnSync(process.execPath, [bin, "run", configFile], {
+      cwd: root,
+      env: environmentForTests(),
+      encoding: "utf8",
+      maxBuffer: OUTPUT_LIMIT,
+    });
+    if (run.status !== 0 || !fs.existsSync(report)) throw new Error(`Stryker failed:\n${run.stderr || run.stdout}`);
+    const mutants = Object.entries(JSON.parse(fs.readFileSync(report, "utf8")).files).flatMap(([file, { mutants }]) =>
+      mutants.map((mutant) => ({ ...mutant, file })),
+    );
+    return {
+      killed: mutants.filter((mutant) => CAUGHT.has(mutant.status)).length,
+      survivors: mutants
+        .filter((mutant) => LIVE.has(mutant.status))
+        .map((mutant) => ({ file: mutant.file, line: mutant.location.start.line, detail: oneLine(`${mutant.mutatorName}: ${mutant.replacement ?? ""}`) })),
+    };
+  } finally {
+    fs.rmSync(work, { recursive: true, force: true });
+  }
+}

package/lib/languages/typescript/project.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+import { readIfExists } from "../../files.js";
+
+/** Every package the project's package.json depends on, dev or not, with its version range. */
+export function dependenciesOf(root) {
+  const packageJson = JSON.parse(readIfExists(path.join(root, "package.json")) ?? "{}");
+  return { ...packageJson.dependencies, ...packageJson.devDependencies };
+}
+
+/** The project's test runner, so the kit writes and runs tests with what the project already uses. */
+export function testRunnerOf(root) {
+  return dependenciesOf(root).vitest ? "vitest" : "node";
+}
+
+/**
+ * This process's environment without node:test's marker. Under a running `node --test`, a nested
+ * `node --test` sees NODE_TEST_CONTEXT, reports to a parent that is not listening, and exits 0 even when a
+ * test fails.
+ */
+export function environmentForTests() {
+  const env = { ...process.env };
+  delete env.NODE_TEST_CONTEXT;
+  return env;
+}