@jsenv/test 1.7.9 → 1.8.1

package/dist/jsenv_test.js

@@ -1,21 +1,21 @@
-import { chmod, stat, lstat, readdir, promises, unlink, openSync, closeSync, rmdir, readFile as readFile$1, writeFile as writeFile$1, writeFileSync as writeFileSync$1, mkdirSync, readFileSync, existsSync, readdirSync } from "node:fs";
+import { chmod, stat, lstat, readdir, promises, unlink, openSync, closeSync, rmdir, readFile as readFile$1, writeFile as writeFile$1, writeFileSync as writeFileSync$1, mkdirSync, readFileSync, readdirSync, existsSync } from "node:fs";
+import process$1, { memoryUsage } from "node:process";
+import v8, { takeCoverage } from "node:v8";
 import stripAnsi from "strip-ansi";
 import { URL_META, filterV8Coverage } from "./js/v8_coverage.js";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import crypto from "node:crypto";
 import { dirname } from "node:path";
-import process$1, { memoryUsage } from "node:process";
 import os from "node:os";
 import tty from "node:tty";
 import stringWidth from "string-width";
 import { readGitHubWorkflowEnv, startGithubCheckRun } from "@jsenv/github-check-run";
 import { createRequire } from "node:module";
+import { applyBabelPlugins } from "@jsenv/ast";
 import { spawn, spawnSync, fork } from "node:child_process";
 import { createServer } from "node:net";
-import v8, { takeCoverage } from "node:v8";
-import { applyBabelPlugins } from "@jsenv/ast";
-import { runInNewContext } from "node:vm";
 import wrapAnsi from "wrap-ansi";
+import { runInNewContext } from "node:vm";
 import { injectSupervisorIntoHTML, supervisorFileUrl } from "@jsenv/plugin-supervisor";
 import { SOURCEMAP, generateSourcemapDataUrl } from "@jsenv/sourcemap";
 import { findFreePort } from "@jsenv/server";
