@jsenv/core 25.4.9 → 25.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "25.4.9",
+  "version": "25.5.0",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {
@@ -102,6 +102,7 @@
     "rollup-plugin-node-globals": "1.4.0",
     "rollup-plugin-polyfill-node": "0.8.0",
     "source-map": "0.7.3",
+    "strip-ansi": "7.0.1",
     "systemjs": "6.11.0",
     "terser": "5.10.0",
     "v8-to-istanbul": "8.1.0",

package/src/executeTestPlan.js

@@ -28,6 +28,7 @@ import { jsenvCoverageConfig } from "./jsenvCoverageConfig.js"
  * @param {boolean} [testPlanParameters.completedExecutionLogMerging=false] Merge completed execution logs to shorten terminal output
  * @param {number} [testPlanParameters.maxExecutionsInParallel=1] Maximum amount of execution in parallel
  * @param {number} [testPlanParameters.defaultMsAllocatedPerExecution=30000] Milliseconds after which execution is aborted and considered as failed by timeout
+ * @param {boolean} [testPlanParameters.failFast=false] Fails immediatly when a test execution fails
  * @param {number} [testPlanParameters.cooldownBetweenExecutions=0] Millisecond to wait between each execution
  * @param {boolean} [testPlanParameters.logMemoryHeapUsage=false] Add memory heap usage during logs
  * @param {boolean} [testPlanParameters.coverage=false] Controls if coverage is collected during files executions
@@ -48,15 +49,17 @@ export const executeTestPlan = async ({
 
   testPlan,
 
+  logSummary = true,
   logMemoryHeapUsage = false,
+  logFileRelativeUrl = ".jsenv/test_plan_debug.txt",
   completedExecutionLogAbbreviation = false,
   completedExecutionLogMerging = false,
-  logSummary = true,
   updateProcessExitCode = true,
   windowsProcessExitFix = true,
 
   maxExecutionsInParallel = 1,
   defaultMsAllocatedPerExecution = 30000,
+  failFast = false,
   // stopAfterExecute: true to ensure runtime is stopped once executed
   // because we have what we wants: execution is completed and
   // we have associated coverage and capturedConsole
@@ -103,14 +106,11 @@ export const executeTestPlan = async ({
   jsenvDirectoryClean,
 }) => {
   const logger = createLogger({ logLevel })
-
   projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
   await assertProjectDirectoryExists({ projectDirectoryUrl })
-
   if (typeof testPlan !== "object") {
     throw new Error(`testPlan must be an object, got ${testPlan}`)
   }
-
   if (coverage) {
     if (typeof coverageConfig !== "object") {
       throw new TypeError(
@@ -155,7 +155,6 @@ export const executeTestPlan = async ({
       }
     }
   }
-
   const result = await executePlan(testPlan, {
     signal,
     handleSIGINT,
@@ -171,13 +170,15 @@ export const executeTestPlan = async ({
     importResolutionMethod,
     importDefaultExtension,
 
+    logSummary,
     logMemoryHeapUsage,
+    logFileRelativeUrl,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
-    logSummary,
 
-    defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    defaultMsAllocatedPerExecution,
+    failFast,
     stopAfterExecute,
     cooldownBetweenExecutions,
     gcBetweenExecutions,
@@ -205,11 +206,9 @@ export const executeTestPlan = async ({
     importMapInWebWorkers,
     customCompilers,
   })
-
   if (updateProcessExitCode && !executionIsPassed(result)) {
     process.exitCode = 1
   }
-
   const planCoverage = result.planCoverage
   // planCoverage can be null when execution is aborted
   if (planCoverage) {
@@ -260,7 +259,6 @@ export const executeTestPlan = async ({
     }
     await Promise.all(promises)
   }
-
   // Sometimes on windows test plan scripts never ends
   // I suspect it's some node process keeping the process alive
   // because not properly killed for some reason.
@@ -271,7 +269,6 @@ export const executeTestPlan = async ({
       process.exit()
     }, 2000).unref()
   }
-
   return {
     testPlanAborted: result.aborted,
     testPlanSummary: result.planSummary,

package/src/internal/executing/executePlan.js

@@ -1,11 +1,34 @@
-import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
-import { createDetailedMessage } from "@jsenv/logger"
+import { existsSync } from "node:fs"
+import { memoryUsage } from "node:process"
+import wrapAnsi from "wrap-ansi"
+import stripAnsi from "strip-ansi"
+import cuid from "cuid"
+import { createDetailedMessage, loggerToLevels } from "@jsenv/logger"
+import { createLog, startSpinner } from "@jsenv/log"
+import {
+  Abort,
+  raceProcessTeardownEvents,
+  createCallbackListNotifiedOnce,
+} from "@jsenv/abort"
+import {
+  urlToFileSystemPath,
+  resolveUrl,
+  writeDirectory,
+  ensureEmptyDirectory,
+  normalizeStructuredMetaMap,
+  urlToMeta,
+  writeFile,
+} from "@jsenv/filesystem"
 
-import { mergeRuntimeSupport } from "@jsenv/core/src/internal/runtime_support/runtime_support.js"
 import { startCompileServer } from "../compiling/startCompileServer.js"
 import { babelPluginInstrument } from "./coverage/babel_plugin_instrument.js"
 import { generateExecutionSteps } from "./generateExecutionSteps.js"
-import { executeConcurrently } from "./executeConcurrently.js"
+
+import { launchAndExecute } from "../executing/launchAndExecute.js"
+import { reportToCoverage } from "./coverage/reportToCoverage.js"
+import { formatExecuting, formatExecutionResult } from "./executionLogs.js"
+import { createSummaryLog } from "./createSummaryLog.js"
+import { ensureGlobalGc } from "./gc.js"
 
 export const executePlan = async (
   plan,
@@ -26,11 +49,13 @@ export const executePlan = async (
 
     logSummary,
     logMemoryHeapUsage,
+    logFileRelativeUrl,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
 
     defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    failFast,
     gcBetweenExecutions,
     stopAfterExecute,
     cooldownBetweenExecutions,
@@ -56,6 +81,9 @@ export const executePlan = async (
     serviceWorkers,
     importMapInWebWorkers,
     customCompilers,
+
+    beforeExecutionCallback = () => {},
+    afterExecutionCallback = () => {},
   } = {},
 ) => {
   if (coverage) {
@@ -67,27 +95,22 @@ export const executePlan = async (
       ],
     }
   }
-
-  const runtimeSupport = {}
+  const runtimes = {}
   Object.keys(plan).forEach((filePattern) => {
     const filePlan = plan[filePattern]
     Object.keys(filePlan).forEach((executionName) => {
       const executionConfig = filePlan[executionName]
       const { runtime } = executionConfig
       if (runtime) {
-        mergeRuntimeSupport(runtimeSupport, {
-          [runtime.name]: runtime.version,
-        })
+        runtimes[runtime.name] = runtime.version
       }
     })
   })
-
   logger.debug(
     createDetailedMessage(`Prepare executing plan`, {
-      runtimeSupport: JSON.stringify(runtimeSupport, null, "  "),
+      runtimes: JSON.stringify(runtimes, null, "  "),
     }),
   )
-
   const multipleExecutionsOperation = Abort.startOperation()
   multipleExecutionsOperation.addAbortSignal(signal)
   if (handleSIGINT) {
@@ -103,6 +126,10 @@ export const executePlan = async (
       )
     })
   }
+  const failFastAbortController = new AbortController()
+  if (failFast) {
+    multipleExecutionsOperation.addAbortSignal(failFastAbortController.signal)
+  }
 
   try {
     const compileServer = await startCompileServer({
@@ -131,74 +158,303 @@ export const executePlan = async (
       serviceWorkers,
       importMapInWebWorkers,
       customCompilers,
-      runtimeSupport,
     })
-
+    babelPluginMap = compileServer.babelPluginMap
     multipleExecutionsOperation.addEndCallback(async () => {
       await compileServer.stop()
     })
-
     logger.debug(`Generate executions`)
+    const executionSteps = await getExecutionAsSteps({
+      plan,
+      compileServer,
+      multipleExecutionsOperation,
+      projectDirectoryUrl,
+    })
+    logger.debug(`${executionSteps.length} executions planned`)
 
-    let executionSteps
-    try {
-      executionSteps = await generateExecutionSteps(
-        {
-          ...plan,
-          [compileServer.jsenvDirectoryRelativeUrl]: null,
-        },
-        {
-          signal: multipleExecutionsOperation.signal,
-          projectDirectoryUrl,
-        },
+    if (completedExecutionLogMerging && !process.stdout.isTTY) {
+      completedExecutionLogMerging = false
+      logger.debug(
+        `Force completedExecutionLogMerging to false because process.stdout.isTTY is false`,
       )
-    } catch (e) {
-      if (Abort.isAbortError(e)) {
-        return {
-          aborted: true,
-          planSummary: {},
-          planReport: {},
-          planCoverage: null,
-        }
-      }
-      throw e
     }
-    logger.debug(`${executionSteps.length} executions planned`)
+    const executionLogsEnabled = loggerToLevels(logger).info
+    const executionSpinner = executionLogsEnabled && process.stdout.isTTY
 
-    const result = await executeConcurrently(executionSteps, {
-      multipleExecutionsOperation,
-      logger,
-      launchAndExecuteLogLevel,
+    const startMs = Date.now()
+    const report = {}
+    const executionCount = executionSteps.length
+    let rawOutput = ""
+
+    let transformReturnValue = (value) => value
 
+    if (gcBetweenExecutions) {
+      ensureGlobalGc()
+    }
+
+    const coverageTempDirectoryUrl = resolveUrl(
+      coverageTempDirectoryRelativeUrl,
       projectDirectoryUrl,
-      compileServer,
+    )
+    const structuredMetaMapForCover = normalizeStructuredMetaMap(
+      {
+        cover: coverageConfig,
+      },
+      projectDirectoryUrl,
+    )
+    const coverageIgnorePredicate = (url) => {
+      return !urlToMeta({
+        url: resolveUrl(url, projectDirectoryUrl),
+        structuredMetaMap: structuredMetaMapForCover,
+      }).cover
+    }
 
-      // not sure we actually have to pass import params to executeConcurrently
-      importResolutionMethod,
-      importDefaultExtension,
+    if (coverage) {
+      // in case runned multiple times, we don't want to keep writing lot of files in this directory
+      if (!process.env.NODE_V8_COVERAGE) {
+        await ensureEmptyDirectory(coverageTempDirectoryUrl)
+      }
+      if (runtimes.node) {
+        // v8 coverage is written in a directoy and auto propagate to subprocesses
+        // through process.env.NODE_V8_COVERAGE.
+        if (!coverageForceIstanbul && !process.env.NODE_V8_COVERAGE) {
+          const v8CoverageDirectory = resolveUrl(
+            `./node_v8/${cuid()}`,
+            coverageTempDirectoryUrl,
+          )
+          await writeDirectory(v8CoverageDirectory, { allowUseless: true })
+          process.env.NODE_V8_COVERAGE =
+            urlToFileSystemPath(v8CoverageDirectory)
+        }
+      }
+
+      transformReturnValue = async (value) => {
+        if (multipleExecutionsOperation.signal.aborted) {
+          // don't try to do the coverage stuff
+          return value
+        }
 
-      babelPluginMap: compileServer.babelPluginMap,
+        try {
+          value.coverage = await reportToCoverage(value.report, {
+            signal: multipleExecutionsOperation.signal,
+            logger,
+            projectDirectoryUrl,
+            babelPluginMap,
+            coverageConfig,
+            coverageIncludeMissing,
+            coverageForceIstanbul,
+            coverageIgnorePredicate,
+            coverageV8ConflictWarning,
+          })
+        } catch (e) {
+          if (Abort.isAbortError(e)) {
+            return value
+          }
+          throw e
+        }
+        return value
+      }
+    }
 
-      logSummary,
-      logMemoryHeapUsage,
-      completedExecutionLogMerging,
-      completedExecutionLogAbbreviation,
+    logger.info("")
+    let executionLog = createLog({ newLine: "" })
+    let abortedCount = 0
+    let timedoutCount = 0
+    let erroredCount = 0
+    let completedCount = 0
+    const stopAfterAllExecutionCallbackList = createCallbackListNotifiedOnce()
 
-      defaultMsAllocatedPerExecution,
+    let executionDoneCount = 0
+    await executeInParallel({
+      multipleExecutionsOperation,
       maxExecutionsInParallel,
-      stopAfterExecute,
-      gcBetweenExecutions,
       cooldownBetweenExecutions,
+      executionSteps,
+      start: async (paramsFromStep) => {
+        const executionIndex = executionSteps.indexOf(paramsFromStep)
+        const { executionName, fileRelativeUrl, runtime } = paramsFromStep
+        const runtimeName = runtime.name
+        const runtimeVersion = runtime.version
 
-      coverage,
-      coverageConfig,
-      coverageIncludeMissing,
-      coverageForceIstanbul,
-      coverageV8ConflictWarning,
-      coverageTempDirectoryRelativeUrl,
-      runtimeSupport,
+        const executionParams = {
+          // the params below can be overriden by executionDefaultParams
+          measurePerformance: false,
+          collectPerformance: false,
+          captureConsole: true,
+          stopAfterExecute,
+          stopAfterExecuteReason: "execution-done",
+          allocatedMs: defaultMsAllocatedPerExecution,
+          ...paramsFromStep,
+          runtime,
+          // mirrorConsole: false because file will be executed in parallel
+          // so log would be a mess to read
+          mirrorConsole: false,
+        }
+
+        const beforeExecutionInfo = {
+          fileRelativeUrl,
+          runtimeName,
+          runtimeVersion,
+          executionIndex,
+          executionParams,
+        }
+
+        let spinner
+        if (executionSpinner) {
+          spinner = startSpinner({
+            log: executionLog,
+            text: formatExecuting(beforeExecutionInfo, {
+              executionCount,
+              abortedCount,
+              timedoutCount,
+              erroredCount,
+              completedCount,
+              ...(logMemoryHeapUsage
+                ? { memoryHeap: memoryUsage().heapUsed }
+                : {}),
+            }),
+          })
+        }
+        beforeExecutionCallback(beforeExecutionInfo)
+
+        const filePath = urlToFileSystemPath(
+          `${projectDirectoryUrl}${fileRelativeUrl}`,
+        )
+        let executionResult
+        if (existsSync(filePath)) {
+          executionResult = await launchAndExecute({
+            signal: multipleExecutionsOperation.signal,
+            launchAndExecuteLogLevel,
+
+            ...executionParams,
+            collectCoverage: coverage,
+            coverageTempDirectoryUrl,
+            runtimeParams: {
+              projectDirectoryUrl,
+              compileServerOrigin: compileServer.origin,
+              compileServerId: compileServer.id,
+              jsenvDirectoryRelativeUrl:
+                compileServer.jsenvDirectoryRelativeUrl,
+
+              collectCoverage: coverage,
+              coverageIgnorePredicate,
+              coverageForceIstanbul,
+              stopAfterAllExecutionCallbackList,
+              ...executionParams.runtimeParams,
+            },
+            executeParams: {
+              fileRelativeUrl,
+              ...executionParams.executeParams,
+            },
+            coverageV8ConflictWarning,
+          })
+        } else {
+          executionResult = {
+            status: "errored",
+            error: new Error(
+              `No file at ${fileRelativeUrl} for execution "${executionName}"`,
+            ),
+          }
+        }
+        executionDoneCount++
+        if (fileRelativeUrl in report === false) {
+          report[fileRelativeUrl] = {}
+        }
+        report[fileRelativeUrl][executionName] = executionResult
+        const afterExecutionInfo = {
+          ...beforeExecutionInfo,
+          endMs: Date.now(),
+          executionResult,
+        }
+        afterExecutionCallback(afterExecutionInfo)
+
+        if (executionResult.status === "aborted") {
+          abortedCount++
+        } else if (executionResult.status === "timedout") {
+          timedoutCount++
+        } else if (executionResult.status === "errored") {
+          erroredCount++
+        } else if (executionResult.status === "completed") {
+          completedCount++
+        }
+        if (gcBetweenExecutions) {
+          global.gc()
+        }
+        if (executionLogsEnabled) {
+          let log = formatExecutionResult(afterExecutionInfo, {
+            completedExecutionLogAbbreviation,
+            executionCount,
+            abortedCount,
+            timedoutCount,
+            erroredCount,
+            completedCount,
+            ...(logMemoryHeapUsage
+              ? { memoryHeap: memoryUsage().heapUsed }
+              : {}),
+          })
+          log = `${log}
+  
+`
+          const { columns = 80 } = process.stdout
+          log = wrapAnsi(log, columns, {
+            trim: false,
+            hard: true,
+            wordWrap: false,
+          })
+
+          // replace spinner with this execution result
+          if (spinner) spinner.stop()
+          executionLog.write(log)
+          rawOutput += stripAnsi(log)
+
+          const canOverwriteLog = canOverwriteLogGetter({
+            completedExecutionLogMerging,
+            executionResult,
+          })
+          if (canOverwriteLog) {
+            // nothing to do, we reuse the current executionLog object
+          } else {
+            executionLog.destroy()
+            executionLog = createLog({ newLine: "" })
+          }
+        }
+        if (
+          failFast &&
+          executionResult.status !== "completed" &&
+          executionDoneCount < executionCount
+        ) {
+          logger.info(`"failFast" enabled -> cancel remaining executions`)
+          failFastAbortController.abort()
+        }
+      },
     })
 
+    if (stopAfterExecute) {
+      stopAfterAllExecutionCallbackList.notify()
+    }
+
+    const summaryCounts = reportToSummary(report)
+    const summary = {
+      executionCount,
+      ...summaryCounts,
+      // when execution is aborted, the remaining executions are "cancelled"
+      cancelledCount: executionCount - executionDoneCount,
+      duration: Date.now() - startMs,
+    }
+    if (logSummary) {
+      const summaryLog = createSummaryLog(summary)
+      rawOutput += stripAnsi(summaryLog)
+      logger.info(summaryLog)
+    }
+    if (summary.executionCount !== summary.completedCount) {
+      const logFileUrl = new URL(logFileRelativeUrl, projectDirectoryUrl)
+      writeFile(logFileUrl, rawOutput)
+      logger.info(`-> ${urlToFileSystemPath(logFileUrl)}`)
+    }
+    const result = await transformReturnValue({
+      summary,
+      report,
+    })
     return {
       aborted: multipleExecutionsOperation.signal.aborted,
       planSummary: result.summary,
@@ -209,3 +465,137 @@ export const executePlan = async (
     await multipleExecutionsOperation.end()
   }
 }
+
+const getExecutionAsSteps = async ({
+  plan,
+  compileServer,
+  multipleExecutionsOperation,
+  projectDirectoryUrl,
+}) => {
+  try {
+    const executionSteps = await generateExecutionSteps(
+      {
+        ...plan,
+        [compileServer.jsenvDirectoryRelativeUrl]: null,
+      },
+      {
+        signal: multipleExecutionsOperation.signal,
+        projectDirectoryUrl,
+      },
+    )
+    return executionSteps
+  } catch (e) {
+    if (Abort.isAbortError(e)) {
+      return {
+        aborted: true,
+        planSummary: {},
+        planReport: {},
+        planCoverage: null,
+      }
+    }
+    throw e
+  }
+}
+
+const canOverwriteLogGetter = ({
+  completedExecutionLogMerging,
+  executionResult,
+}) => {
+  if (!completedExecutionLogMerging) {
+    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 reportToSummary = (report) => {
+  const fileNames = Object.keys(report)
+  const countResultMatching = (predicate) => {
+    return fileNames.reduce((previous, fileName) => {
+      const fileExecutionResult = report[fileName]
+
+      return (
+        previous +
+        Object.keys(fileExecutionResult).filter((executionName) => {
+          const fileExecutionResultForRuntime =
+            fileExecutionResult[executionName]
+          return predicate(fileExecutionResultForRuntime)
+        }).length
+      )
+    }, 0)
+  }
+  const abortedCount = countResultMatching(({ status }) => status === "aborted")
+  const timedoutCount = countResultMatching(
+    ({ status }) => status === "timedout",
+  )
+  const erroredCount = countResultMatching(({ status }) => status === "errored")
+  const completedCount = countResultMatching(
+    ({ status }) => status === "completed",
+  )
+  return {
+    abortedCount,
+    timedoutCount,
+    erroredCount,
+    completedCount,
+  }
+}

package/src/internal/runtime_support/runtime_support.js

@@ -56,7 +56,7 @@ const normalizeRuntimeVersion = (version) => {
   return version
 }
 
-export const mergeRuntimeSupport = (runtimeSupport, childRuntimeSupport) => {
+const mergeRuntimeSupport = (runtimeSupport, childRuntimeSupport) => {
   Object.keys(childRuntimeSupport).forEach((runtimeName) => {
     const childRuntimeVersion = normalizeRuntimeVersion(
       childRuntimeSupport[runtimeName],

package/src/internal/executing/executeConcurrently.js

@@ -1,440 +0,0 @@
-import { existsSync } from "node:fs"
-import { memoryUsage } from "node:process"
-import wrapAnsi from "wrap-ansi"
-import cuid from "cuid"
-import { loggerToLevels } from "@jsenv/logger"
-import { createLog, startSpinner } from "@jsenv/log"
-import {
-  urlToFileSystemPath,
-  resolveUrl,
-  writeDirectory,
-  ensureEmptyDirectory,
-  normalizeStructuredMetaMap,
-  urlToMeta,
-} from "@jsenv/filesystem"
-import { Abort, createCallbackListNotifiedOnce } from "@jsenv/abort"
-
-import { launchAndExecute } from "../executing/launchAndExecute.js"
-import { reportToCoverage } from "./coverage/reportToCoverage.js"
-import { formatExecuting, formatExecutionResult } from "./executionLogs.js"
-import { createSummaryLog } from "./createSummaryLog.js"
-import { ensureGlobalGc } from "./gc.js"
-
-export const executeConcurrently = async (
-  executionSteps,
-  {
-    multipleExecutionsOperation,
-
-    logger,
-    launchAndExecuteLogLevel,
-
-    projectDirectoryUrl,
-    compileServer,
-    babelPluginMap,
-
-    logSummary,
-    logMemoryHeapUsage,
-    completedExecutionLogMerging,
-    completedExecutionLogAbbreviation,
-
-    maxExecutionsInParallel,
-    defaultMsAllocatedPerExecution,
-    stopAfterExecute,
-    cooldownBetweenExecutions,
-    gcBetweenExecutions,
-
-    coverage,
-    coverageConfig,
-    coverageIncludeMissing,
-    coverageForceIstanbul,
-    coverageV8ConflictWarning,
-    coverageTempDirectoryRelativeUrl,
-    runtimeSupport,
-
-    beforeExecutionCallback = () => {},
-    afterExecutionCallback = () => {},
-  },
-) => {
-  if (completedExecutionLogMerging && !process.stdout.isTTY) {
-    completedExecutionLogMerging = false
-    logger.debug(
-      `Force completedExecutionLogMerging to false because process.stdout.isTTY is false`,
-    )
-  }
-  const executionLogsEnabled = loggerToLevels(logger).info
-  const executionSpinner = executionLogsEnabled && process.stdout.isTTY
-
-  const startMs = Date.now()
-  const report = {}
-  const executionCount = executionSteps.length
-
-  let transformReturnValue = (value) => value
-
-  if (gcBetweenExecutions) {
-    ensureGlobalGc()
-  }
-
-  const coverageTempDirectoryUrl = resolveUrl(
-    coverageTempDirectoryRelativeUrl,
-    projectDirectoryUrl,
-  )
-
-  const structuredMetaMapForCover = normalizeStructuredMetaMap(
-    {
-      cover: coverageConfig,
-    },
-    projectDirectoryUrl,
-  )
-  const coverageIgnorePredicate = (url) => {
-    return !urlToMeta({
-      url: resolveUrl(url, projectDirectoryUrl),
-      structuredMetaMap: structuredMetaMapForCover,
-    }).cover
-  }
-
-  if (coverage) {
-    // in case runned multiple times, we don't want to keep writing lot of files in this directory
-    if (!process.env.NODE_V8_COVERAGE) {
-      await ensureEmptyDirectory(coverageTempDirectoryUrl)
-    }
-
-    if (runtimeSupport.node) {
-      // v8 coverage is written in a directoy and auto propagate to subprocesses
-      // through process.env.NODE_V8_COVERAGE.
-      if (!coverageForceIstanbul && !process.env.NODE_V8_COVERAGE) {
-        const v8CoverageDirectory = resolveUrl(
-          `./node_v8/${cuid()}`,
-          coverageTempDirectoryUrl,
-        )
-        await writeDirectory(v8CoverageDirectory, { allowUseless: true })
-        process.env.NODE_V8_COVERAGE = urlToFileSystemPath(v8CoverageDirectory)
-      }
-    }
-
-    transformReturnValue = async (value) => {
-      if (multipleExecutionsOperation.signal.aborted) {
-        // don't try to do the coverage stuff
-        return value
-      }
-
-      try {
-        value.coverage = await reportToCoverage(value.report, {
-          signal: multipleExecutionsOperation.signal,
-          logger,
-          projectDirectoryUrl,
-          babelPluginMap,
-          coverageConfig,
-          coverageIncludeMissing,
-          coverageForceIstanbul,
-          coverageIgnorePredicate,
-          coverageV8ConflictWarning,
-        })
-      } catch (e) {
-        if (Abort.isAbortError(e)) {
-          return value
-        }
-        throw e
-      }
-      return value
-    }
-  }
-
-  logger.info("")
-  let executionLog = createLog({ newLine: "" })
-  let abortedCount = 0
-  let timedoutCount = 0
-  let erroredCount = 0
-  let completedCount = 0
-  const stopAfterAllExecutionCallbackList = createCallbackListNotifiedOnce()
-
-  const executionsDone = await executeInParallel({
-    multipleExecutionsOperation,
-    maxExecutionsInParallel,
-    cooldownBetweenExecutions,
-    executionSteps,
-    start: async (paramsFromStep) => {
-      const executionIndex = executionSteps.indexOf(paramsFromStep)
-      const { executionName, fileRelativeUrl, runtime } = paramsFromStep
-      const runtimeName = runtime.name
-      const runtimeVersion = runtime.version
-
-      const executionParams = {
-        // the params below can be overriden by executionDefaultParams
-        measurePerformance: false,
-        collectPerformance: false,
-        captureConsole: true,
-        stopAfterExecute,
-        stopAfterExecuteReason: "execution-done",
-        allocatedMs: defaultMsAllocatedPerExecution,
-        ...paramsFromStep,
-        runtime,
-        // mirrorConsole: false because file will be executed in parallel
-        // so log would be a mess to read
-        mirrorConsole: false,
-      }
-
-      const beforeExecutionInfo = {
-        fileRelativeUrl,
-        runtimeName,
-        runtimeVersion,
-        executionIndex,
-        executionParams,
-      }
-
-      let spinner
-      if (executionSpinner) {
-        spinner = startSpinner({
-          log: executionLog,
-          text: formatExecuting(beforeExecutionInfo, {
-            executionCount,
-            abortedCount,
-            timedoutCount,
-            erroredCount,
-            completedCount,
-            ...(logMemoryHeapUsage
-              ? { memoryHeap: memoryUsage().heapUsed }
-              : {}),
-          }),
-        })
-      }
-      beforeExecutionCallback(beforeExecutionInfo)
-
-      const filePath = urlToFileSystemPath(
-        `${projectDirectoryUrl}${fileRelativeUrl}`,
-      )
-      let executionResult
-      if (existsSync(filePath)) {
-        executionResult = await launchAndExecute({
-          signal: multipleExecutionsOperation.signal,
-          launchAndExecuteLogLevel,
-
-          ...executionParams,
-          collectCoverage: coverage,
-          coverageTempDirectoryUrl,
-          runtimeParams: {
-            projectDirectoryUrl,
-            compileServerOrigin: compileServer.origin,
-            compileServerId: compileServer.id,
-            jsenvDirectoryRelativeUrl: compileServer.jsenvDirectoryRelativeUrl,
-
-            collectCoverage: coverage,
-            coverageIgnorePredicate,
-            coverageForceIstanbul,
-            stopAfterAllExecutionCallbackList,
-            ...executionParams.runtimeParams,
-          },
-          executeParams: {
-            fileRelativeUrl,
-            ...executionParams.executeParams,
-          },
-          coverageV8ConflictWarning,
-        })
-      } else {
-        executionResult = {
-          status: "errored",
-          error: new Error(
-            `No file at ${fileRelativeUrl} for execution "${executionName}"`,
-          ),
-        }
-      }
-      if (fileRelativeUrl in report === false) {
-        report[fileRelativeUrl] = {}
-      }
-      report[fileRelativeUrl][executionName] = executionResult
-      const afterExecutionInfo = {
-        ...beforeExecutionInfo,
-        endMs: Date.now(),
-        executionResult,
-      }
-      afterExecutionCallback(afterExecutionInfo)
-
-      if (executionResult.status === "aborted") {
-        abortedCount++
-      } else if (executionResult.status === "timedout") {
-        timedoutCount++
-      } else if (executionResult.status === "errored") {
-        erroredCount++
-      } else if (executionResult.status === "completed") {
-        completedCount++
-      }
-
-      if (gcBetweenExecutions) {
-        global.gc()
-      }
-
-      if (executionLogsEnabled) {
-        let log = formatExecutionResult(afterExecutionInfo, {
-          completedExecutionLogAbbreviation,
-          executionCount,
-          abortedCount,
-          timedoutCount,
-          erroredCount,
-          completedCount,
-          ...(logMemoryHeapUsage ? { memoryHeap: memoryUsage().heapUsed } : {}),
-        })
-        log = `${log}
-
-`
-        const { columns = 80 } = process.stdout
-        log = wrapAnsi(log, columns, {
-          trim: false,
-          hard: true,
-          wordWrap: false,
-        })
-
-        // replace spinner with this execution result
-        if (spinner) spinner.stop()
-        executionLog.write(log)
-
-        const canOverwriteLog = canOverwriteLogGetter({
-          completedExecutionLogMerging,
-          executionResult,
-        })
-        if (canOverwriteLog) {
-          // nothing to do, we reuse the current executionLog object
-        } else {
-          executionLog.destroy()
-          executionLog = createLog({ newLine: "" })
-        }
-      }
-    },
-  })
-
-  if (stopAfterExecute) {
-    stopAfterAllExecutionCallbackList.notify()
-  }
-
-  const summaryCounts = reportToSummary(report)
-
-  const summary = {
-    executionCount,
-    ...summaryCounts,
-    // when execution is aborted, the remaining executions are "cancelled"
-    cancelledCount:
-      executionCount -
-      executionsDone.length -
-      // we substract abortedCount because they are not pushed into executionsDone
-      summaryCounts.abortedCount,
-    duration: Date.now() - startMs,
-  }
-  if (logSummary) {
-    logger.info(createSummaryLog(summary))
-  }
-
-  return transformReturnValue({
-    summary,
-    report,
-  })
-}
-
-const canOverwriteLogGetter = ({
-  completedExecutionLogMerging,
-  executionResult,
-}) => {
-  if (!completedExecutionLogMerging) {
-    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,
-  executionSteps,
-  start,
-  maxExecutionsInParallel = 1,
-  cooldownBetweenExecutions,
-}) => {
-  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 reportToSummary = (report) => {
-  const fileNames = Object.keys(report)
-
-  const countResultMatching = (predicate) => {
-    return fileNames.reduce((previous, fileName) => {
-      const fileExecutionResult = report[fileName]
-
-      return (
-        previous +
-        Object.keys(fileExecutionResult).filter((executionName) => {
-          const fileExecutionResultForRuntime =
-            fileExecutionResult[executionName]
-          return predicate(fileExecutionResultForRuntime)
-        }).length
-      )
-    }, 0)
-  }
-
-  const abortedCount = countResultMatching(({ status }) => status === "aborted")
-  const timedoutCount = countResultMatching(
-    ({ status }) => status === "timedout",
-  )
-  const erroredCount = countResultMatching(({ status }) => status === "errored")
-  const completedCount = countResultMatching(
-    ({ status }) => status === "completed",
-  )
-
-  return {
-    abortedCount,
-    timedoutCount,
-    erroredCount,
-    completedCount,
-  }
-}