@jsenv/core 27.1.0 → 27.2.0

package/src/omega/server/file_service.js

@@ -50,10 +50,10 @@ export const createFileService = ({
       reference = urlGraph.inferReference(request.ressource, parentUrl)
     }
     if (!reference) {
-      const entryPoint = kitchen.prepareEntryPoint({
+      const entryPoint = kitchen.injectReference({
         trace: parentUrl || rootDirectoryUrl,
         parentUrl: parentUrl || rootDirectoryUrl,
-        type: "entry_point",
+        type: "http_request",
         specifier: request.ressource,
       })
       reference = entryPoint[0]

package/src/omega/url_graph/url_graph_load.js

@@ -56,7 +56,6 @@ export const loadUrlGraph = async ({
         type,
         specifier,
       })
-      entryUrlInfo.data.isEntryPoint = true
       cook(entryUrlInfo, { reference: entryReference })
       return [entryReference, entryUrlInfo]
     },

package/src/omega/url_graph.js

@@ -207,6 +207,7 @@ const createUrlInfo = (url) => {
     originalUrl: undefined,
     generatedUrl: null,
     filename: "",
+    isEntryPoint: false,
     isInline: false,
     inlineUrlSite: null,
     shouldHandle: undefined,

package/src/plugins/bundling/js_module/bundle_js_module.js

@@ -94,7 +94,7 @@ const rollupPluginJsenv = ({
       let previousNonEntryPointModuleId
       jsModuleUrlInfos.forEach((jsModuleUrlInfo) => {
         const id = jsModuleUrlInfo.url
-        if (jsModuleUrlInfo.data.isEntryPoint) {
+        if (jsModuleUrlInfo.isEntryPoint) {
           emitChunk({
             id,
           })
@@ -355,10 +355,7 @@ const willBeInsideJsDirectory = ({
     // generated by rollup
     return true
   }
-  if (
-    !jsModuleUrlInfo.data.isEntryPoint &&
-    !jsModuleUrlInfo.data.isWebWorkerEntryPoint
-  ) {
+  if (!jsModuleUrlInfo.isEntryPoint) {
     // not an entry point, jsenv will put it inside js/ directory
     return true
   }

package/src/plugins/transpilation/as_js_classic/jsenv_plugin_as_js_classic.js

@@ -101,24 +101,24 @@ const jsenvPluginAsJsClassicConversion = ({
       if (!originalUrlInfo) {
         return null
       }
-      const isJsEntryPoint =
-        // in general html files are entry points
-        // but during build js can be sepcified as an entry point
-        // (meaning there is no html file where we can inject systemjs)
-        // in that case we need to inject systemjs in the js file
-        originalUrlInfo.data.isEntryPoint ||
-        // In thoose case we need to inject systemjs the worker js file
-        originalUrlInfo.data.isWebWorkerEntryPoint
-      // if it's an entry point without dependency (it does not use import)
-      // then we can use UMD, otherwise we have to use systemjs
-      // because it is imported by systemjs
       const jsClassicFormat =
-        isJsEntryPoint && !originalUrlInfo.data.usesImport ? "umd" : "system"
+        // in general html file are entry points, but js can be entry point when:
+        // - passed in entryPoints to build
+        // - is used by web worker
+        // - the reference contains ?entry_point
+        // When js is entry point there can be no HTML to inject systemjs
+        // and systemjs must be injected into the js file
+        originalUrlInfo.isEntryPoint &&
+        // if it's an entry point without dependency (it does not use import)
+        // then we can use UMD, otherwise we have to use systemjs
+        // because it is imported by systemjs
+        !originalUrlInfo.data.usesImport
+          ? "umd"
+          : "system"
       const { content, sourcemap } = await convertJsModuleToJsClassic({
         systemJsInjection,
         systemJsClientFileUrl,
         urlInfo: originalUrlInfo,
-        isJsEntryPoint,
         jsClassicFormat,
       })
       urlInfo.data.jsClassicFormat = jsClassicFormat
@@ -160,7 +160,6 @@ const convertJsModuleToJsClassic = async ({
   systemJsInjection,
   systemJsClientFileUrl,
   urlInfo,
-  isJsEntryPoint,
   jsClassicFormat,
 }) => {
   const { code, map } = await applyBabelPlugins({
@@ -193,7 +192,11 @@ const convertJsModuleToJsClassic = async ({
   })
   let sourcemap = urlInfo.sourcemap
   sourcemap = await composeTwoSourcemaps(sourcemap, map)
-  if (systemJsInjection && jsClassicFormat === "system" && isJsEntryPoint) {
+  if (
+    systemJsInjection &&
+    jsClassicFormat === "system" &&
+    urlInfo.isEntryPoint
+  ) {
     const magicSource = createMagicSource(code)
     const systemjsCode = readFileSync(systemJsClientFileUrl, { as: "string" })
     magicSource.prepend(`${systemjsCode}\n\n`)

package/src/plugins/url_resolution/jsenv_plugin_url_resolution.js

@@ -9,7 +9,8 @@ export const jsenvPluginUrlResolution = () => {
     name: "jsenv:url_resolution",
     appliesDuring: "*",
     resolveUrl: {
-      "entry_point": urlResolver,
+      "http_request": urlResolver, // during dev
+      "entry_point": urlResolver, // during build
       "link_href": urlResolver,
       "script_src": urlResolver,
       "a_href": urlResolver,

package/src/test/coverage/report_to_coverage.js

@@ -1,10 +1,8 @@
-import { readFile } from "@jsenv/filesystem"
+import { readFileSync } from "node:fs"
 import { Abort } from "@jsenv/abort"
 
-import {
-  visitNodeV8Directory,
-  filterV8Coverage,
-} from "./v8_coverage_from_directory.js"
+import { filterV8Coverage } from "./v8_coverage.js"
+import { readNodeV8CoverageDirectory } from "./v8_coverage_node_directory.js"
 import { composeTwoV8Coverages } from "./v8_coverage_composition.js"
 import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
 import { v8CoverageToIstanbul } from "./v8_coverage_to_istanbul.js"
@@ -20,8 +18,7 @@ export const reportToCoverage = async (
     rootDirectoryUrl,
     coverageConfig,
     coverageIncludeMissing,
-    urlShouldBeCovered,
-    coverageForceIstanbul,
+    coverageMethodForNodeJs,
     coverageV8ConflictWarning,
   },
 ) => {
@@ -49,24 +46,24 @@ export const reportToCoverage = async (
       // that were suppose to be coverage but were not.
       if (
         executionResult.status === "completed" &&
-        executionResult.runtimeName !== "node" &&
-        !process.env.NODE_V8_COVERAGE
+        executionResult.type === "node" &&
+        coverageMethodForNodeJs !== "NODE_V8_COVERAGE"
       ) {
         logger.warn(
-          `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
+          `No "coverageFileUrl" from execution named "${executionName}" of ${file}`,
         )
       }
     },
   })
 
-  if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
-    await visitNodeV8Directory({
+  if (coverageMethodForNodeJs === "NODE_V8_COVERAGE") {
+    await readNodeV8CoverageDirectory({
       logger,
       signal,
-      NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
-      onV8Coverage: (nodeV8Coverage) => {
-        const nodeV8CoverageLight = filterV8Coverage(nodeV8Coverage, {
-          urlShouldBeCovered,
+      onV8Coverage: async (nodeV8Coverage) => {
+        const nodeV8CoverageLight = await filterV8Coverage(nodeV8Coverage, {
+          rootDirectoryUrl,
+          coverageConfig,
         })
         v8Coverage = v8Coverage
           ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
@@ -164,9 +161,9 @@ const getCoverageFromReport = async ({ signal, report, onMissing }) => {
             return
           }
 
-          const executionCoverage = await readFile(coverageFileUrl, {
-            as: "json",
-          })
+          const executionCoverage = JSON.parse(
+            String(readFileSync(new URL(coverageFileUrl))),
+          )
           if (isV8Coverage(executionCoverage)) {
             v8Coverage = v8Coverage
               ? composeTwoV8Coverages(v8Coverage, executionCoverage)

package/src/test/coverage/v8_coverage.js

@@ -0,0 +1,26 @@
+import { URL_META } from "@jsenv/url-meta"
+
+export const filterV8Coverage = async (
+  v8Coverage,
+  { rootDirectoryUrl, coverageConfig },
+) => {
+  const associations = URL_META.resolveAssociations(
+    { cover: coverageConfig },
+    rootDirectoryUrl,
+  )
+  const urlShouldBeCovered = (url) => {
+    const { cover } = URL_META.applyAssociations({
+      url: new URL(url, rootDirectoryUrl).href,
+      associations,
+    })
+    return cover
+  }
+
+  const v8CoverageFiltered = {
+    ...v8Coverage,
+    result: v8Coverage.result.filter((fileReport) =>
+      urlShouldBeCovered(fileReport.url),
+    ),
+  }
+  return v8CoverageFiltered
+}

package/src/test/coverage/{v8_coverage_from_directory.js → v8_coverage_node_directory.js}

@@ -1,27 +1,30 @@
-import {
-  assertAndNormalizeDirectoryUrl,
-  readDirectory,
-  readFile,
-} from "@jsenv/filesystem"
-import { resolveUrl } from "@jsenv/urls"
+import { readFileSync, readdirSync } from "node:fs"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/log"
 import { Abort } from "@jsenv/abort"
 
-export const visitNodeV8Directory = async ({
+export const readNodeV8CoverageDirectory = async ({
   logger,
   signal,
-  NODE_V8_COVERAGE,
   onV8Coverage,
   maxMsWaitingForNodeToWriteCoverageFile = 2000,
 }) => {
+  const NODE_V8_COVERAGE = process.env.NODE_V8_COVERAGE
   const operation = Abort.startOperation()
   operation.addAbortSignal(signal)
 
+  let timeSpentTrying = 0
   const tryReadDirectory = async () => {
-    const dirContent = await readDirectory(NODE_V8_COVERAGE)
+    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
   }
@@ -32,17 +35,19 @@ export const visitNodeV8Directory = async ({
 
     const coverageDirectoryUrl =
       assertAndNormalizeDirectoryUrl(NODE_V8_COVERAGE)
+
     await dirContent.reduce(async (previous, dirEntry) => {
       operation.throwIfAborted()
       await previous
 
-      const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
-      const tryReadJsonFile = async (timeSpentTrying = 0) => {
-        const fileContent = await readFile(dirEntryUrl, { as: "string" })
+      const dirEntryUrl = new URL(dirEntry, coverageDirectoryUrl)
+      const tryReadJsonFile = async () => {
+        const fileContent = String(readFileSync(dirEntryUrl))
         if (fileContent === "") {
-          if (timeSpentTrying < 400) {
+          if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
             await new Promise((resolve) => setTimeout(resolve, 200))
-            return tryReadJsonFile(timeSpentTrying + 200)
+            timeSpentTrying += 200
+            return tryReadJsonFile()
           }
           console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`)
           return null
@@ -54,7 +59,8 @@ export const visitNodeV8Directory = async ({
         } catch (e) {
           if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
             await new Promise((resolve) => setTimeout(resolve, 200))
-            return tryReadJsonFile(timeSpentTrying + 200)
+            timeSpentTrying += 200
+            return tryReadJsonFile()
           }
           console.warn(
             createDetailedMessage(`Error while reading coverage file`, {
@@ -68,20 +74,10 @@ export const visitNodeV8Directory = async ({
 
       const fileContent = await tryReadJsonFile()
       if (fileContent) {
-        onV8Coverage(fileContent)
+        await onV8Coverage(fileContent)
       }
     }, Promise.resolve())
   } finally {
     await operation.end()
   }
 }
-
-export const filterV8Coverage = (v8Coverage, { urlShouldBeCovered }) => {
-  const v8CoverageFiltered = {
-    ...v8Coverage,
-    result: v8Coverage.result.filter((fileReport) =>
-      urlShouldBeCovered(fileReport.url),
-    ),
-  }
-  return v8CoverageFiltered
-}

package/src/test/execute_plan.js

@@ -1,10 +1,9 @@
 import { existsSync } from "node:fs"
 import { memoryUsage } from "node:process"
+import { takeCoverage } from "node:v8"
 import wrapAnsi from "wrap-ansi"
 import stripAnsi from "strip-ansi"
-import cuid from "cuid"
 
-import { URL_META } from "@jsenv/url-meta"
 import { urlToFileSystemPath } from "@jsenv/urls"
 import {
   createDetailedMessage,
@@ -13,11 +12,7 @@ import {
   startSpinner,
 } from "@jsenv/log"
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
-import {
-  writeDirectory,
-  ensureEmptyDirectory,
-  writeFileSync,
-} from "@jsenv/filesystem"
+import { ensureEmptyDirectory, writeFileSync } from "@jsenv/filesystem"
 
 import { babelPluginInstrument } from "./coverage/babel_plugin_instrument.js"
 import { reportToCoverage } from "./coverage/report_to_coverage.js"
@@ -54,10 +49,11 @@ export const executePlan = async (
     gcBetweenExecutions,
     cooldownBetweenExecutions,
 
-    coverage,
+    coverageEnabled,
     coverageConfig,
     coverageIncludeMissing,
-    coverageForceIstanbul,
+    coverageMethodForBrowsers,
+    coverageMethodForNodeJs,
     coverageV8ConflictWarning,
     coverageTempDirectoryRelativeUrl,
 
@@ -79,9 +75,13 @@ export const executePlan = async (
     afterExecutionCallback = () => {},
   } = {},
 ) => {
+  const executePlanReturnValue = {}
+  const report = {}
+  const callbacks = []
   const stopAfterAllSignal = { notify: () => {} }
 
   let someNeedsServer = false
+  let someNodeRuntime = false
   const runtimes = {}
   Object.keys(plan).forEach((filePattern) => {
     const filePlan = plan[filePattern]
@@ -93,6 +93,9 @@ export const executePlan = async (
         if (runtime.needsServer) {
           someNeedsServer = true
         }
+        if (runtime.type === "node") {
+          someNodeRuntime = true
+        }
       }
     })
   })
@@ -122,10 +125,76 @@ export const executePlan = async (
   }
 
   try {
+    const coverageTempDirectoryUrl = new URL(
+      coverageTempDirectoryRelativeUrl,
+      rootDirectoryUrl,
+    ).href
+    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": `Preprend NODE_V8_COVERAGE=.coverage/node to the command executing this process`,
+              "suggestion 2": `use coverageMethodForNodeJs: "Profiler". But it means coverage for child_process and worker_thread cannot be collected`,
+            },
+          ),
+        )
+      }
+    }
+
+    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,
+            coverageMethodForBrowsers,
+            coverageV8ConflictWarning,
+          })
+          executePlanReturnValue.planCoverage = planCoverage
+        } catch (e) {
+          if (Abort.isAbortError(e)) {
+            return
+          }
+          throw e
+        }
+      })
+    }
+
     let runtimeParams = {
       rootDirectoryUrl,
-      collectCoverage: coverage,
-      coverageForceIstanbul,
+      coverageEnabled,
+      coverageConfig,
+      coverageMethodForBrowsers,
+      coverageMethodForNodeJs,
       stopAfterAllSignal,
     }
     if (someNeedsServer) {
@@ -154,7 +223,7 @@ export const executePlan = async (
               ...transpilation,
               getCustomBabelPlugins: ({ clientRuntimeCompat }) => {
                 if (
-                  coverage &&
+                  coverageEnabled &&
                   Object.keys(clientRuntimeCompat)[0] !== "chrome"
                 ) {
                   return {
@@ -221,76 +290,8 @@ export const executePlan = async (
       process.exitCode !== 1
 
     const startMs = Date.now()
-    const report = {}
     let rawOutput = ""
 
-    let transformReturnValue = (value) => value
-    if (gcBetweenExecutions) {
-      ensureGlobalGc()
-    }
-
-    const coverageTempDirectoryUrl = new URL(
-      coverageTempDirectoryRelativeUrl,
-      rootDirectoryUrl,
-    ).href
-
-    if (coverage) {
-      const associations = URL_META.resolveAssociations(
-        { cover: coverageConfig },
-        rootDirectoryUrl,
-      )
-      const urlShouldBeCovered = (url) => {
-        const { cover } = URL_META.applyAssociations({
-          url: new URL(url, rootDirectoryUrl).href,
-          associations,
-        })
-        return cover
-      }
-      runtimeParams.urlShouldBeCovered = urlShouldBeCovered
-
-      // 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 = new URL(
-            `./node_v8/${cuid()}`,
-            coverageTempDirectoryUrl,
-          ).href
-          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,
-            rootDirectoryUrl,
-            coverageConfig,
-            coverageIncludeMissing,
-            coverageForceIstanbul,
-            urlShouldBeCovered,
-            coverageV8ConflictWarning,
-          })
-        } catch (e) {
-          if (Abort.isAbortError(e)) {
-            return value
-          }
-          throw e
-        }
-        return value
-      }
-    }
-
     logger.info("")
     let executionLog = createLog({ newLine: "" })
     const counters = {
@@ -309,6 +310,7 @@ export const executePlan = async (
       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 = {
@@ -324,6 +326,7 @@ export const executePlan = async (
         }
         const beforeExecutionInfo = {
           fileRelativeUrl,
+          runtimeType,
           runtimeName,
           runtimeVersion,
           executionIndex,
@@ -366,7 +369,7 @@ export const executePlan = async (
             keepRunning,
             mirrorConsole: false, // file are executed in parallel, log would be a mess to read
             collectConsole: executionParams.collectConsole,
-            collectCoverage: coverage,
+            coverageEnabled,
             coverageTempDirectoryUrl,
             runtime: executionParams.runtime,
             runtimeParams: {
@@ -483,16 +486,14 @@ export const executePlan = async (
       writeFileSync(logFileUrl, rawOutput)
       logger.info(`-> ${urlToFileSystemPath(logFileUrl)}`)
     }
-    const result = await transformReturnValue({
-      summary,
-      report,
-    })
-    return {
-      aborted: multipleExecutionsOperation.signal.aborted,
-      planSummary: result.summary,
-      planReport: result.report,
-      planCoverage: result.coverage,
-    }
+    executePlanReturnValue.aborted = multipleExecutionsOperation.signal.aborted
+    executePlanReturnValue.planSummary = summary
+    executePlanReturnValue.planReport = report
+    await callbacks.reduce(async (previous, callback) => {
+      await previous
+      await callback()
+    }, Promise.resolve())
+    return executePlanReturnValue
   } finally {
     await multipleExecutionsOperation.end()
   }

package/src/test/execute_test_plan.js

@@ -28,7 +28,7 @@ import { executePlan } from "./execute_plan.js"
  * @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
+ * @param {boolean} [testPlanParameters.coverageEnabled=false] Controls if coverage is collected during files executions
  * @param {boolean} [testPlanParameters.coverageV8ConflictWarning=true] Warn when coverage from 2 executions cannot be merged
  * @return {Object} An object containing the result of all file executions
  */
@@ -60,23 +60,24 @@ export const executeTestPlan = async ({
   cooldownBetweenExecutions = 0,
   gcBetweenExecutions = logMemoryHeapUsage,
 
-  coverage = process.argv.includes("--cover") ||
+  coverageEnabled = process.argv.includes("--cover") ||
     process.argv.includes("--coverage"),
-  coverageTempDirectoryRelativeUrl = "./.coverage/tmp/",
   coverageConfig = {
     "./src/": true,
   },
   coverageIncludeMissing = true,
   coverageAndExecutionAllowed = false,
-  coverageForceIstanbul = false,
+  coverageMethodForNodeJs = "NODE_V8_COVERAGE", // "Profiler" also accepted
+  coverageMethodForBrowsers = "playwright_api", // "istanbul" also accepted
   coverageV8ConflictWarning = true,
-  coverageReportTextLog = true,
-  coverageReportJsonFile = process.env.CI ? null : "./.coverage/coverage.json",
-  coverageReportHtmlDirectory = process.env.CI ? "./.coverage/" : null,
+  coverageTempDirectoryRelativeUrl = "./.coverage/tmp/",
   // skip empty means empty files won't appear in the coverage reports (json and html)
   coverageReportSkipEmpty = false,
   // skip full means file with 100% coverage won't appear in coverage reports (json and html)
   coverageReportSkipFull = false,
+  coverageReportTextLog = true,
+  coverageReportJsonFile = process.env.CI ? null : "./.coverage/coverage.json",
+  coverageReportHtmlDirectory = process.env.CI ? "./.coverage/" : null,
 
   sourcemaps = "inline",
   plugins = [],
@@ -95,7 +96,7 @@ export const executeTestPlan = async ({
   if (typeof testPlan !== "object") {
     throw new Error(`testPlan must be an object, got ${testPlan}`)
   }
-  if (coverage) {
+  if (coverageEnabled) {
     if (typeof coverageConfig !== "object") {
       throw new TypeError(
         `coverageConfig must be an object, got ${coverageConfig}`,
@@ -156,10 +157,11 @@ export const executeTestPlan = async ({
     cooldownBetweenExecutions,
     gcBetweenExecutions,
 
-    coverage,
+    coverageEnabled,
     coverageConfig,
     coverageIncludeMissing,
-    coverageForceIstanbul,
+    coverageMethodForBrowsers,
+    coverageMethodForNodeJs,
     coverageV8ConflictWarning,
     coverageTempDirectoryRelativeUrl,
 
@@ -189,7 +191,7 @@ export const executeTestPlan = async ({
     // keep this one first because it does ensureEmptyDirectory
     // and in case coverage json file gets written in the same directory
     // it must be done before
-    if (coverage && coverageReportHtmlDirectory) {
+    if (coverageEnabled && coverageReportHtmlDirectory) {
       const coverageHtmlDirectoryUrl = resolveDirectoryUrl(
         coverageReportHtmlDirectory,
         rootDirectoryUrl,
@@ -216,7 +218,7 @@ export const executeTestPlan = async ({
         }),
       )
     }
-    if (coverage && coverageReportJsonFile) {
+    if (coverageEnabled && coverageReportJsonFile) {
       const coverageJsonFileUrl = new URL(
         coverageReportJsonFile,
         rootDirectoryUrl,
@@ -229,7 +231,7 @@ export const executeTestPlan = async ({
         }),
       )
     }
-    if (coverage && coverageReportTextLog) {
+    if (coverageEnabled && coverageReportTextLog) {
       promises.push(
         generateCoverageTextLog(result.planCoverage, {
           coverageReportSkipEmpty,