@@ -2515,6 +2515,7 @@ const createLog = ({
   const { columns = 80, rows = 24 } = stream;
 
   const log = {
+    destroyed: false,
     onVerticalOverflow: () => {},
   };
 
@@ -2579,6 +2580,9 @@ const createLog = ({
   };
 
   const write = (string, outputFromOutside = streamOutputSpy()) => {
+    if (log.destroyed) {
+      throw new Error("Cannot write log after destroy");
+    }
     if (!lastOutput) {
       doWrite(string);
       return;
@@ -2599,6 +2603,7 @@ const createLog = ({
   };
 
   const destroy = () => {
+    log.destroyed = true;
     if (streamOutputSpy) {
       streamOutputSpy(); // this uninstalls the spy
       streamOutputSpy = null;
@@ -2724,1238 +2729,1113 @@ const createTeardown = () => {
   };
 };
 
-const generateCoverageJsonFile = async ({
-  coverage,
-  coverageJsonFileUrl,
+const createCallOrderer = () => {
+  const queue = [];
+  const callWhenPreviousExecutionAreDone = (executionIndex, callback) => {
+    if (queue[executionIndex]) {
+      throw new Error(`${executionIndex} already used`);
+    }
+
+    let allBeforeAreDone = true;
+    if (executionIndex > 0) {
+      let beforeIndex = executionIndex - 1;
+      do {
+        const value = queue[beforeIndex];
+        if (!value) {
+          allBeforeAreDone = false;
+          break;
+        }
+      } while (beforeIndex--);
+    }
+    if (!allBeforeAreDone) {
+      queue[executionIndex] = callback;
+      return;
+    }
+    queue[executionIndex] = true;
+    callback();
+    let afterIndex = executionIndex + 1;
+    while (afterIndex < queue.length) {
+      const value = queue[afterIndex];
+      if (value === undefined) {
+        break;
+      }
+      if (typeof value === "function") {
+        queue[afterIndex] = true;
+        value();
+      }
+      afterIndex++;
+    }
+  };
+  return callWhenPreviousExecutionAreDone;
+};
+
+const readNodeV8CoverageDirectory = async ({
   logger,
+  signal,
+  onV8Coverage,
+  maxMsWaitingForNodeToWriteCoverageFile = 2000,
 }) => {
-  const coverageAsText = JSON.stringify(coverage, null, "  ");
-  logger.info(
-    `-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(
-      Buffer.byteLength(coverageAsText),
-    )})`,
-  );
-  await writeFile(coverageJsonFileUrl, coverageAsText);
-};
+  const NODE_V8_COVERAGE = process.env.NODE_V8_COVERAGE;
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
 
-const importWithRequire = createRequire(import.meta.url);
+  let timeSpentTrying = 0;
+  const tryReadDirectory = async () => {
+    const dirContent = readdirSync(NODE_V8_COVERAGE);
+    if (dirContent.length > 0) {
+      return dirContent;
+    }
+    if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      timeSpentTrying += 200;
+      logger.debug("retry to read coverage directory");
+      return tryReadDirectory();
+    }
+    logger.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`);
+    return dirContent;
+  };
 
-const istanbulCoverageMapFromCoverage = (coverage) => {
-  const { createCoverageMap } = importWithRequire("istanbul-lib-coverage");
+  try {
+    operation.throwIfAborted();
+    const dirContent = await tryReadDirectory();
 
-  const coverageAdjusted = {};
-  Object.keys(coverage).forEach((key) => {
-    coverageAdjusted[key.slice(2)] = {
-      ...coverage[key],
-      path: key.slice(2),
-    };
-  });
+    const coverageDirectoryUrl = assertAndNormalizeDirectoryUrl(
+      NODE_V8_COVERAGE,
+      "NODE_V8_COVERAGE",
+    );
 
-  const coverageMap = createCoverageMap(coverageAdjusted);
-  return coverageMap;
+    await dirContent.reduce(async (previous, dirEntry) => {
+      operation.throwIfAborted();
+      await previous;
+
+      const dirEntryUrl = new URL(dirEntry, coverageDirectoryUrl);
+      const tryReadJsonFile = async () => {
+        const fileContent = String(readFileSync(dirEntryUrl));
+        if (fileContent === "") {
+          if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            timeSpentTrying += 200;
+            return tryReadJsonFile();
+          }
+          console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`);
+          return null;
+        }
+
+        try {
+          const fileAsJson = JSON.parse(fileContent);
+          return fileAsJson;
+        } catch (e) {
+          if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            timeSpentTrying += 200;
+            return tryReadJsonFile();
+          }
+          console.warn(
+            createDetailedMessage(`Error while reading coverage file`, {
+              "error stack": e.stack,
+              "file": dirEntryUrl,
+            }),
+          );
+          return null;
+        }
+      };
+
+      const fileContent = await tryReadJsonFile();
+      if (fileContent) {
+        await onV8Coverage(fileContent);
+      }
+    }, Promise.resolve());
+  } finally {
+    await operation.end();
+  }
 };
 
-const generateCoverageHtmlDirectory = async (
-  coverage,
-  {
-    rootDirectoryUrl,
-    coverageHtmlDirectoryRelativeUrl,
-    coverageReportSkipEmpty,
-    coverageReportSkipFull,
-  },
-) => {
-  const libReport = importWithRequire("istanbul-lib-report");
-  const reports = importWithRequire("istanbul-reports");
+const importWithRequire = createRequire(import.meta.url);
 
-  const context = libReport.createContext({
-    dir: fileURLToPath(rootDirectoryUrl),
-    coverageMap: istanbulCoverageMapFromCoverage(coverage),
-    sourceFinder: (path) =>
-      readFileSync(new URL(path, rootDirectoryUrl), "utf8"),
-  });
+const composeTwoV8Coverages = (firstV8Coverage, secondV8Coverage) => {
+  if (secondV8Coverage.result.length === 0) {
+    return firstV8Coverage;
+  }
 
-  const report = reports.create("html", {
-    skipEmpty: coverageReportSkipEmpty,
-    skipFull: coverageReportSkipFull,
-    subdir: coverageHtmlDirectoryRelativeUrl,
-  });
-  report.execute(context);
+  // eslint-disable-next-line import/no-unresolved
+  const { mergeProcessCovs } = importWithRequire("@c88/v8-coverage");
+  // "mergeProcessCovs" do not preserves source-map-cache during the merge
+  // so we store sourcemap cache now
+  const sourceMapCache = {};
+  const visit = (coverageReport) => {
+    if (coverageReport["source-map-cache"]) {
+      Object.assign(sourceMapCache, coverageReport["source-map-cache"]);
+    }
+  };
+  visit(firstV8Coverage);
+  visit(secondV8Coverage);
+  const v8Coverage = mergeProcessCovs([firstV8Coverage, secondV8Coverage]);
+  v8Coverage["source-map-cache"] = sourceMapCache;
+
+  return v8Coverage;
 };
 
-const generateCoverageTextLog = (
-  coverage,
-  { coverageReportSkipEmpty, coverageReportSkipFull },
+const composeTwoFileByFileIstanbulCoverages = (
+  firstFileByFileIstanbulCoverage,
+  secondFileByFileIstanbulCoverage,
 ) => {
-  const libReport = importWithRequire("istanbul-lib-report");
-  const reports = importWithRequire("istanbul-reports");
-
-  const context = libReport.createContext({
-    coverageMap: istanbulCoverageMapFromCoverage(coverage),
+  const fileByFileIstanbulCoverage = {};
+  Object.keys(firstFileByFileIstanbulCoverage).forEach((key) => {
+    fileByFileIstanbulCoverage[key] = firstFileByFileIstanbulCoverage[key];
   });
-  const report = reports.create("text", {
-    skipEmpty: coverageReportSkipEmpty,
-    skipFull: coverageReportSkipFull,
+  Object.keys(secondFileByFileIstanbulCoverage).forEach((key) => {
+    const firstCoverage = firstFileByFileIstanbulCoverage[key];
+    const secondCoverage = secondFileByFileIstanbulCoverage[key];
+    fileByFileIstanbulCoverage[key] = firstCoverage
+      ? merge(firstCoverage, secondCoverage)
+      : secondCoverage;
   });
-  report.execute(context);
-};
 
-const pingServer = async (url) => {
-  const server = createServer();
-  const { hostname, port } = new URL(url);
+  return fileByFileIstanbulCoverage;
+};
 
-  try {
-    await new Promise((resolve, reject) => {
-      server.on("error", reject);
-      server.on("listening", () => {
-        resolve();
-      });
-      server.listen(port, hostname);
-    });
-  } catch (error) {
-    if (error && error.code === "EADDRINUSE") {
-      return true;
-    }
-    if (error && error.code === "EACCES") {
-      return true;
-    }
-    throw error;
-  }
-  await new Promise((resolve, reject) => {
-    server.on("error", reject);
-    server.on("close", resolve);
-    server.close();
-  });
-  return false;
+const merge = (firstIstanbulCoverage, secondIstanbulCoverage) => {
+  const { createFileCoverage } = importWithRequire("istanbul-lib-coverage");
+  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage);
+  istanbulFileCoverageObject.merge(secondIstanbulCoverage);
+  const istanbulCoverage = istanbulFileCoverageObject.toJSON();
+  return istanbulCoverage;
 };
 
-const startServerUsingCommand = async (
-  webServer,
-  { signal, allocatedMs, logger, teardown },
-) => {
-  const spawnedProcess = spawn(webServer.command, [], {
-    // On non-windows platforms, `detached: true` makes child process a leader of a new
-    // process group, making it possible to kill child process tree with `.kill(-pid)` command.
-    // @see https://nodejs.org/api/child_process.html#child_process_options_detached
-    detached: process.platform !== "win32",
-    stdio: ["pipe", "pipe", "pipe"],
-    shell: true,
-    cwd: webServer.cwd,
-  });
-  if (!spawnedProcess.pid) {
-    await new Promise((resolve, reject) => {
-      spawnedProcess.once("error", (error) => {
-        reject(new Error(`Failed to launch: ${error}`));
-      });
-    });
-  }
+const v8CoverageToIstanbul = async (v8Coverage, { signal }) => {
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
 
-  let errorReceived = false;
-  const errorPromise = new Promise((resolve, reject) => {
-    spawnedProcess.on("error", (e) => {
-      errorReceived = true;
-      reject(e);
-    });
-  });
+  try {
+    const v8ToIstanbul = importWithRequire("v8-to-istanbul");
+    const sourcemapCache = v8Coverage["source-map-cache"];
+    let istanbulCoverageComposed = null;
 
-  // const stdout = readline.createInterface({ input: spawnedProcess.stdout });
-  // stdout.on("line", () => {
-  //   logger.debug(`[pid=${spawnedProcess.pid}][out] ${data}`);
-  // });
-  // const stderr = readline.createInterface({ input: spawnedProcess.stderr });
-  // stderr.on("line", (data) => {
-  //   logger.debug(`[pid=${spawnedProcess.pid}][err] ${data}`);
-  // });
-  let processClosed = false;
-  const closedPromise = new Promise((resolve) => {
-    spawnedProcess.once("exit", (exitCode, signal) => {
-      logger.debug(
-        `[pid=${spawnedProcess.pid}] <process did exit: exitCode=${exitCode}, signal=${signal}>`,
-      );
-      processClosed = true;
-      resolve();
-    });
-  });
-  const killProcess = async () => {
-    logger.debug(`[pid=${spawnedProcess.pid}] <kill>`);
-    if (!spawnedProcess.pid || spawnedProcess.killed || processClosed) {
-      logger.debug(
-        `[pid=${spawnedProcess.pid}] <skipped force kill spawnedProcess.killed=${spawnedProcess.killed} processClosed=${processClosed}>`,
-      );
-      return;
-    }
-    logger.debug(`[pid=${spawnedProcess.pid}] <will force kill>`);
-    // Force kill the browser.
-    try {
-      if (process.platform === "win32") {
-        const taskkillProcess = spawnSync(
-          `taskkill /pid ${spawnedProcess.pid} /T /F`,
-          { shell: true },
-        );
-        const [stdout, stderr] = [
-          taskkillProcess.stdout.toString(),
-          taskkillProcess.stderr.toString(),
-        ];
-        if (stdout)
-          logger.debug(
-            `[pid=${spawnedProcess.pid}] taskkill stdout: ${stdout}`,
-          );
-        if (stderr)
-          logger.info(`[pid=${spawnedProcess.pid}] taskkill stderr: ${stderr}`);
-      } else {
-        process.kill(-spawnedProcess.pid, "SIGKILL");
+    await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
+      operation.throwIfAborted();
+      await previous;
+
+      const { source } = fileV8Coverage;
+      let sources;
+      // when v8 coverage comes from playwright (chromium) v8Coverage.source is set
+      if (typeof source === "string") {
+        sources = { source };
       }
-    } catch (e) {
-      logger.info(
-        `[pid=${spawnedProcess.pid}] exception while trying to kill process: ${e}`,
+      // when v8 coverage comes from Node.js, the source can be read from sourcemapCache
+      else if (sourcemapCache) {
+        sources = sourcesFromSourceMapCache(fileV8Coverage.url, sourcemapCache);
+      }
+      const path = urlToFileSystemPath(fileV8Coverage.url);
+
+      const converter = v8ToIstanbul(
+        path,
+        // wrapperLength is undefined we don't need it
+        // https://github.com/istanbuljs/v8-to-istanbul/blob/2b54bc97c5edf8a37b39a171ec29134ba9bfd532/lib/v8-to-istanbul.js#L27
+        undefined,
+        sources,
       );
-      // the process might have already stopped
-    }
-    await closedPromise;
-  };
+      await converter.load();
 
-  const startOperation = Abort.startOperation();
-  startOperation.addAbortSignal(signal);
-  const timeoutAbortSource = startOperation.timeout(allocatedMs);
-  startOperation.addAbortCallback(killProcess);
-  teardown.addCallback(killProcess);
+      converter.applyCoverage(fileV8Coverage.functions);
+      const istanbulCoverage = converter.toIstanbul();
 
-  const startedPromise = (async () => {
-    const logScale = [100, 250, 500];
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      if (errorReceived) {
-        break;
-      }
-      const connected = await pingServer(webServer.origin);
-      if (connected) {
-        break;
-      }
-      startOperation.throwIfAborted();
-      const delay = logScale.shift() || 1000;
-      logger.debug(`Waiting ${delay}ms`);
-      await new Promise((x) => setTimeout(x, delay));
-    }
-  })();
+      istanbulCoverageComposed = istanbulCoverageComposed
+        ? composeTwoFileByFileIstanbulCoverages(
+            istanbulCoverageComposed,
+            istanbulCoverage,
+          )
+        : istanbulCoverage;
+    }, Promise.resolve());
 
-  try {
-    await Promise.race([errorPromise, startedPromise]);
-  } catch (e) {
-    if (Abort.isAbortError(e)) {
-      if (timeoutAbortSource.signal.aborted) {
-        // aborted by timeout
-        throw new Error(
-          `"${webServer.command}" command did not start a server in less than ${allocatedMs}ms`,
-        );
-      }
-      if (signal.aborted) {
-        // aborted from outside
-        return;
-      }
+    if (!istanbulCoverageComposed) {
+      return {};
     }
-    throw e;
+    istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed);
+    return istanbulCoverageComposed;
   } finally {
-    await startOperation.end();
+    await operation.end();
   }
 };
 
-const startServerUsingModuleUrl = async (webServer, params) => {
-  if (!existsSync(new URL(webServer.moduleUrl))) {
-    throw new Error(`"${webServer.moduleUrl}" does not lead to a file`);
-  }
-  return startServerUsingCommand(
-    {
-      ...webServer,
-      command: `node ${fileURLToPath(webServer.moduleUrl)}`,
-    },
-    params,
-  );
+const markAsConvertedFromV8 = (fileByFileCoverage) => {
+  const fileByFileMarked = {};
+  Object.keys(fileByFileCoverage).forEach((key) => {
+    const fileCoverage = fileByFileCoverage[key];
+    fileByFileMarked[key] = {
+      ...fileCoverage,
+      fromV8: true,
+    };
+  });
+  return fileByFileMarked;
 };
 
-const basicFetch = async (
-  url,
-  { rejectUnauthorized = true, method = "GET", headers = {} } = {},
-) => {
-  let requestModule;
-  if (url.startsWith("http:")) {
-    requestModule = await import("node:http");
-  } else {
-    requestModule = await import("node:https");
+const sourcesFromSourceMapCache = (url, sourceMapCache) => {
+  const sourceMapAndLineLengths = sourceMapCache[url];
+  if (!sourceMapAndLineLengths) {
+    return {};
   }
-  const { request } = requestModule;
 
-  const urlObject = new URL(url);
+  const { data, lineLengths } = sourceMapAndLineLengths;
+  // See: https://github.com/nodejs/node/pull/34305
+  if (!data) {
+    return undefined;
+  }
 
-  return new Promise((resolve, reject) => {
-    const req = request({
-      rejectUnauthorized,
-      hostname: urlObject.hostname,
-      port: urlObject.port,
-      path: urlObject.pathname,
-      method,
-      headers,
-    });
-    req.on("response", (response) => {
-      resolve({
-        status: response.statusCode,
-        headers: response.headers,
-        json: () => {
-          req.setTimeout(0);
-          req.destroy();
-          return new Promise((resolve) => {
-            if (response.headers["content-type"] !== "application/json") {
-              console.warn("not json");
-            }
-            let responseBody = "";
-            response.setEncoding("utf8");
-            response.on("data", (chunk) => {
-              responseBody += chunk;
-            });
-            response.on("end", () => {
-              resolve(JSON.parse(responseBody));
-            });
-            response.on("error", (e) => {
-              reject(e);
-            });
-          });
-        },
-      });
-    });
-    req.on("error", reject);
-    req.end();
+  const sources = {
+    sourcemap: data,
+    ...(lineLengths ? { source: sourcesFromLineLengths(lineLengths) } : {}),
+  };
+  return sources;
+};
+
+const sourcesFromLineLengths = (lineLengths) => {
+  let source = "";
+  lineLengths.forEach((length) => {
+    source += `${"".padEnd(length, ".")}\n`;
   });
+  return source;
 };
 
-const assertAndNormalizeWebServer = async (
-  webServer,
-  { signal, logger, teardown },
+const composeV8AndIstanbul = (
+  v8FileByFileCoverage,
+  istanbulFileByFileCoverage,
+  { coverageV8ConflictWarning },
 ) => {
-  if (!webServer) {
-    throw new TypeError(
-      `webServer is required when running tests on browser(s)`,
-    );
-  }
-  const unexpectedParamNames = Object.keys(webServer).filter((key) => {
-    return ![
-      "origin",
-      "moduleUrl",
-      "command",
-      "cwd",
-      "rootDirectoryUrl",
-    ].includes(key);
+  const fileByFileCoverage = {};
+  const v8Files = Object.keys(v8FileByFileCoverage);
+  const istanbulFiles = Object.keys(istanbulFileByFileCoverage);
+
+  v8Files.forEach((key) => {
+    fileByFileCoverage[key] = v8FileByFileCoverage[key];
   });
-  if (unexpectedParamNames.length > 0) {
-    throw new TypeError(
-      `${unexpectedParamNames.join(",")}: there is no such param to webServer`,
-    );
-  }
-  if (typeof webServer.origin !== "string") {
-    throw new TypeError(
-      `webServer.origin must be a string, got ${webServer.origin}`,
-    );
-  }
-  await ensureWebServerIsStarted(webServer, {
-    signal,
-    teardown,
-    logger,
-  });
-  const { headers } = await basicFetch(webServer.origin, {
-    method: "GET",
-    rejectUnauthorized: false,
-    headers: {
-      "x-server-inspect": "1",
-    },
-  });
-  if (String(headers["server"]).includes("jsenv_dev_server")) {
-    webServer.isJsenvDevServer = true;
-    const { json } = await basicFetch(`${webServer.origin}/__params__.json`, {
-      rejectUnauthorized: false,
-    });
-    if (webServer.rootDirectoryUrl === undefined) {
-      const jsenvDevServerParams = await json();
-      webServer.rootDirectoryUrl = jsenvDevServerParams.sourceDirectoryUrl;
+  istanbulFiles.forEach((key) => {
+    const v8Coverage = v8FileByFileCoverage[key];
+    if (v8Coverage) {
+      if (coverageV8ConflictWarning) {
+        console.warn(
+          createDetailedMessage(
+            `Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`,
+            {
+              "details": `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
+              "suggestion":
+                "disable this warning with coverageV8ConflictWarning: false",
+              "suggestion 2": `force coverage using istanbul with coverageMethodForBrowsers: "istanbul"`,
+            },
+          ),
+        );
+      }
+      fileByFileCoverage[key] = v8Coverage;
     } else {
-      webServer.rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
-        webServer.rootDirectoryUrl,
-        "webServer.rootDirectoryUrl",
-      );
+      fileByFileCoverage[key] = istanbulFileByFileCoverage[key];
     }
-  } else {
-    webServer.rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
-      webServer.rootDirectoryUrl,
-      "webServer.rootDirectoryUrl",
-    );
-  }
+  });
+
+  return fileByFileCoverage;
 };
 
-const ensureWebServerIsStarted = async (
-  webServer,
-  { signal, teardown, logger, allocatedMs = 5_000 },
+const normalizeFileByFileCoveragePaths = (
+  fileByFileCoverage,
+  rootDirectoryUrl,
 ) => {
-  const aServerIsListening = await pingServer(webServer.origin);
-  if (aServerIsListening) {
-    return;
-  }
-  if (webServer.moduleUrl) {
-    await startServerUsingModuleUrl(webServer, {
-      signal,
-      allocatedMs,
-      teardown,
-      logger,
-    });
-    return;
-  }
-  if (webServer.command) {
-    await startServerUsingCommand(webServer, {
-      signal,
-      allocatedMs,
-      teardown,
-      logger,
-    });
-    return;
-  }
-  throw new TypeError(
-    `webServer.moduleUrl or webServer.command is required as there is no server listening "${webServer.origin}"`,
-  );
+  const fileByFileNormalized = {};
+  Object.keys(fileByFileCoverage).forEach((key) => {
+    const fileCoverage = fileByFileCoverage[key];
+    const { path } = fileCoverage;
+    const url = isFileSystemPath(path)
+      ? fileSystemPathToUrl(path)
+      : new URL(path, rootDirectoryUrl).href;
+    const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
+    fileByFileNormalized[`./${relativeUrl}`] = {
+      ...fileCoverage,
+      path: `./${relativeUrl}`,
+    };
+  });
+  return fileByFileNormalized;
 };
 
-const executionStepsFromTestPlan = async ({
+const listRelativeFileUrlToCover = async ({
   signal,
   rootDirectoryUrl,
-  testPlan,
+  coverageConfig,
 }) => {
+  const matchingFileResultArray = await collectFiles({
+    signal,
+    directoryUrl: rootDirectoryUrl,
+    associations: { cover: coverageConfig },
+    predicate: ({ cover }) => cover,
+  });
+  return matchingFileResultArray.map(({ relativeUrl }) => relativeUrl);
+};
+
+// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
+
+const babelPluginInstrument = (api, { useInlineSourceMaps = false }) => {
+  const { programVisitor } = importWithRequire("istanbul-lib-instrument");
+  const { types } = api;
+
+  return {
+    name: "transform-instrument",
+    visitor: {
+      Program: {
+        enter(path, state) {
+          const { file } = state;
+          const { opts } = file;
+          let inputSourceMap;
+          if (useInlineSourceMaps) {
+            // https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e15643d249a2985e4387e4308022053b2cd0ad#diff-1fdf421c05c1140f6d71444ea2b27638R65
+            inputSourceMap =
+              opts.inputSourceMap || file.inputMap
+                ? file.inputMap.sourcemap
+                : null;
+          } else {
+            inputSourceMap = opts.inputSourceMap;
+          }
+          const __dv__ = programVisitor(
+            types,
+            opts.filenameRelative || opts.filename,
+            {
+              coverageVariable: "__coverage__",
+              inputSourceMap,
+            },
+          );
+          __dv__.enter(path);
+          file.metadata.__dv__ = __dv__;
+        },
+
+        exit(path, state) {
+          const { __dv__ } = state.file.metadata;
+          if (!__dv__) {
+            return;
+          }
+          const object = __dv__.exit(path);
+          // object got two properties: fileCoverage and sourceMappingURL
+          state.file.metadata.coverage = object.fileCoverage;
+        },
+      },
+    },
+  };
+};
+
+const relativeUrlToEmptyCoverage = async (
+  relativeUrl,
+  { signal, rootDirectoryUrl },
+) => {
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+
   try {
-    const fileResultArray = await collectFiles({
-      signal,
-      directoryUrl: rootDirectoryUrl,
-      associations: { testPlan },
-      predicate: ({ testPlan }) => testPlan,
+    const fileUrl = resolveUrl(relativeUrl, rootDirectoryUrl);
+    const content = await readFile(fileUrl, { as: "string" });
+
+    operation.throwIfAborted();
+    const { metadata } = await applyBabelPlugins({
+      babelPlugins: [babelPluginInstrument],
+      input: content,
+      inputIsJsModule: true,
+      inputUrl: fileUrl,
     });
-    const executionSteps = [];
-    fileResultArray.forEach(({ relativeUrl, meta }) => {
-      const fileExecutionSteps = generateFileExecutionSteps({
-        fileRelativeUrl: relativeUrl,
-        filePlan: meta.testPlan,
-      });
-      executionSteps.push(...fileExecutionSteps);
+    const { coverage } = metadata;
+    if (!coverage) {
+      throw new Error(`missing coverage for file`);
+    }
+    // https://github.com/gotwarlost/istanbul/blob/bc84c315271a5dd4d39bcefc5925cfb61a3d174a/lib/command/common/run-with-cover.js#L229
+    Object.keys(coverage.s).forEach(function (key) {
+      coverage.s[key] = 0;
     });
-    return executionSteps;
+    return coverage;
   } catch (e) {
-    if (Abort.isAbortError(e)) {
-      return {
-        aborted: true,
-        planSummary: {},
-        planReport: {},
-        planCoverage: null,
-      };
+    if (e && e.code === "PARSE_ERROR") {
+      // return an empty coverage for that file when
+      // it contains a syntax error
+      return createEmptyCoverage(relativeUrl);
     }
     throw e;
+  } finally {
+    await operation.end();
   }
 };
 
-const generateFileExecutionSteps = ({ fileRelativeUrl, filePlan }) => {
-  const fileExecutionSteps = [];
-  Object.keys(filePlan).forEach((executionName) => {
-    const stepConfig = filePlan[executionName];
-    if (stepConfig === null || stepConfig === undefined) {
-      return;
-    }
-    if (typeof stepConfig !== "object") {
-      throw new TypeError(
-        createDetailedMessage(
-          `found unexpected value in plan, they must be object`,
-          {
-            ["file relative path"]: fileRelativeUrl,
-            ["execution name"]: executionName,
-            ["value"]: stepConfig,
-          },
-        ),
-      );
-    }
-    fileExecutionSteps.push({
-      executionName,
-      fileRelativeUrl,
-      ...stepConfig,
-    });
-  });
-  return fileExecutionSteps;
+const createEmptyCoverage = (relativeUrl) => {
+  const { createFileCoverage } = importWithRequire("istanbul-lib-coverage");
+  return createFileCoverage(relativeUrl).toJSON();
 };
 
-const readNodeV8CoverageDirectory = async ({
-  logger,
+const getMissingFileByFileCoverage = async ({
   signal,
-  onV8Coverage,
-  maxMsWaitingForNodeToWriteCoverageFile = 2000,
+  rootDirectoryUrl,
+  coverageConfig,
+  fileByFileCoverage,
 }) => {
-  const NODE_V8_COVERAGE = process.env.NODE_V8_COVERAGE;
+  const relativeUrlsToCover = await listRelativeFileUrlToCover({
+    signal,
+    rootDirectoryUrl,
+    coverageConfig,
+  });
+  const relativeUrlsMissing = relativeUrlsToCover.filter((relativeUrlToCover) =>
+    Object.keys(fileByFileCoverage).every((key) => {
+      return key !== `./${relativeUrlToCover}`;
+    }),
+  );
+
   const operation = Abort.startOperation();
   operation.addAbortSignal(signal);
-
-  let timeSpentTrying = 0;
-  const tryReadDirectory = async () => {
-    const dirContent = readdirSync(NODE_V8_COVERAGE);
-    if (dirContent.length > 0) {
-      return dirContent;
-    }
-    if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      timeSpentTrying += 200;
-      logger.debug("retry to read coverage directory");
-      return tryReadDirectory();
-    }
-    logger.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`);
-    return dirContent;
-  };
-
-  try {
+  const missingFileByFileCoverage = {};
+  await relativeUrlsMissing.reduce(async (previous, relativeUrlMissing) => {
     operation.throwIfAborted();
-    const dirContent = await tryReadDirectory();
-
-    const coverageDirectoryUrl = assertAndNormalizeDirectoryUrl(
-      NODE_V8_COVERAGE,
-      "NODE_V8_COVERAGE",
-    );
+    await previous;
+    await operation.withSignal(async (signal) => {
+      const emptyCoverage = await relativeUrlToEmptyCoverage(
+        relativeUrlMissing,
+        {
+          signal,
+          rootDirectoryUrl,
+        },
+      );
+      missingFileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage;
+    });
+  }, Promise.resolve());
+  return missingFileByFileCoverage;
+};
 
-    await dirContent.reduce(async (previous, dirEntry) => {
-      operation.throwIfAborted();
-      await previous;
+const reportToCoverage = async (
+  report,
+  {
+    signal,
+    logger,
+    rootDirectoryUrl,
+    coverageConfig,
+    coverageIncludeMissing,
+    coverageMethodForNodeJs,
+    coverageV8ConflictWarning,
+  },
+) => {
+  // collect v8 and istanbul coverage from executions
+  let { v8Coverage, fileByFileIstanbulCoverage } = await getCoverageFromReport({
+    signal,
+    report,
+    onMissing: ({ file, executionResult, executionName }) => {
+      // several reasons not to have coverage here:
+      // 1. the file we executed did not import an instrumented file.
+      // - a test file without import
+      // - a test file importing only file excluded from coverage
+      // - a coverDescription badly configured so that we don't realize
+      // a file should be covered
 
-      const dirEntryUrl = new URL(dirEntry, coverageDirectoryUrl);
-      const tryReadJsonFile = async () => {
-        const fileContent = String(readFileSync(dirEntryUrl));
-        if (fileContent === "") {
-          if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
-            await new Promise((resolve) => setTimeout(resolve, 200));
-            timeSpentTrying += 200;
-            return tryReadJsonFile();
-          }
-          console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`);
-          return null;
-        }
+      // 2. the file we wanted to executed timedout
+      // - infinite loop
+      // - too extensive operation
+      // - a badly configured or too low allocatedMs for that execution.
 
-        try {
-          const fileAsJson = JSON.parse(fileContent);
-          return fileAsJson;
-        } catch (e) {
-          if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
-            await new Promise((resolve) => setTimeout(resolve, 200));
-            timeSpentTrying += 200;
-            return tryReadJsonFile();
-          }
-          console.warn(
-            createDetailedMessage(`Error while reading coverage file`, {
-              "error stack": e.stack,
-              "file": dirEntryUrl,
-            }),
-          );
-          return null;
-        }
-      };
+      // 3. the file we wanted to execute contains syntax-error
 
-      const fileContent = await tryReadJsonFile();
-      if (fileContent) {
-        await onV8Coverage(fileContent);
+      // in any scenario we are fine because
+      // coverDescription will generate empty coverage for files
+      // that were suppose to be coverage but were not.
+      if (
+        executionResult.status === "completed" &&
+        executionResult.type === "node" &&
+        coverageMethodForNodeJs !== "NODE_V8_COVERAGE"
+      ) {
+        logger.warn(
+          `"${executionName}" execution of ${file} did not properly write coverage into ${executionResult.coverageFileUrl}`,
+        );
       }
-    }, Promise.resolve());
-  } finally {
-    await operation.end();
-  }
-};
+    },
+  });
 
-const composeTwoV8Coverages = (firstV8Coverage, secondV8Coverage) => {
-  if (secondV8Coverage.result.length === 0) {
-    return firstV8Coverage;
+  if (coverageMethodForNodeJs === "NODE_V8_COVERAGE") {
+    await readNodeV8CoverageDirectory({
+      logger,
+      signal,
+      onV8Coverage: async (nodeV8Coverage) => {
+        const nodeV8CoverageLight = await filterV8Coverage(nodeV8Coverage, {
+          rootDirectoryUrl,
+          coverageConfig,
+        });
+        v8Coverage = v8Coverage
+          ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
+          : nodeV8CoverageLight;
+      },
+    });
   }
 
-  // eslint-disable-next-line import/no-unresolved
-  const { mergeProcessCovs } = importWithRequire("@c88/v8-coverage");
-  // "mergeProcessCovs" do not preserves source-map-cache during the merge
-  // so we store sourcemap cache now
-  const sourceMapCache = {};
-  const visit = (coverageReport) => {
-    if (coverageReport["source-map-cache"]) {
-      Object.assign(sourceMapCache, coverageReport["source-map-cache"]);
-    }
-  };
-  visit(firstV8Coverage);
-  visit(secondV8Coverage);
-  const v8Coverage = mergeProcessCovs([firstV8Coverage, secondV8Coverage]);
-  v8Coverage["source-map-cache"] = sourceMapCache;
+  // try to merge v8 with istanbul, if any
+  let fileByFileCoverage;
+  if (v8Coverage) {
+    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage, {
+      signal,
+    });
 
-  return v8Coverage;
-};
+    v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
+      v8FileByFileCoverage,
+      rootDirectoryUrl,
+    );
 
-const composeTwoFileByFileIstanbulCoverages = (
-  firstFileByFileIstanbulCoverage,
-  secondFileByFileIstanbulCoverage,
-) => {
-  const fileByFileIstanbulCoverage = {};
-  Object.keys(firstFileByFileIstanbulCoverage).forEach((key) => {
-    fileByFileIstanbulCoverage[key] = firstFileByFileIstanbulCoverage[key];
-  });
-  Object.keys(secondFileByFileIstanbulCoverage).forEach((key) => {
-    const firstCoverage = firstFileByFileIstanbulCoverage[key];
-    const secondCoverage = secondFileByFileIstanbulCoverage[key];
-    fileByFileIstanbulCoverage[key] = firstCoverage
-      ? merge(firstCoverage, secondCoverage)
-      : secondCoverage;
-  });
+    if (fileByFileIstanbulCoverage) {
+      fileByFileIstanbulCoverage = normalizeFileByFileCoveragePaths(
+        fileByFileIstanbulCoverage,
+        rootDirectoryUrl,
+      );
+      fileByFileCoverage = composeV8AndIstanbul(
+        v8FileByFileCoverage,
+        fileByFileIstanbulCoverage,
+        { coverageV8ConflictWarning },
+      );
+    } else {
+      fileByFileCoverage = v8FileByFileCoverage;
+    }
+  }
+  // get istanbul only
+  else if (fileByFileIstanbulCoverage) {
+    fileByFileCoverage = normalizeFileByFileCoveragePaths(
+      fileByFileIstanbulCoverage,
+      rootDirectoryUrl,
+    );
+  }
+  // no coverage found in execution (or zero file where executed)
+  else {
+    fileByFileCoverage = {};
+  }
 
-  return fileByFileIstanbulCoverage;
-};
+  // now add coverage for file not covered
+  if (coverageIncludeMissing) {
+    const missingFileByFileCoverage = await getMissingFileByFileCoverage({
+      signal,
+      rootDirectoryUrl,
+      coverageConfig,
+      fileByFileCoverage,
+    });
+    Object.assign(
+      fileByFileCoverage,
+      normalizeFileByFileCoveragePaths(
+        missingFileByFileCoverage,
+        rootDirectoryUrl,
+      ),
+    );
+  }
 
-const merge = (firstIstanbulCoverage, secondIstanbulCoverage) => {
-  const { createFileCoverage } = importWithRequire("istanbul-lib-coverage");
-  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage);
-  istanbulFileCoverageObject.merge(secondIstanbulCoverage);
-  const istanbulCoverage = istanbulFileCoverageObject.toJSON();
-  return istanbulCoverage;
+  return fileByFileCoverage;
 };
 
-const v8CoverageToIstanbul = async (v8Coverage, { signal }) => {
+const getCoverageFromReport = async ({ signal, report, onMissing }) => {
   const operation = Abort.startOperation();
   operation.addAbortSignal(signal);
 
   try {
-    const v8ToIstanbul = importWithRequire("v8-to-istanbul");
-    const sourcemapCache = v8Coverage["source-map-cache"];
-    let istanbulCoverageComposed = null;
+    let v8Coverage;
+    let fileByFileIstanbulCoverage;
 
-    await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
+    // collect v8 and istanbul coverage from executions
+    await Object.keys(report).reduce(async (previous, file) => {
       operation.throwIfAborted();
       await previous;
 
-      const { source } = fileV8Coverage;
-      let sources;
-      // when v8 coverage comes from playwright (chromium) v8Coverage.source is set
-      if (typeof source === "string") {
-        sources = { source };
-      }
-      // when v8 coverage comes from Node.js, the source can be read from sourcemapCache
-      else if (sourcemapCache) {
-        sources = sourcesFromSourceMapCache(fileV8Coverage.url, sourcemapCache);
-      }
-      const path = urlToFileSystemPath(fileV8Coverage.url);
+      const executionResultForFile = report[file];
+      await Object.keys(executionResultForFile).reduce(
+        async (previous, executionName) => {
+          operation.throwIfAborted();
+          await previous;
 
-      const converter = v8ToIstanbul(
-        path,
-        // wrapperLength is undefined we don't need it
-        // https://github.com/istanbuljs/v8-to-istanbul/blob/2b54bc97c5edf8a37b39a171ec29134ba9bfd532/lib/v8-to-istanbul.js#L27
-        undefined,
-        sources,
-      );
-      await converter.load();
-
-      converter.applyCoverage(fileV8Coverage.functions);
-      const istanbulCoverage = converter.toIstanbul();
+          const executionResultForFileOnRuntime =
+            executionResultForFile[executionName];
+          const { coverageFileUrl } = executionResultForFileOnRuntime;
+          let executionCoverage;
+          try {
+            executionCoverage = JSON.parse(
+              String(readFileSync(new URL(coverageFileUrl))),
+            );
+          } catch (e) {
+            if (e.code === "ENOENT" || e.name === "SyntaxError") {
+              onMissing({
+                executionName,
+                file,
+                executionResult: executionResultForFileOnRuntime,
+              });
+              return;
+            }
+            throw e;
+          }
 
-      istanbulCoverageComposed = istanbulCoverageComposed
-        ? composeTwoFileByFileIstanbulCoverages(
-            istanbulCoverageComposed,
-            istanbulCoverage,
-          )
-        : istanbulCoverage;
+          if (isV8Coverage(executionCoverage)) {
+            v8Coverage = v8Coverage
+              ? composeTwoV8Coverages(v8Coverage, executionCoverage)
+              : executionCoverage;
+          } else {
+            fileByFileIstanbulCoverage = fileByFileIstanbulCoverage
+              ? composeTwoFileByFileIstanbulCoverages(
+                  fileByFileIstanbulCoverage,
+                  executionCoverage,
+                )
+              : executionCoverage;
+          }
+        },
+        Promise.resolve(),
+      );
     }, Promise.resolve());
 
-    if (!istanbulCoverageComposed) {
-      return {};
-    }
-    istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed);
-    return istanbulCoverageComposed;
+    return {
+      v8Coverage,
+      fileByFileIstanbulCoverage,
+    };
   } finally {
     await operation.end();
   }
 };
 
-const markAsConvertedFromV8 = (fileByFileCoverage) => {
-  const fileByFileMarked = {};
-  Object.keys(fileByFileCoverage).forEach((key) => {
-    const fileCoverage = fileByFileCoverage[key];
-    fileByFileMarked[key] = {
-      ...fileCoverage,
-      fromV8: true,
-    };
-  });
-  return fileByFileMarked;
-};
-
-const sourcesFromSourceMapCache = (url, sourceMapCache) => {
-  const sourceMapAndLineLengths = sourceMapCache[url];
-  if (!sourceMapAndLineLengths) {
-    return {};
-  }
-
-  const { data, lineLengths } = sourceMapAndLineLengths;
-  // See: https://github.com/nodejs/node/pull/34305
-  if (!data) {
-    return undefined;
-  }
+const isV8Coverage = (coverage) => Boolean(coverage.result);
 
-  const sources = {
-    sourcemap: data,
-    ...(lineLengths ? { source: sourcesFromLineLengths(lineLengths) } : {}),
-  };
-  return sources;
+const generateCoverageJsonFile = async ({
+  coverage,
+  coverageJsonFileUrl,
+  logger,
+}) => {
+  const coverageAsText = JSON.stringify(coverage, null, "  ");
+  logger.info(
+    `-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(
+      Buffer.byteLength(coverageAsText),
+    )})`,
+  );
+  await writeFile(coverageJsonFileUrl, coverageAsText);
 };
 
-const sourcesFromLineLengths = (lineLengths) => {
-  let source = "";
-  lineLengths.forEach((length) => {
-    source += `${"".padEnd(length, ".")}\n`;
+const istanbulCoverageMapFromCoverage = (coverage) => {
+  const { createCoverageMap } = importWithRequire("istanbul-lib-coverage");
+
+  const coverageAdjusted = {};
+  Object.keys(coverage).forEach((key) => {
+    coverageAdjusted[key.slice(2)] = {
+      ...coverage[key],
+      path: key.slice(2),
+    };
   });
-  return source;
+
+  const coverageMap = createCoverageMap(coverageAdjusted);
+  return coverageMap;
 };
 
-const composeV8AndIstanbul = (
-  v8FileByFileCoverage,
-  istanbulFileByFileCoverage,
-  { coverageV8ConflictWarning },
+const generateCoverageHtmlDirectory = async (
+  coverage,
+  {
+    rootDirectoryUrl,
+    coverageHtmlDirectoryRelativeUrl,
+    coverageReportSkipEmpty,
+    coverageReportSkipFull,
+  },
 ) => {
-  const fileByFileCoverage = {};
-  const v8Files = Object.keys(v8FileByFileCoverage);
-  const istanbulFiles = Object.keys(istanbulFileByFileCoverage);
+  const libReport = importWithRequire("istanbul-lib-report");
+  const reports = importWithRequire("istanbul-reports");
 
-  v8Files.forEach((key) => {
-    fileByFileCoverage[key] = v8FileByFileCoverage[key];
-  });
-  istanbulFiles.forEach((key) => {
-    const v8Coverage = v8FileByFileCoverage[key];
-    if (v8Coverage) {
-      if (coverageV8ConflictWarning) {
-        console.warn(
-          createDetailedMessage(
-            `Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`,
-            {
-              "details": `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
-              "suggestion":
-                "disable this warning with coverageV8ConflictWarning: false",
-              "suggestion 2": `force coverage using istanbul with coverageMethodForBrowsers: "istanbul"`,
-            },
-          ),
-        );
-      }
-      fileByFileCoverage[key] = v8Coverage;
-    } else {
-      fileByFileCoverage[key] = istanbulFileByFileCoverage[key];
-    }
+  const context = libReport.createContext({
+    dir: fileURLToPath(rootDirectoryUrl),
+    coverageMap: istanbulCoverageMapFromCoverage(coverage),
+    sourceFinder: (path) =>
+      readFileSync(new URL(path, rootDirectoryUrl), "utf8"),
   });
 
-  return fileByFileCoverage;
+  const report = reports.create("html", {
+    skipEmpty: coverageReportSkipEmpty,
+    skipFull: coverageReportSkipFull,
+    subdir: coverageHtmlDirectoryRelativeUrl,
+  });
+  report.execute(context);
 };
 
-const normalizeFileByFileCoveragePaths = (
-  fileByFileCoverage,
-  rootDirectoryUrl,
+const generateCoverageTextLog = (
+  coverage,
+  { coverageReportSkipEmpty, coverageReportSkipFull },
 ) => {
-  const fileByFileNormalized = {};
-  Object.keys(fileByFileCoverage).forEach((key) => {
-    const fileCoverage = fileByFileCoverage[key];
-    const { path } = fileCoverage;
-    const url = isFileSystemPath(path)
-      ? fileSystemPathToUrl(path)
-      : new URL(path, rootDirectoryUrl).href;
-    const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
-    fileByFileNormalized[`./${relativeUrl}`] = {
-      ...fileCoverage,
-      path: `./${relativeUrl}`,
-    };
+  const libReport = importWithRequire("istanbul-lib-report");
+  const reports = importWithRequire("istanbul-reports");
+
+  const context = libReport.createContext({
+    coverageMap: istanbulCoverageMapFromCoverage(coverage),
   });
-  return fileByFileNormalized;
+  const report = reports.create("text", {
+    skipEmpty: coverageReportSkipEmpty,
+    skipFull: coverageReportSkipFull,
+  });
+  report.execute(context);
 };
 
-const listRelativeFileUrlToCover = async ({
-  signal,
-  rootDirectoryUrl,
-  coverageConfig,
-}) => {
-  const matchingFileResultArray = await collectFiles({
-    signal,
-    directoryUrl: rootDirectoryUrl,
-    associations: { cover: coverageConfig },
-    predicate: ({ cover }) => cover,
+const pingServer = async (url) => {
+  const server = createServer();
+  const { hostname, port } = new URL(url);
+
+  try {
+    await new Promise((resolve, reject) => {
+      server.on("error", reject);
+      server.on("listening", () => {
+        resolve();
+      });
+      server.listen(port, hostname);
+    });
+  } catch (error) {
+    if (error && error.code === "EADDRINUSE") {
+      return true;
+    }
+    if (error && error.code === "EACCES") {
+      return true;
+    }
+    throw error;
+  }
+  await new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.on("close", resolve);
+    server.close();
   });
-  return matchingFileResultArray.map(({ relativeUrl }) => relativeUrl);
+  return false;
 };
 
-// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
+const startServerUsingCommand = async (
+  webServer,
+  { signal, allocatedMs, logger, teardown },
+) => {
+  const spawnedProcess = spawn(webServer.command, [], {
+    // On non-windows platforms, `detached: true` makes child process a leader of a new
+    // process group, making it possible to kill child process tree with `.kill(-pid)` command.
+    // @see https://nodejs.org/api/child_process.html#child_process_options_detached
+    detached: process.platform !== "win32",
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: true,
+    cwd: webServer.cwd,
+  });
+  if (!spawnedProcess.pid) {
+    await new Promise((resolve, reject) => {
+      spawnedProcess.once("error", (error) => {
+        reject(new Error(`Failed to launch: ${error}`));
+      });
+    });
+  }
 
-const babelPluginInstrument = (api, { useInlineSourceMaps = false }) => {
-  const { programVisitor } = importWithRequire("istanbul-lib-instrument");
-  const { types } = api;
+  let errorReceived = false;
+  const errorPromise = new Promise((resolve, reject) => {
+    spawnedProcess.on("error", (e) => {
+      errorReceived = true;
+      reject(e);
+    });
+  });
 
-  return {
-    name: "transform-instrument",
-    visitor: {
-      Program: {
-        enter(path, state) {
-          const { file } = state;
-          const { opts } = file;
-          let inputSourceMap;
-          if (useInlineSourceMaps) {
-            // https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e15643d249a2985e4387e4308022053b2cd0ad#diff-1fdf421c05c1140f6d71444ea2b27638R65
-            inputSourceMap =
-              opts.inputSourceMap || file.inputMap
-                ? file.inputMap.sourcemap
-                : null;
-          } else {
-            inputSourceMap = opts.inputSourceMap;
-          }
-          const __dv__ = programVisitor(
-            types,
-            opts.filenameRelative || opts.filename,
-            {
-              coverageVariable: "__coverage__",
-              inputSourceMap,
-            },
+  // const stdout = readline.createInterface({ input: spawnedProcess.stdout });
+  // stdout.on("line", () => {
+  //   logger.debug(`[pid=${spawnedProcess.pid}][out] ${data}`);
+  // });
+  // const stderr = readline.createInterface({ input: spawnedProcess.stderr });
+  // stderr.on("line", (data) => {
+  //   logger.debug(`[pid=${spawnedProcess.pid}][err] ${data}`);
+  // });
+  let processClosed = false;
+  const closedPromise = new Promise((resolve) => {
+    spawnedProcess.once("exit", (exitCode, signal) => {
+      logger.debug(
+        `[pid=${spawnedProcess.pid}] <process did exit: exitCode=${exitCode}, signal=${signal}>`,
+      );
+      processClosed = true;
+      resolve();
+    });
+  });
+  const killProcess = async () => {
+    logger.debug(`[pid=${spawnedProcess.pid}] <kill>`);
+    if (!spawnedProcess.pid || spawnedProcess.killed || processClosed) {
+      logger.debug(
+        `[pid=${spawnedProcess.pid}] <skipped force kill spawnedProcess.killed=${spawnedProcess.killed} processClosed=${processClosed}>`,
+      );
+      return;
+    }
+    logger.debug(`[pid=${spawnedProcess.pid}] <will force kill>`);
+    // Force kill the browser.
+    try {
+      if (process.platform === "win32") {
+        const taskkillProcess = spawnSync(
+          `taskkill /pid ${spawnedProcess.pid} /T /F`,
+          { shell: true },
+        );
+        const [stdout, stderr] = [
+          taskkillProcess.stdout.toString(),
+          taskkillProcess.stderr.toString(),
+        ];
+        if (stdout)
+          logger.debug(
+            `[pid=${spawnedProcess.pid}] taskkill stdout: ${stdout}`,
           );
-          __dv__.enter(path);
-          file.metadata.__dv__ = __dv__;
-        },
-
-        exit(path, state) {
-          const { __dv__ } = state.file.metadata;
-          if (!__dv__) {
-            return;
-          }
-          const object = __dv__.exit(path);
-          // object got two properties: fileCoverage and sourceMappingURL
-          state.file.metadata.coverage = object.fileCoverage;
-        },
-      },
-    },
+        if (stderr)
+          logger.info(`[pid=${spawnedProcess.pid}] taskkill stderr: ${stderr}`);
+      } else {
+        process.kill(-spawnedProcess.pid, "SIGKILL");
+      }
+    } catch (e) {
+      logger.info(
+        `[pid=${spawnedProcess.pid}] exception while trying to kill process: ${e}`,
+      );
+      // the process might have already stopped
+    }
+    await closedPromise;
   };
-};
-
-const relativeUrlToEmptyCoverage = async (
-  relativeUrl,
-  { signal, rootDirectoryUrl },
-) => {
-  const operation = Abort.startOperation();
-  operation.addAbortSignal(signal);
 
-  try {
-    const fileUrl = resolveUrl(relativeUrl, rootDirectoryUrl);
-    const content = await readFile(fileUrl, { as: "string" });
+  const startOperation = Abort.startOperation();
+  startOperation.addAbortSignal(signal);
+  const timeoutAbortSource = startOperation.timeout(allocatedMs);
+  startOperation.addAbortCallback(killProcess);
+  teardown.addCallback(killProcess);
 
-    operation.throwIfAborted();
-    const { metadata } = await applyBabelPlugins({
-      babelPlugins: [babelPluginInstrument],
-      input: content,
-      inputIsJsModule: true,
-      inputUrl: fileUrl,
-    });
-    const { coverage } = metadata;
-    if (!coverage) {
-      throw new Error(`missing coverage for file`);
+  const startedPromise = (async () => {
+    const logScale = [100, 250, 500];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      if (errorReceived) {
+        break;
+      }
+      const connected = await pingServer(webServer.origin);
+      if (connected) {
+        break;
+      }
+      startOperation.throwIfAborted();
+      const delay = logScale.shift() || 1000;
+      logger.debug(`Waiting ${delay}ms`);
+      await new Promise((x) => setTimeout(x, delay));
     }
-    // https://github.com/gotwarlost/istanbul/blob/bc84c315271a5dd4d39bcefc5925cfb61a3d174a/lib/command/common/run-with-cover.js#L229
-    Object.keys(coverage.s).forEach(function (key) {
-      coverage.s[key] = 0;
-    });
-    return coverage;
+  })();
+
+  try {
+    await Promise.race([errorPromise, startedPromise]);
   } catch (e) {
-    if (e && e.code === "PARSE_ERROR") {
-      // return an empty coverage for that file when
-      // it contains a syntax error
-      return createEmptyCoverage(relativeUrl);
+    if (Abort.isAbortError(e)) {
+      if (timeoutAbortSource.signal.aborted) {
+        // aborted by timeout
+        throw new Error(
+          `"${webServer.command}" command did not start a server in less than ${allocatedMs}ms`,
+        );
+      }
+      if (signal.aborted) {
+        // aborted from outside
+        return;
+      }
     }
     throw e;
   } finally {
-    await operation.end();
+    await startOperation.end();
   }
 };
 
-const createEmptyCoverage = (relativeUrl) => {
-  const { createFileCoverage } = importWithRequire("istanbul-lib-coverage");
-  return createFileCoverage(relativeUrl).toJSON();
-};
-
-const getMissingFileByFileCoverage = async ({
-  signal,
-  rootDirectoryUrl,
-  coverageConfig,
-  fileByFileCoverage,
-}) => {
-  const relativeUrlsToCover = await listRelativeFileUrlToCover({
-    signal,
-    rootDirectoryUrl,
-    coverageConfig,
-  });
-  const relativeUrlsMissing = relativeUrlsToCover.filter((relativeUrlToCover) =>
-    Object.keys(fileByFileCoverage).every((key) => {
-      return key !== `./${relativeUrlToCover}`;
-    }),
+const startServerUsingModuleUrl = async (webServer, params) => {
+  if (!existsSync(new URL(webServer.moduleUrl))) {
+    throw new Error(`"${webServer.moduleUrl}" does not lead to a file`);
+  }
+  return startServerUsingCommand(
+    {
+      ...webServer,
+      command: `node ${fileURLToPath(webServer.moduleUrl)}`,
+    },
+    params,
   );
-
-  const operation = Abort.startOperation();
-  operation.addAbortSignal(signal);
-  const missingFileByFileCoverage = {};
-  await relativeUrlsMissing.reduce(async (previous, relativeUrlMissing) => {
-    operation.throwIfAborted();
-    await previous;
-    await operation.withSignal(async (signal) => {
-      const emptyCoverage = await relativeUrlToEmptyCoverage(
-        relativeUrlMissing,
-        {
-          signal,
-          rootDirectoryUrl,
-        },
-      );
-      missingFileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage;
-    });
-  }, Promise.resolve());
-  return missingFileByFileCoverage;
 };
 
-const reportToCoverage = async (
-  report,
-  {
-    signal,
-    logger,
-    rootDirectoryUrl,
-    coverageConfig,
-    coverageIncludeMissing,
-    coverageMethodForNodeJs,
-    coverageV8ConflictWarning,
-  },
+const basicFetch = async (
+  url,
+  { rejectUnauthorized = true, method = "GET", headers = {} } = {},
 ) => {
-  // collect v8 and istanbul coverage from executions
-  let { v8Coverage, fileByFileIstanbulCoverage } = await getCoverageFromReport({
-    signal,
-    report,
-    onMissing: ({ file, executionResult, executionName }) => {
-      // several reasons not to have coverage here:
-      // 1. the file we executed did not import an instrumented file.
-      // - a test file without import
-      // - a test file importing only file excluded from coverage
-      // - a coverDescription badly configured so that we don't realize
-      // a file should be covered
-
-      // 2. the file we wanted to executed timedout
-      // - infinite loop
-      // - too extensive operation
-      // - a badly configured or too low allocatedMs for that execution.
+  let requestModule;
+  if (url.startsWith("http:")) {
+    requestModule = await import("node:http");
+  } else {
+    requestModule = await import("node:https");
+  }
+  const { request } = requestModule;
 
-      // 3. the file we wanted to execute contains syntax-error
+  const urlObject = new URL(url);
 
-      // in any scenario we are fine because
-      // coverDescription will generate empty coverage for files
-      // that were suppose to be coverage but were not.
-      if (
-        executionResult.status === "completed" &&
-        executionResult.type === "node" &&
-        coverageMethodForNodeJs !== "NODE_V8_COVERAGE"
-      ) {
-        logger.warn(
-          `"${executionName}" execution of ${file} did not properly write coverage into ${executionResult.coverageFileUrl}`,
-        );
-      }
-    },
-  });
-
-  if (coverageMethodForNodeJs === "NODE_V8_COVERAGE") {
-    await readNodeV8CoverageDirectory({
-      logger,
-      signal,
-      onV8Coverage: async (nodeV8Coverage) => {
-        const nodeV8CoverageLight = await filterV8Coverage(nodeV8Coverage, {
-          rootDirectoryUrl,
-          coverageConfig,
-        });
-        v8Coverage = v8Coverage
-          ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
-          : nodeV8CoverageLight;
-      },
+  return new Promise((resolve, reject) => {
+    const req = request({
+      rejectUnauthorized,
+      hostname: urlObject.hostname,
+      port: urlObject.port,
+      path: urlObject.pathname,
+      method,
+      headers,
     });
-  }
-
-  // try to merge v8 with istanbul, if any
-  let fileByFileCoverage;
-  if (v8Coverage) {
-    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage, {
-      signal,
+    req.on("response", (response) => {
+      resolve({
+        status: response.statusCode,
+        headers: response.headers,
+        json: () => {
+          req.setTimeout(0);
+          req.destroy();
+          return new Promise((resolve) => {
+            if (response.headers["content-type"] !== "application/json") {
+              console.warn("not json");
+            }
+            let responseBody = "";
+            response.setEncoding("utf8");
+            response.on("data", (chunk) => {
+              responseBody += chunk;
+            });
+            response.on("end", () => {
+              resolve(JSON.parse(responseBody));
+            });
+            response.on("error", (e) => {
+              reject(e);
+            });
+          });
+        },
+      });
     });
+    req.on("error", reject);
+    req.end();
+  });
+};
 
-    v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
-      v8FileByFileCoverage,
-      rootDirectoryUrl,
+const assertAndNormalizeWebServer = async (
+  webServer,
+  { signal, logger, teardown },
+) => {
+  if (!webServer) {
+    throw new TypeError(
+      `webServer is required when running tests on browser(s)`,
     );
-
-    if (fileByFileIstanbulCoverage) {
-      fileByFileIstanbulCoverage = normalizeFileByFileCoveragePaths(
-        fileByFileIstanbulCoverage,
-        rootDirectoryUrl,
-      );
-      fileByFileCoverage = composeV8AndIstanbul(
-        v8FileByFileCoverage,
-        fileByFileIstanbulCoverage,
-        { coverageV8ConflictWarning },
-      );
-    } else {
-      fileByFileCoverage = v8FileByFileCoverage;
-    }
   }
-  // get istanbul only
-  else if (fileByFileIstanbulCoverage) {
-    fileByFileCoverage = normalizeFileByFileCoveragePaths(
-      fileByFileIstanbulCoverage,
-      rootDirectoryUrl,
+  const unexpectedParamNames = Object.keys(webServer).filter((key) => {
+    return ![
+      "origin",
+      "moduleUrl",
+      "command",
+      "cwd",
+      "rootDirectoryUrl",
+    ].includes(key);
+  });
+  if (unexpectedParamNames.length > 0) {
+    throw new TypeError(
+      `${unexpectedParamNames.join(",")}: there is no such param to webServer`,
     );
   }
-  // no coverage found in execution (or zero file where executed)
-  else {
-    fileByFileCoverage = {};
+  if (typeof webServer.origin !== "string") {
+    throw new TypeError(
+      `webServer.origin must be a string, got ${webServer.origin}`,
+    );
   }
-
-  // now add coverage for file not covered
-  if (coverageIncludeMissing) {
-    const missingFileByFileCoverage = await getMissingFileByFileCoverage({
-      signal,
-      rootDirectoryUrl,
-      coverageConfig,
-      fileByFileCoverage,
+  await ensureWebServerIsStarted(webServer, {
+    signal,
+    teardown,
+    logger,
+  });
+  const { headers } = await basicFetch(webServer.origin, {
+    method: "GET",
+    rejectUnauthorized: false,
+    headers: {
+      "x-server-inspect": "1",
+    },
+  });
+  if (String(headers["server"]).includes("jsenv_dev_server")) {
+    webServer.isJsenvDevServer = true;
+    const { json } = await basicFetch(`${webServer.origin}/__params__.json`, {
+      rejectUnauthorized: false,
     });
-    Object.assign(
-      fileByFileCoverage,
-      normalizeFileByFileCoveragePaths(
-        missingFileByFileCoverage,
-        rootDirectoryUrl,
-      ),
+    if (webServer.rootDirectoryUrl === undefined) {
+      const jsenvDevServerParams = await json();
+      webServer.rootDirectoryUrl = jsenvDevServerParams.sourceDirectoryUrl;
+    } else {
+      webServer.rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
+        webServer.rootDirectoryUrl,
+        "webServer.rootDirectoryUrl",
+      );
+    }
+  } else {
+    webServer.rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
+      webServer.rootDirectoryUrl,
+      "webServer.rootDirectoryUrl",
     );
   }
-
-  return fileByFileCoverage;
 };
 
-const getCoverageFromReport = async ({ signal, report, onMissing }) => {
-  const operation = Abort.startOperation();
-  operation.addAbortSignal(signal);
-
-  try {
-    let v8Coverage;
-    let fileByFileIstanbulCoverage;
-
-    // collect v8 and istanbul coverage from executions
-    await Object.keys(report).reduce(async (previous, file) => {
-      operation.throwIfAborted();
-      await previous;
-
-      const executionResultForFile = report[file];
-      await Object.keys(executionResultForFile).reduce(
-        async (previous, executionName) => {
-          operation.throwIfAborted();
-          await previous;
-
-          const executionResultForFileOnRuntime =
-            executionResultForFile[executionName];
-          const { coverageFileUrl } = executionResultForFileOnRuntime;
-          let executionCoverage;
-          try {
-            executionCoverage = JSON.parse(
-              String(readFileSync(new URL(coverageFileUrl))),
-            );
-          } catch (e) {
-            if (e.code === "ENOENT" || e.name === "SyntaxError") {
-              onMissing({
-                executionName,
-                file,
-                executionResult: executionResultForFileOnRuntime,
-              });
-              return;
-            }
-            throw e;
-          }
-
-          if (isV8Coverage(executionCoverage)) {
-            v8Coverage = v8Coverage
-              ? composeTwoV8Coverages(v8Coverage, executionCoverage)
-              : executionCoverage;
-          } else {
-            fileByFileIstanbulCoverage = fileByFileIstanbulCoverage
-              ? composeTwoFileByFileIstanbulCoverages(
-                  fileByFileIstanbulCoverage,
-                  executionCoverage,
-                )
-              : executionCoverage;
-          }
-        },
-        Promise.resolve(),
-      );
-    }, Promise.resolve());
-
-    return {
-      v8Coverage,
-      fileByFileIstanbulCoverage,
-    };
-  } finally {
-    await operation.end();
+const ensureWebServerIsStarted = async (
+  webServer,
+  { signal, teardown, logger, allocatedMs = 5_000 },
+) => {
+  const aServerIsListening = await pingServer(webServer.origin);
+  if (aServerIsListening) {
+    return;
+  }
+  if (webServer.moduleUrl) {
+    await startServerUsingModuleUrl(webServer, {
+      signal,
+      allocatedMs,
+      teardown,
+      logger,
+    });
+    return;
+  }
+  if (webServer.command) {
+    await startServerUsingCommand(webServer, {
+      signal,
+      allocatedMs,
+      teardown,
+      logger,
+    });
+    return;
   }
+  throw new TypeError(
+    `webServer.moduleUrl or webServer.command is required as there is no server listening "${webServer.origin}"`,
+  );
 };
 
-const isV8Coverage = (coverage) => Boolean(coverage.result);
-
-/*
- * Export a function capable to run a file on a runtime.
- *
- * - Used internally by "executeTestPlan" part of the documented API
- * - Used internally by "execute" an advanced API not documented
- * - logs generated during file execution can be collected
- * - logs generated during file execution can be mirrored (re-logged to the console)
- * - File is given allocatedMs to complete
- * - Errors are collected
- * - File execution result is returned, it contains status/errors/namespace/consoleCalls
- */
-
-
-const run = async ({
-  signal = new AbortController().signal,
-  logger,
-  allocatedMs,
-  keepRunning = false,
-  mirrorConsole = false,
-  collectConsole = false,
-  coverageEnabled = false,
-  coverageTempDirectoryUrl,
-  collectPerformance = false,
-  runtime,
-  runtimeParams,
+const executionStepsFromTestPlan = async ({
+  signal,
+  rootDirectoryUrl,
+  testPlan,
 }) => {
-  const result = {
-    status: "pending",
-    errors: [],
-    namespace: null,
-  };
-  const callbacks = [];
-
-  const onConsoleRef = { current: () => {} };
-  const stopSignal = { notify: () => {} };
-  const runtimeLabel = `${runtime.name}/${runtime.version}`;
-
-  const runOperation = Abort.startOperation();
-  runOperation.addAbortSignal(signal);
-  let timeoutAbortSource;
-  if (
-    // ideally we would rather log than the timeout is ignored
-    // when keepRunning is true
-    !keepRunning &&
-    typeof allocatedMs === "number" &&
-    allocatedMs !== Infinity
-  ) {
-    timeoutAbortSource = runOperation.timeout(allocatedMs);
-  }
-  const consoleCalls = [];
-  onConsoleRef.current = ({ type, text }) => {
-    if (mirrorConsole) {
-      if (type === "error") {
-        process.stderr.write(text);
-      } else {
-        process.stdout.write(text);
-      }
-    }
-    if (collectConsole) {
-      consoleCalls.push({ type, text });
-    }
-  };
-  if (collectConsole) {
-    result.consoleCalls = consoleCalls;
-  }
-
-  // we do not keep coverage in memory, it can grow very big
-  // instead we store it on the filesystem
-  // and they can be read later at "coverageFileUrl"
-  let coverageFileUrl;
-  if (coverageEnabled) {
-    coverageFileUrl = new URL(
-      `./${runtime.name}/${crypto.randomUUID()}.json`,
-      coverageTempDirectoryUrl,
-    ).href;
-    await ensureParentDirectories(coverageFileUrl);
-    if (coverageEnabled) {
-      result.coverageFileUrl = coverageFileUrl;
-      // written within the child_process/worker_thread or during runtime.run()
-      // for browsers
-      // (because it takes time to serialize and transfer the coverage object)
-    }
-  }
-
-  const startMs = Date.now();
-  callbacks.push(() => {
-    result.duration = Date.now() - startMs;
-  });
-
   try {
-    logger.debug(`run() ${runtimeLabel}`);
-    runOperation.throwIfAborted();
-    const winnerPromise = new Promise((resolve) => {
-      raceCallbacks(
-        {
-          aborted: (cb) => {
-            runOperation.signal.addEventListener("abort", cb);
-            return () => {
-              runOperation.signal.removeEventListener("abort", cb);
-            };
-          },
-          runned: async (cb) => {
-            try {
-              const runResult = await runtime.run({
-                signal: runOperation.signal,
-                logger,
-                ...runtimeParams,
-                collectConsole,
-                collectPerformance,
-                coverageFileUrl,
-                keepRunning,
-                stopSignal,
-                onConsole: (log) => onConsoleRef.current(log),
-              });
-              cb(runResult);
-            } catch (e) {
-              cb({
-                status: "failed",
-                errors: [e],
-              });
-            }
-          },
-        },
-        resolve,
-      );
+    const fileResultArray = await collectFiles({
+      signal,
+      directoryUrl: rootDirectoryUrl,
+      associations: { testPlan },
+      predicate: ({ testPlan }) => testPlan,
     });
-    const winner = await winnerPromise;
-    if (winner.name === "aborted") {
-      runOperation.throwIfAborted();
-    }
-    const { status, namespace, errors, performance } = winner.data;
-    result.status = status;
-    result.errors.push(...errors);
-    result.namespace = namespace;
-    if (collectPerformance) {
-      result.performance = performance;
-    }
+    const executionSteps = [];
+    fileResultArray.forEach(({ relativeUrl, meta }) => {
+      const fileExecutionSteps = generateFileExecutionSteps({
+        fileRelativeUrl: relativeUrl,
+        filePlan: meta.testPlan,
+      });
+      executionSteps.push(...fileExecutionSteps);
+    });
+    return executionSteps;
   } catch (e) {
     if (Abort.isAbortError(e)) {
-      if (timeoutAbortSource && timeoutAbortSource.signal.aborted) {
-        result.status = "timedout";
-      } else {
-        result.status = "aborted";
-      }
-    } else {
-      result.status = "failed";
-      result.errors.push(e);
+      return {
+        aborted: true,
+        planSummary: {},
+        planReport: {},
+        planCoverage: null,
+      };
     }
-  } finally {
-    await runOperation.end();
+    throw e;
   }
-
-  callbacks.forEach((callback) => {
-    callback();
-  });
-  return result;
 };
 
-const ensureGlobalGc = () => {
-  if (!global.gc) {
-    v8.setFlagsFromString("--expose_gc");
-    global.gc = runInNewContext("gc");
-  }
+const generateFileExecutionSteps = ({ fileRelativeUrl, filePlan }) => {
+  const fileExecutionSteps = [];
+  Object.keys(filePlan).forEach((executionName) => {
+    const stepConfig = filePlan[executionName];
+    if (stepConfig === null || stepConfig === undefined) {
+      return;
+    }
+    if (typeof stepConfig !== "object") {
+      throw new TypeError(
+        createDetailedMessage(
+          `found unexpected value in plan, they must be object`,
+          {
+            ["file relative path"]: fileRelativeUrl,
+            ["execution name"]: executionName,
+            ["value"]: stepConfig,
+          },
+        ),
+      );
+    }
+    fileExecutionSteps.push({
+      executionName,
+      fileRelativeUrl,
+      ...stepConfig,
+    });
+  });
+  return fileExecutionSteps;
 };
 
 const EXECUTION_COLORS = {
@@ -4452,424 +4332,28 @@ const formatConsoleSummary = (repartition) => {
   return `console (${parts.join(" ")})`;
 };
 
-const executeSteps = async (
-  executionSteps,
-  {
-    signal,
-    teardown,
-    logger,
-    logRefresh,
-    logRuntime,
-    logEachDuration,
-    logSummary,
-    logTimeUsage,
-    logMemoryHeapUsage,
-    logFileRelativeUrl,
-    logMergeForCompletedExecutions,
-    logShortForCompletedExecutions,
-    rootDirectoryUrl,
-    webServer,
-
-    keepRunning,
-    defaultMsAllocatedPerExecution,
-    maxExecutionsInParallel,
-    failFast,
-    gcBetweenExecutions,
-    cooldownBetweenExecutions,
-
-    coverageEnabled,
-    coverageConfig,
-    coverageIncludeMissing,
-    coverageMethodForBrowsers,
-    coverageMethodForNodeJs,
-    coverageV8ConflictWarning,
-    coverageTempDirectoryUrl,
-
-    beforeExecutionCallback = () => {},
-    afterExecutionCallback = () => {},
-  } = {},
+const githubAnnotationFromError = (
+  error,
+  { rootDirectoryUrl, executionInfo },
 ) => {
-  executionSteps = executionSteps.filter(
-    (executionStep) => !executionStep.runtime?.disabled,
-  );
-
-  const executePlanReturnValue = {};
-  const report = {};
-  const callbacks = [];
-
-  const multipleExecutionsOperation = Abort.startOperation();
-  multipleExecutionsOperation.addAbortSignal(signal);
-  const failFastAbortController = new AbortController();
-  if (failFast) {
-    multipleExecutionsOperation.addAbortSignal(failFastAbortController.signal);
-  }
-
-  try {
-    if (gcBetweenExecutions) {
-      ensureGlobalGc();
-    }
-
-    if (coverageEnabled) {
-      // when runned multiple times, we don't want to keep previous files in this directory
-      await ensureEmptyDirectory(coverageTempDirectoryUrl);
-      callbacks.push(async () => {
-        if (multipleExecutionsOperation.signal.aborted) {
-          // don't try to do the coverage stuff
-          return;
-        }
-        try {
-          if (coverageMethodForNodeJs === "NODE_V8_COVERAGE") {
-            takeCoverage();
-            // conceptually we don't need coverage anymore so it would be
-            // good to call v8.stopCoverage()
-            // but it logs a strange message about "result is not an object"
-          }
-          const planCoverage = await reportToCoverage(report, {
-            signal: multipleExecutionsOperation.signal,
-            logger,
-            rootDirectoryUrl,
-            coverageConfig,
-            coverageIncludeMissing,
-            coverageMethodForNodeJs,
-            coverageV8ConflictWarning,
-          });
-          executePlanReturnValue.planCoverage = planCoverage;
-        } catch (e) {
-          if (Abort.isAbortError(e)) {
-            return;
-          }
-          throw e;
-        }
-      });
-    }
-
-    const runtimeParams = {
-      rootDirectoryUrl,
-      webServer,
-
-      coverageEnabled,
-      coverageConfig,
-      coverageMethodForBrowsers,
-      coverageMethodForNodeJs,
-      isTestPlan: true,
-      teardown,
-    };
-
-    if (logMergeForCompletedExecutions && !process.stdout.isTTY) {
-      logMergeForCompletedExecutions = false;
-      logger.debug(
-        `Force logMergeForCompletedExecutions to false because process.stdout.isTTY is false`,
-      );
-    }
-    const debugLogsEnabled = logger.levels.debug;
-    const executionLogsEnabled = logger.levels.info;
-    const executionSpinner =
-      logRefresh &&
-      !debugLogsEnabled &&
-      executionLogsEnabled &&
-      process.stdout.isTTY &&
-      // if there is an error during execution npm will mess up the output
-      // (happens when npm runs several command in a workspace)
-      // so we enable spinner only when !process.exitCode (no error so far)
-      process.exitCode !== 1;
-
-    const startMs = Date.now();
-    let rawOutput = "";
-    let executionLog = createLog({ newLine: "" });
-    const counters = {
-      total: executionSteps.length,
-      aborted: 0,
-      timedout: 0,
-      failed: 0,
-      completed: 0,
-      done: 0,
-    };
-    await executeInParallel({
-      multipleExecutionsOperation,
-      maxExecutionsInParallel,
-      cooldownBetweenExecutions,
-      executionSteps,
-      start: async (paramsFromStep) => {
-        const executionIndex = executionSteps.indexOf(paramsFromStep);
-        const { executionName, fileRelativeUrl, runtime } = paramsFromStep;
-        const runtimeType = runtime.type;
-        const runtimeName = runtime.name;
-        const runtimeVersion = runtime.version;
-        const executionParams = {
-          measurePerformance: false,
-          collectPerformance: false,
-          collectConsole: true,
-          allocatedMs: defaultMsAllocatedPerExecution,
-          ...paramsFromStep,
-          runtimeParams: {
-            fileRelativeUrl,
-            ...paramsFromStep.runtimeParams,
-          },
-        };
-        const beforeExecutionInfo = {
-          fileRelativeUrl,
-          runtimeType,
-          runtimeName,
-          runtimeVersion,
-          executionIndex,
-          executionParams,
-          startMs: Date.now(),
-          executionResult: {
-            status: "executing",
-          },
-          counters,
-          timeEllapsed: Date.now() - startMs,
-          memoryHeap: memoryUsage().heapUsed,
-        };
-        if (typeof executionParams.allocatedMs === "function") {
-          executionParams.allocatedMs =
-            executionParams.allocatedMs(beforeExecutionInfo);
-        }
-        let spinner;
-        if (executionSpinner) {
-          spinner = startSpinner({
-            log: executionLog,
-            render: () => {
-              return createExecutionLog(beforeExecutionInfo, {
-                logRuntime,
-                logEachDuration,
-                logTimeUsage,
-                logMemoryHeapUsage,
-              });
-            },
-          });
-        }
-        beforeExecutionCallback(beforeExecutionInfo);
-
-        const fileUrl = `${rootDirectoryUrl}${fileRelativeUrl}`;
-        let executionResult;
-        if (existsSync(new URL(fileUrl))) {
-          executionResult = await run({
-            signal: multipleExecutionsOperation.signal,
-            logger,
-            allocatedMs: executionParams.allocatedMs,
-            keepRunning,
-            mirrorConsole: false, // file are executed in parallel, log would be a mess to read
-            collectConsole: executionParams.collectConsole,
-            coverageEnabled,
-            coverageTempDirectoryUrl,
-            runtime: executionParams.runtime,
-            runtimeParams: {
-              ...runtimeParams,
-              ...executionParams.runtimeParams,
-            },
-          });
-        } else {
-          executionResult = {
-            status: "failed",
-            errors: [
-              new Error(
-                `No file at ${fileRelativeUrl} for execution "${executionName}"`,
-              ),
-            ],
-          };
-        }
-        counters.done++;
-        const fileReport = report[fileRelativeUrl];
-        if (fileReport) {
-          fileReport[executionName] = executionResult;
-        } else {
-          report[fileRelativeUrl] = {
-            [executionName]: executionResult,
-          };
-        }
-
-        const afterExecutionInfo = {
-          ...beforeExecutionInfo,
-          runtimeVersion: runtime.version,
-          endMs: Date.now(),
-          executionResult,
-        };
-
-        if (executionResult.status === "aborted") {
-          counters.aborted++;
-        } else if (executionResult.status === "timedout") {
-          counters.timedout++;
-        } else if (executionResult.status === "failed") {
-          counters.failed++;
-        } else if (executionResult.status === "completed") {
-          counters.completed++;
-        }
-        if (gcBetweenExecutions) {
-          global.gc();
-        }
-        if (executionLogsEnabled) {
-          const log = createExecutionLog(afterExecutionInfo, {
-            logShortForCompletedExecutions,
-            logRuntime,
-            logEachDuration,
-            ...(logTimeUsage
-              ? {
-                  timeEllapsed: Date.now() - startMs,
-                }
-              : {}),
-            ...(logMemoryHeapUsage
-              ? { memoryHeap: memoryUsage().heapUsed }
-              : {}),
-          });
-          // replace spinner with this execution result
-          if (spinner) spinner.stop();
-          executionLog.write(log);
-          rawOutput += stripAnsi(log);
-
-          const canOverwriteLog = canOverwriteLogGetter({
-            logMergeForCompletedExecutions,
-            executionResult,
-          });
-          if (canOverwriteLog) {
-            // nothing to do, we reuse the current executionLog object
-          } else {
-            executionLog.destroy();
-            executionLog = createLog({ newLine: "" });
-          }
-        }
-        afterExecutionCallback(afterExecutionInfo);
-        const isLastExecutionLog = executionIndex === executionSteps.length - 1;
-        const cancelRemaining =
-          failFast &&
-          executionResult.status !== "completed" &&
-          counters.done < counters.total;
-        if (isLastExecutionLog && logger.levels.info) {
-          executionLog.write("\n");
-        }
-
-        if (cancelRemaining) {
-          logger.info(`"failFast" enabled -> cancel remaining executions`);
-          failFastAbortController.abort();
-        }
-      },
-    });
-    if (!keepRunning) {
-      logger.debug("trigger test plan teardown");
-      await teardown.trigger();
-    }
-
-    counters.cancelled = counters.total - counters.done;
-    const summary = {
-      counters,
-      // when execution is aborted, the remaining executions are "cancelled"
-      duration: Date.now() - startMs,
-    };
-    if (logSummary) {
-      const summaryLog = formatSummaryLog(summary);
-      rawOutput += stripAnsi(summaryLog);
-      logger.info(summaryLog);
-    }
-    if (summary.counters.total !== summary.counters.completed) {
-      const logFileUrl = new URL(logFileRelativeUrl, rootDirectoryUrl).href;
-      writeFileSync(logFileUrl, rawOutput);
-      logger.info(`-> ${urlToFileSystemPath(logFileUrl)}`);
-    }
-    executePlanReturnValue.aborted = multipleExecutionsOperation.signal.aborted;
-    executePlanReturnValue.planSummary = summary;
-    executePlanReturnValue.planReport = report;
-    for (const callback of callbacks) {
-      await callback();
-    }
-    return executePlanReturnValue;
-  } finally {
-    await multipleExecutionsOperation.end();
-  }
-};
-
-const canOverwriteLogGetter = ({
-  logMergeForCompletedExecutions,
-  executionResult,
-}) => {
-  if (!logMergeForCompletedExecutions) {
-    return false;
-  }
-  if (executionResult.status === "aborted") {
-    return true;
-  }
-  if (executionResult.status !== "completed") {
-    return false;
-  }
-  const { consoleCalls = [] } = executionResult;
-  if (consoleCalls.length > 0) {
-    return false;
-  }
-  return true;
-};
-
-const executeInParallel = async ({
-  multipleExecutionsOperation,
-  maxExecutionsInParallel,
-  cooldownBetweenExecutions,
-  executionSteps,
-  start,
-}) => {
-  const executionResults = [];
-  let progressionIndex = 0;
-  let remainingExecutionCount = executionSteps.length;
-
-  const nextChunk = async () => {
-    if (multipleExecutionsOperation.signal.aborted) {
-      return;
-    }
-    const outputPromiseArray = [];
-    while (
-      remainingExecutionCount > 0 &&
-      outputPromiseArray.length < maxExecutionsInParallel
-    ) {
-      remainingExecutionCount--;
-      const outputPromise = executeOne(progressionIndex);
-      progressionIndex++;
-      outputPromiseArray.push(outputPromise);
-    }
-    if (outputPromiseArray.length) {
-      await Promise.all(outputPromiseArray);
-      if (remainingExecutionCount > 0) {
-        await nextChunk();
-      }
-    }
-  };
-
-  const executeOne = async (index) => {
-    const input = executionSteps[index];
-    const output = await start(input);
-    if (!multipleExecutionsOperation.signal.aborted) {
-      executionResults[index] = output;
-    }
-    if (cooldownBetweenExecutions) {
-      await new Promise((resolve) =>
-        setTimeout(resolve, cooldownBetweenExecutions),
-      );
-    }
-  };
-
-  await nextChunk();
-
-  return executionResults;
-};
-
-const githubAnnotationFromError = (
-  error,
-  { rootDirectoryUrl, executionInfo },
-) => {
-  const annotation = {
-    annotation_level: "failure",
-    path: executionInfo.fileRelativeUrl,
-    start_line: 1,
-    end_line: 1,
-    title: `Error while executing ${executionInfo.fileRelativeUrl} on ${executionInfo.runtimeName}@${executionInfo.runtimeVersion}`,
-  };
-  const exception = asException(error, { rootDirectoryUrl });
-  if (exception.site && typeof exception.site.line === "number") {
-    annotation.path = urlToRelativeUrl(exception.site.url, rootDirectoryUrl);
-    annotation.start_line = exception.site.line;
-    annotation.end_line = exception.site.line;
-    annotation.start_column = exception.site.column;
-    annotation.end_column = exception.site.column;
-  }
-  annotation.message = exception.stack;
-  return annotation;
-};
+  const annotation = {
+    annotation_level: "failure",
+    path: executionInfo.fileRelativeUrl,
+    start_line: 1,
+    end_line: 1,
+    title: `Error while executing ${executionInfo.fileRelativeUrl} on ${executionInfo.runtimeName}@${executionInfo.runtimeVersion}`,
+  };
+  const exception = asException(error, { rootDirectoryUrl });
+  if (exception.site && typeof exception.site.line === "number") {
+    annotation.path = urlToRelativeUrl(exception.site.url, rootDirectoryUrl);
+    annotation.start_line = exception.site.line;
+    annotation.end_line = exception.site.line;
+    annotation.start_column = exception.site.column;
+    annotation.end_column = exception.site.column;
+  }
+  annotation.message = exception.stack;
+  return annotation;
+};
 
 const asException = (error, { rootDirectoryUrl }) => {
   const exception = {
@@ -4979,6 +4463,171 @@ const replaceUrls = (source, replace) => {
   });
 };
 
+/*
+ * Export a function capable to run a file on a runtime.
+ *
+ * - Used internally by "executeTestPlan" part of the documented API
+ * - Used internally by "execute" an advanced API not documented
+ * - logs generated during file execution can be collected
+ * - logs generated during file execution can be mirrored (re-logged to the console)
+ * - File is given allocatedMs to complete
+ * - Errors are collected
+ * - File execution result is returned, it contains status/errors/namespace/consoleCalls
+ */
+
+
+const run = async ({
+  signal = new AbortController().signal,
+  logger,
+  allocatedMs,
+  keepRunning = false,
+  mirrorConsole = false,
+  collectConsole = false,
+  coverageEnabled = false,
+  coverageTempDirectoryUrl,
+  collectPerformance = false,
+  runtime,
+  runtimeParams,
+}) => {
+  const result = {
+    status: "pending",
+    errors: [],
+    namespace: null,
+  };
+  const callbacks = [];
+
+  const onConsoleRef = { current: () => {} };
+  const stopSignal = { notify: () => {} };
+  const runtimeLabel = `${runtime.name}/${runtime.version}`;
+
+  const runOperation = Abort.startOperation();
+  runOperation.addAbortSignal(signal);
+  let timeoutAbortSource;
+  if (
+    // ideally we would rather log than the timeout is ignored
+    // when keepRunning is true
+    !keepRunning &&
+    typeof allocatedMs === "number" &&
+    allocatedMs !== Infinity
+  ) {
+    timeoutAbortSource = runOperation.timeout(allocatedMs);
+  }
+  const consoleCalls = [];
+  onConsoleRef.current = ({ type, text }) => {
+    if (mirrorConsole) {
+      if (type === "error") {
+        process.stderr.write(text);
+      } else {
+        process.stdout.write(text);
+      }
+    }
+    if (collectConsole) {
+      consoleCalls.push({ type, text });
+    }
+  };
+  if (collectConsole) {
+    result.consoleCalls = consoleCalls;
+  }
+
+  // we do not keep coverage in memory, it can grow very big
+  // instead we store it on the filesystem
+  // and they can be read later at "coverageFileUrl"
+  let coverageFileUrl;
+  if (coverageEnabled) {
+    coverageFileUrl = new URL(
+      `./${runtime.name}/${crypto.randomUUID()}.json`,
+      coverageTempDirectoryUrl,
+    ).href;
+    await ensureParentDirectories(coverageFileUrl);
+    if (coverageEnabled) {
+      result.coverageFileUrl = coverageFileUrl;
+      // written within the child_process/worker_thread or during runtime.run()
+      // for browsers
+      // (because it takes time to serialize and transfer the coverage object)
+    }
+  }
+
+  const startMs = Date.now();
+  callbacks.push(() => {
+    result.duration = Date.now() - startMs;
+  });
+
+  try {
+    logger.debug(`run() ${runtimeLabel}`);
+    runOperation.throwIfAborted();
+    const winnerPromise = new Promise((resolve) => {
+      raceCallbacks(
+        {
+          aborted: (cb) => {
+            runOperation.signal.addEventListener("abort", cb);
+            return () => {
+              runOperation.signal.removeEventListener("abort", cb);
+            };
+          },
+          runned: async (cb) => {
+            try {
+              const runResult = await runtime.run({
+                signal: runOperation.signal,
+                logger,
+                ...runtimeParams,
+                collectConsole,
+                collectPerformance,
+                coverageFileUrl,
+                keepRunning,
+                stopSignal,
+                onConsole: (log) => onConsoleRef.current(log),
+              });
+              cb(runResult);
+            } catch (e) {
+              cb({
+                status: "failed",
+                errors: [e],
+              });
+            }
+          },
+        },
+        resolve,
+      );
+    });
+    const winner = await winnerPromise;
+    if (winner.name === "aborted") {
+      runOperation.throwIfAborted();
+    }
+    const { status, namespace, errors, performance } = winner.data;
+    result.status = status;
+    result.errors.push(...errors);
+    result.namespace = namespace;
+    if (collectPerformance) {
+      result.performance = performance;
+    }
+  } catch (e) {
+    if (Abort.isAbortError(e)) {
+      if (timeoutAbortSource && timeoutAbortSource.signal.aborted) {
+        result.status = "timedout";
+      } else {
+        result.status = "aborted";
+      }
+    } else {
+      result.status = "failed";
+      result.errors.push(e);
+    }
+  } finally {
+    await runOperation.end();
+  }
+
+  callbacks.forEach((callback) => {
+    callback();
+  });
+  return result;
+};
+
+const ensureGlobalGc = () => {
+  if (!global.gc) {
+    v8.setFlagsFromString("--expose_gc");
+    global.gc = runInNewContext("gc");
+  }
+};
+
 /**
  * Execute a list of files and log how it goes.
  * @param {Object} testPlanParameters
@@ -5029,7 +4678,7 @@ const executeTestPlan = async ({
   githubCheckEnabled = Boolean(process.env.GITHUB_WORKFLOW),
   githubCheckLogLevel,
   githubCheckName = "Jsenv tests",
-  githubCheckTitle,
+  githubCheckTitle = "Tests executions",
   githubCheckToken,
   githubCheckRepositoryOwner,
   githubCheckRepositoryName,
@@ -5074,10 +4723,21 @@ const executeTestPlan = async ({
   coverageReportJsonFileUrl,
   coverageReportHtml = !process.env.CI,
   coverageReportHtmlDirectoryUrl,
+
+  beforeExecutionCallback = () => {},
+  afterExecutionCallback = () => {},
+  afterAllExecutionCallback = () => {},
   ...rest
 }) => {
   const teardown = createTeardown();
 
+  const beforeExecutionCallbackSet = new Set();
+  const afterExecutionCallbackSet = new Set();
+  const afterAllExecutionCallbackSet = new Set();
+  beforeExecutionCallbackSet.add(beforeExecutionCallback);
+  afterExecutionCallbackSet.add(afterExecutionCallback);
+  afterAllExecutionCallbackSet.add(afterAllExecutionCallback);
+
   const operation = Abort.startOperation();
   operation.addAbortSignal(signal);
   if (handleSIGINT) {
@@ -5223,204 +4883,460 @@ To fix this warning:
           // It would be strange, for a given file to be both covered and executed
           throw new Error(
             createDetailedMessage(
-              `some file will be both covered and executed`,
+              `some file will be both covered and executed`,
+              {
+                patterns: patternsMatchingCoverAndExecute,
+              },
+            ),
+          );
+        }
+      }
+
+      if (coverageTempDirectoryUrl === undefined) {
+        coverageTempDirectoryUrl = new URL(
+          "./.coverage/tmp/",
+          rootDirectoryUrl,
+        );
+      } else {
+        coverageTempDirectoryUrl = assertAndNormalizeDirectoryUrl(
+          coverageTempDirectoryUrl,
+          "coverageTempDirectoryUrl",
+        );
+      }
+      if (coverageReportJson) {
+        if (coverageReportJsonFileUrl === undefined) {
+          coverageReportJsonFileUrl = new URL(
+            "./.coverage/coverage.json",
+            rootDirectoryUrl,
+          );
+        } else {
+          coverageReportJsonFileUrl = assertAndNormalizeFileUrl(
+            coverageReportJsonFileUrl,
+            "coverageReportJsonFileUrl",
+          );
+        }
+      }
+      if (coverageReportHtml) {
+        if (coverageReportHtmlDirectoryUrl === undefined) {
+          coverageReportHtmlDirectoryUrl = new URL(
+            "./.coverage/",
+            rootDirectoryUrl,
+          );
+        } else {
+          coverageReportHtmlDirectoryUrl = assertAndNormalizeDirectoryUrl(
+            coverageReportHtmlDirectoryUrl,
+            "coverageReportHtmlDirectoryUrl",
+          );
+        }
+      }
+    }
+  }
+
+  logger.debug(
+    createDetailedMessage(`Prepare executing plan`, {
+      runtimes: JSON.stringify(runtimes, null, "  "),
+    }),
+  );
+
+  // param normalization
+  {
+    if (coverageEnabled) {
+      if (Object.keys(coverageConfig).length === 0) {
+        logger.warn(
+          `coverageConfig is an empty object. Nothing will be instrumented for coverage so your coverage will be empty`,
+        );
+      }
+      if (
+        someNodeRuntime &&
+        coverageEnabled &&
+        coverageMethodForNodeJs === "NODE_V8_COVERAGE"
+      ) {
+        if (process.env.NODE_V8_COVERAGE) {
+          // when runned multiple times, we don't want to keep previous files in this directory
+          await ensureEmptyDirectory(process.env.NODE_V8_COVERAGE);
+        } else {
+          coverageMethodForNodeJs = "Profiler";
+          logger.warn(
+            createDetailedMessage(
+              `process.env.NODE_V8_COVERAGE is required to generate coverage for Node.js subprocesses`,
               {
-                patterns: patternsMatchingCoverAndExecute,
+                "suggestion": `set process.env.NODE_V8_COVERAGE`,
+                "suggestion 2": `use coverageMethodForNodeJs: "Profiler". But it means coverage for child_process and worker_thread cannot be collected`,
               },
             ),
           );
         }
       }
+    }
+  }
 
-      if (coverageTempDirectoryUrl === undefined) {
-        coverageTempDirectoryUrl = new URL(
-          "./.coverage/tmp/",
+  testPlan = {
+    "file:///**/node_modules/": null,
+    "**/*./": null,
+    ...testPlan,
+    "**/.jsenv/": null,
+  };
+  logger.debug(`Generate executions`);
+  let executionSteps = await executionStepsFromTestPlan({
+    signal,
+    testPlan,
+    rootDirectoryUrl,
+  });
+  logger.debug(`${executionSteps.length} executions planned`);
+  if (githubCheckEnabled) {
+    const githubCheckRun = await startGithubCheckRun({
+      logLevel: githubCheckLogLevel,
+      githubToken: githubCheckToken,
+      repositoryOwner: githubCheckRepositoryOwner,
+      repositoryName: githubCheckRepositoryName,
+      commitSha: githubCheckCommitSha,
+      checkName: githubCheckName,
+      checkTitle: githubCheckTitle,
+      checkSummary: `${executionSteps.length} files will be executed`,
+    });
+    const annotations = [];
+    afterExecutionCallbackSet.add((afterExecutionInfo) => {
+      const { executionResult } = afterExecutionInfo;
+      const { errors = [] } = executionResult;
+      for (const error of errors) {
+        const annotation = githubAnnotationFromError(error, {
           rootDirectoryUrl,
-        );
-      } else {
-        coverageTempDirectoryUrl = assertAndNormalizeDirectoryUrl(
-          coverageTempDirectoryUrl,
-          "coverageTempDirectoryUrl",
-        );
+          executionInfo: afterExecutionInfo,
+        });
+        annotations.push(annotation);
       }
-      if (coverageReportJson) {
-        if (coverageReportJsonFileUrl === undefined) {
-          coverageReportJsonFileUrl = new URL(
-            "./.coverage/coverage.json",
+    });
+    afterAllExecutionCallbackSet.add(async (returnValue) => {
+      const { summary } = returnValue;
+      const title = "Jsenv test results";
+      const summaryText = stripAnsi(formatSummary(summary));
+      if (summary.counters.total !== summary.counters.completed) {
+        await githubCheckRun.fail({
+          title,
+          summary: summaryText,
+          annotations,
+        });
+        return;
+      }
+      await githubCheckRun.pass({
+        title,
+        summary: summaryText,
+        annotations,
+      });
+    });
+  }
+
+  executionSteps = executionSteps.filter(
+    (executionStep) => !executionStep.runtime?.disabled,
+  );
+
+  const returnValue = {
+    aborted: false,
+    summary: null,
+    report: null,
+    coverage: null,
+  };
+  const report = {};
+  const callbacks = [];
+
+  const multipleExecutionsOperation = Abort.startOperation();
+  multipleExecutionsOperation.addAbortSignal(signal);
+  const failFastAbortController = new AbortController();
+  if (failFast) {
+    multipleExecutionsOperation.addAbortSignal(failFastAbortController.signal);
+  }
+
+  try {
+    if (gcBetweenExecutions) {
+      ensureGlobalGc();
+    }
+
+    if (coverageEnabled) {
+      // when runned multiple times, we don't want to keep previous files in this directory
+      await ensureEmptyDirectory(coverageTempDirectoryUrl);
+      callbacks.push(async () => {
+        if (multipleExecutionsOperation.signal.aborted) {
+          // don't try to do the coverage stuff
+          return;
+        }
+        try {
+          if (coverageMethodForNodeJs === "NODE_V8_COVERAGE") {
+            takeCoverage();
+            // conceptually we don't need coverage anymore so it would be
+            // good to call v8.stopCoverage()
+            // but it logs a strange message about "result is not an object"
+          }
+          const coverage = await reportToCoverage(report, {
+            signal: multipleExecutionsOperation.signal,
+            logger,
             rootDirectoryUrl,
-          );
-        } else {
-          coverageReportJsonFileUrl = assertAndNormalizeFileUrl(
-            coverageReportJsonFileUrl,
-            "coverageReportJsonFileUrl",
-          );
+            coverageConfig,
+            coverageIncludeMissing,
+            coverageMethodForNodeJs,
+            coverageV8ConflictWarning,
+          });
+          returnValue.coverage = coverage;
+        } catch (e) {
+          if (Abort.isAbortError(e)) {
+            return;
+          }
+          throw e;
+        }
+      });
+    }
+
+    const runtimeParams = {
+      rootDirectoryUrl,
+      webServer,
+
+      coverageEnabled,
+      coverageConfig,
+      coverageMethodForBrowsers,
+      coverageMethodForNodeJs,
+      isTestPlan: true,
+      teardown,
+    };
+
+    if (logMergeForCompletedExecutions && !process.stdout.isTTY) {
+      logMergeForCompletedExecutions = false;
+      logger.debug(
+        `Force logMergeForCompletedExecutions to false because process.stdout.isTTY is false`,
+      );
+    }
+    const debugLogsEnabled = logger.levels.debug;
+    const executionLogsEnabled = logger.levels.info;
+    const executionSpinner =
+      logRefresh &&
+      maxExecutionsInParallel === 1 &&
+      !debugLogsEnabled &&
+      executionLogsEnabled &&
+      process.stdout.isTTY &&
+      // if there is an error during execution npm will mess up the output
+      // (happens when npm runs several command in a workspace)
+      // so we enable spinner only when !process.exitCode (no error so far)
+      process.exitCode !== 1;
+
+    const startMs = Date.now();
+    let rawOutput = "";
+    let executionLog = createLog({ newLine: "" });
+    const counters = {
+      total: executionSteps.length,
+      aborted: 0,
+      timedout: 0,
+      failed: 0,
+      completed: 0,
+      done: 0,
+    };
+
+    const callWhenPreviousExecutionAreDone = createCallOrderer();
+
+    await executeInParallel({
+      multipleExecutionsOperation,
+      maxExecutionsInParallel,
+      cooldownBetweenExecutions,
+      executionSteps,
+      start: async (paramsFromStep) => {
+        const executionIndex = executionSteps.indexOf(paramsFromStep);
+        const { executionName, fileRelativeUrl, runtime } = paramsFromStep;
+        const runtimeType = runtime.type;
+        const runtimeName = runtime.name;
+        const runtimeVersion = runtime.version;
+        const executionParams = {
+          measurePerformance: false,
+          collectPerformance: false,
+          collectConsole: true,
+          allocatedMs: defaultMsAllocatedPerExecution,
+          ...paramsFromStep,
+          runtimeParams: {
+            fileRelativeUrl,
+            ...paramsFromStep.runtimeParams,
+          },
+        };
+        const beforeExecutionInfo = {
+          fileRelativeUrl,
+          runtimeType,
+          runtimeName,
+          runtimeVersion,
+          executionIndex,
+          executionParams,
+          startMs: Date.now(),
+          executionResult: {
+            status: "executing",
+          },
+          counters,
+          timeEllapsed: Date.now() - startMs,
+          memoryHeap: memoryUsage().heapUsed,
+        };
+        if (typeof executionParams.allocatedMs === "function") {
+          executionParams.allocatedMs =
+            executionParams.allocatedMs(beforeExecutionInfo);
+        }
+        let spinner;
+        if (executionSpinner) {
+          spinner = startSpinner({
+            log: executionLog,
+            render: () => {
+              return createExecutionLog(beforeExecutionInfo, {
+                logRuntime,
+                logEachDuration,
+                logTimeUsage,
+                logMemoryHeapUsage,
+              });
+            },
+          });
+        }
+        for (const beforeExecutionCallback of beforeExecutionCallbackSet) {
+          beforeExecutionCallback(beforeExecutionInfo);
+        }
+        const fileUrl = `${rootDirectoryUrl}${fileRelativeUrl}`;
+        let executionResult;
+        if (existsSync(new URL(fileUrl))) {
+          executionResult = await run({
+            signal: multipleExecutionsOperation.signal,
+            logger,
+            allocatedMs: executionParams.allocatedMs,
+            keepRunning,
+            mirrorConsole: false, // might be executed in parallel: log would be a mess to read
+            collectConsole: executionParams.collectConsole,
+            coverageEnabled,
+            coverageTempDirectoryUrl,
+            runtime: executionParams.runtime,
+            runtimeParams: {
+              ...runtimeParams,
+              ...executionParams.runtimeParams,
+            },
+          });
+        } else {
+          executionResult = {
+            status: "failed",
+            errors: [
+              new Error(
+                `No file at ${fileRelativeUrl} for execution "${executionName}"`,
+              ),
+            ],
+          };
         }
-      }
-      if (coverageReportHtml) {
-        if (coverageReportHtmlDirectoryUrl === undefined) {
-          coverageReportHtmlDirectoryUrl = new URL(
-            "./.coverage/",
-            rootDirectoryUrl,
-          );
+        const fileReport = report[fileRelativeUrl];
+        if (fileReport) {
+          fileReport[executionName] = executionResult;
         } else {
-          coverageReportHtmlDirectoryUrl = assertAndNormalizeDirectoryUrl(
-            coverageReportHtmlDirectoryUrl,
-            "coverageReportHtmlDirectoryUrl",
-          );
+          report[fileRelativeUrl] = {
+            [executionName]: executionResult,
+          };
         }
-      }
-    }
-  }
 
-  logger.debug(
-    createDetailedMessage(`Prepare executing plan`, {
-      runtimes: JSON.stringify(runtimes, null, "  "),
-    }),
-  );
+        const afterExecutionInfo = {
+          ...beforeExecutionInfo,
+          runtimeVersion: runtime.version,
+          endMs: Date.now(),
+          executionResult,
+        };
 
-  // param normalization
-  {
-    if (coverageEnabled) {
-      if (Object.keys(coverageConfig).length === 0) {
-        logger.warn(
-          `coverageConfig is an empty object. Nothing will be instrumented for coverage so your coverage will be empty`,
-        );
-      }
-      if (
-        someNodeRuntime &&
-        coverageEnabled &&
-        coverageMethodForNodeJs === "NODE_V8_COVERAGE"
-      ) {
-        if (process.env.NODE_V8_COVERAGE) {
-          // when runned multiple times, we don't want to keep previous files in this directory
-          await ensureEmptyDirectory(process.env.NODE_V8_COVERAGE);
-        } else {
-          coverageMethodForNodeJs = "Profiler";
-          logger.warn(
-            createDetailedMessage(
-              `process.env.NODE_V8_COVERAGE is required to generate coverage for Node.js subprocesses`,
-              {
-                "suggestion": `set process.env.NODE_V8_COVERAGE`,
-                "suggestion 2": `use coverageMethodForNodeJs: "Profiler". But it means coverage for child_process and worker_thread cannot be collected`,
-              },
-            ),
-          );
+        if (gcBetweenExecutions) {
+          global.gc();
         }
-      }
-    }
-  }
 
-  testPlan = {
-    "file:///**/node_modules/": null,
-    "**/*./": null,
-    ...testPlan,
-    "**/.jsenv/": null,
-  };
-  logger.debug(`Generate executions`);
-  const executionSteps = await executionStepsFromTestPlan({
-    signal,
-    testPlan,
-    rootDirectoryUrl,
-  });
-  logger.debug(`${executionSteps.length} executions planned`);
-  let beforeExecutionCallback;
-  let afterExecutionCallback;
-  let afterAllExecutionCallback = () => {};
-  if (githubCheckEnabled) {
-    const githubCheckRun = await startGithubCheckRun({
-      logLevel: githubCheckLogLevel,
-      githubToken: githubCheckToken,
-      repositoryOwner: githubCheckRepositoryOwner,
-      repositoryName: githubCheckRepositoryName,
-      commitSha: githubCheckCommitSha,
-      checkName: githubCheckName,
-      checkTitle: `Tests executions`,
-      checkSummary: `${executionSteps.length} files will be executed`,
-    });
-    const annotations = [];
-    afterExecutionCallback = (afterExecutionInfo) => {
-      const { executionResult } = afterExecutionInfo;
-      const { errors = [] } = executionResult;
-      for (const error of errors) {
-        const annotation = githubAnnotationFromError(error, {
-          rootDirectoryUrl,
-          executionInfo: afterExecutionInfo,
-        });
-        annotations.push(annotation);
-      }
-    };
-    afterAllExecutionCallback = async ({ testPlanSummary }) => {
-      const title = "Jsenv test results";
-      const summary = stripAnsi(formatSummary(testPlanSummary));
-      if (
-        testPlanSummary.counters.total !== testPlanSummary.counters.completed
-      ) {
-        await githubCheckRun.fail({
-          title,
-          summary,
-          annotations,
-        });
-        return;
-      }
-      await githubCheckRun.pass({
-        title,
-        summary,
-        annotations,
-      });
-    };
-  }
+        const timeEllapsed = Date.now() - startMs;
+        const memoryHeap = memoryUsage().heapUsed;
+        callWhenPreviousExecutionAreDone(executionIndex, () => {
+          counters.done++;
+          if (executionResult.status === "aborted") {
+            counters.aborted++;
+          } else if (executionResult.status === "timedout") {
+            counters.timedout++;
+          } else if (executionResult.status === "failed") {
+            counters.failed++;
+          } else if (executionResult.status === "completed") {
+            counters.completed++;
+          }
 
-  const result = await executeSteps(executionSteps, {
-    signal,
-    teardown,
-    logger,
-    logRefresh,
-    logSummary,
-    logRuntime,
-    logEachDuration,
-    logTimeUsage,
-    logMemoryHeapUsage,
-    logFileRelativeUrl,
-    logShortForCompletedExecutions,
-    logMergeForCompletedExecutions,
-    rootDirectoryUrl,
-    webServer,
+          if (executionLogsEnabled) {
+            // replace spinner with this execution result
+            if (spinner) {
+              spinner.stop();
+              spinner = null;
+            }
 
-    maxExecutionsInParallel,
-    defaultMsAllocatedPerExecution,
-    failFast,
-    keepRunning,
-    cooldownBetweenExecutions,
-    gcBetweenExecutions,
-
-    githubCheckEnabled,
-    githubCheckName,
-    githubCheckTitle,
-    githubCheckToken,
-    githubCheckRepositoryOwner,
-    githubCheckRepositoryName,
-    githubCheckCommitSha,
-
-    coverageEnabled,
-    coverageConfig,
-    coverageIncludeMissing,
-    coverageMethodForBrowsers,
-    coverageMethodForNodeJs,
-    coverageV8ConflictWarning,
-    coverageTempDirectoryUrl,
+            const log = createExecutionLog(afterExecutionInfo, {
+              logShortForCompletedExecutions,
+              logRuntime,
+              logEachDuration,
+              ...(logTimeUsage ? { timeEllapsed } : {}),
+              ...(logMemoryHeapUsage ? { memoryHeap } : {}),
+            });
 
-    beforeExecutionCallback,
-    afterExecutionCallback,
-  });
+            executionLog.write(log);
+            rawOutput += stripAnsi(log);
+            const canOverwriteLog = canOverwriteLogGetter({
+              logMergeForCompletedExecutions,
+              executionResult,
+            });
+            if (canOverwriteLog) {
+              // nothing to do, we reuse the current executionLog object
+            } else {
+              executionLog.destroy();
+              executionLog = createLog({ newLine: "" });
+            }
+            const isLastExecutionLog =
+              executionIndex === executionSteps.length - 1;
+            if (isLastExecutionLog && logger.levels.info) {
+              executionLog.write("\n");
+            }
+          }
+        });
+        for (const afterExecutionCallback of afterExecutionCallbackSet) {
+          afterExecutionCallback(afterExecutionInfo);
+        }
+        const cancelRemaining =
+          failFast &&
+          executionResult.status !== "completed" &&
+          counters.done < counters.total;
+        if (cancelRemaining) {
+          logger.info(`"failFast" enabled -> cancel remaining executions`);
+          failFastAbortController.abort();
+        }
+      },
+    });
+    if (!keepRunning) {
+      logger.debug("trigger test plan teardown");
+      await teardown.trigger();
+    }
+
+    counters.cancelled = counters.total - counters.done;
+    const summary = {
+      counters,
+      // when execution is aborted, the remaining executions are "cancelled"
+      duration: Date.now() - startMs,
+    };
+    if (logSummary) {
+      const summaryLog = formatSummaryLog(summary);
+      rawOutput += stripAnsi(summaryLog);
+      logger.info(summaryLog);
+    }
+    if (summary.counters.total !== summary.counters.completed) {
+      const logFileUrl = new URL(logFileRelativeUrl, rootDirectoryUrl).href;
+      writeFileSync(logFileUrl, rawOutput);
+      logger.info(`-> ${urlToFileSystemPath(logFileUrl)}`);
+    }
+    returnValue.aborted = multipleExecutionsOperation.signal.aborted;
+    returnValue.summary = summary;
+    returnValue.report = report;
+    for (const callback of callbacks) {
+      await callback();
+    }
+  } finally {
+    await multipleExecutionsOperation.end();
+  }
 
   const hasFailed =
-    result.planSummary.counters.total !== result.planSummary.counters.completed;
+    returnValue.summary.counters.total !==
+    returnValue.summary.counters.completed;
   if (updateProcessExitCode && hasFailed) {
     process.exitCode = 1;
   }
-  const planCoverage = result.planCoverage;
+  const coverage = returnValue.coverage;
   // planCoverage can be null when execution is aborted
-  if (planCoverage) {
+  if (coverage) {
     const promises = [];
     // keep this one first because it does ensureEmptyDirectory
     // and in case coverage json file gets written in the same directory
@@ -5432,7 +5348,7 @@ To fix this warning:
         `-> ${urlToFileSystemPath(htmlCoverageDirectoryIndexFileUrl)}`,
       );
       promises.push(
-        generateCoverageHtmlDirectory(planCoverage, {
+        generateCoverageHtmlDirectory(coverage, {
           rootDirectoryUrl,
           coverageHtmlDirectoryRelativeUrl: urlToRelativeUrl(
             coverageReportHtmlDirectoryUrl,
@@ -5446,7 +5362,7 @@ To fix this warning:
     if (coverageEnabled && coverageReportJson) {
       promises.push(
         generateCoverageJsonFile({
-          coverage: result.planCoverage,
+          coverage,
           coverageJsonFileUrl: coverageReportJsonFileUrl,
           logger,
         }),
@@ -5454,7 +5370,7 @@ To fix this warning:
     }
     if (coverageEnabled && coverageReportTextLog) {
       promises.push(
-        generateCoverageTextLog(result.planCoverage, {
+        generateCoverageTextLog(coverage, {
           coverageReportSkipEmpty,
           coverageReportSkipFull,
         }),
@@ -5463,16 +5379,85 @@ To fix this warning:
     await Promise.all(promises);
   }
 
-  const returnValue = {
-    testPlanAborted: result.aborted,
-    testPlanSummary: result.planSummary,
-    testPlanReport: result.planReport,
-    testPlanCoverage: planCoverage,
-  };
-  await afterAllExecutionCallback(returnValue);
+  for (const afterAllExecutionCallback of afterAllExecutionCallbackSet) {
+    await afterAllExecutionCallback(returnValue);
+  }
   return returnValue;
 };
 
+const canOverwriteLogGetter = ({
+  logMergeForCompletedExecutions,
+  executionResult,
+}) => {
+  if (!logMergeForCompletedExecutions) {
+    return false;
+  }
+  if (executionResult.status === "aborted") {
+    return true;
+  }
+  if (executionResult.status !== "completed") {
+    return false;
+  }
+  const { consoleCalls = [] } = executionResult;
+  if (consoleCalls.length > 0) {
+    return false;
+  }
+  return true;
+};
+
+const executeInParallel = async ({
+  multipleExecutionsOperation,
+  maxExecutionsInParallel,
+  cooldownBetweenExecutions,
+  executionSteps,
+  start,
+}) => {
+  const executionResults = [];
+  let progressionIndex = 0;
+  let remainingExecutionCount = executionSteps.length;
+
+  const nextChunk = async () => {
+    if (multipleExecutionsOperation.signal.aborted) {
+      return;
+    }
+    const outputPromiseArray = [];
+    let previousExecPromise = Promise.resolve();
+    while (
+      remainingExecutionCount > 0 &&
+      outputPromiseArray.length < maxExecutionsInParallel
+    ) {
+      remainingExecutionCount--;
+      const outputPromise = executeOne(progressionIndex, previousExecPromise);
+      previousExecPromise = outputPromise;
+      progressionIndex++;
+      outputPromiseArray.push(outputPromise);
+    }
+    if (outputPromiseArray.length) {
+      await Promise.all(outputPromiseArray);
+      if (remainingExecutionCount > 0) {
+        await nextChunk();
+      }
+    }
+  };
+
+  const executeOne = async (index, previousExecPromise) => {
+    const input = executionSteps[index];
+    const output = await start(input, previousExecPromise);
+    if (!multipleExecutionsOperation.signal.aborted) {
+      executionResults[index] = output;
+    }
+    if (cooldownBetweenExecutions) {
+      await new Promise((resolve) =>
+        setTimeout(resolve, cooldownBetweenExecutions),
+      );
+    }
+  };
+
+  await nextChunk();
+
+  return executionResults;
+};
+
 const memoize = (compute) => {
   let memoized = false;
   let memoizedValue;