@jsenv/core 23.3.0 → 23.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "23.3.0",
+  "version": "23.4.0",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {

package/readme.md

@@ -107,7 +107,7 @@ runtime: firefox/73.0b13
 duration: 2.42 seconds
 
 -------------- summary -----------------
-2 execution: all completed
+2 executions: all completed
 total duration: 3.72 seconds
 ----------------------------------------
 ```

package/src/executeTestPlan.js

@@ -14,9 +14,9 @@ import {
 } from "./internal/argUtils.js"
 import { executePlan } from "./internal/executing/executePlan.js"
 import { executionIsPassed } from "./internal/executing/executionIsPassed.js"
-import { generateCoverageJsonFile } from "./internal/executing/coverage/generateCoverageJsonFile.js"
-import { generateCoverageHtmlDirectory } from "./internal/executing/coverage/generateCoverageHtmlDirectory.js"
-import { generateCoverageTextLog } from "./internal/executing/coverage/generateCoverageTextLog.js"
+import { generateCoverageJsonFile } from "./internal/executing/coverage_reporter/coverage_reporter_json_file.js"
+import { generateCoverageHtmlDirectory } from "./internal/executing/coverage_reporter/coverage_reporter_html_directory.js"
+import { generateCoverageTextLog } from "./internal/executing/coverage_reporter/coverage_reporter_text_log.js"
 import { jsenvCoverageConfig } from "./jsenvCoverageConfig.js"
 
 export const executeTestPlan = async ({
@@ -44,18 +44,18 @@ export const executeTestPlan = async ({
 
   coverage = process.argv.includes("--cover") ||
     process.argv.includes("--coverage"),
+  coverageTempDirectoryRelativeUrl = "./coverage/tmp/",
   coverageConfig = jsenvCoverageConfig,
   coverageIncludeMissing = true,
   coverageAndExecutionAllowed = false,
   coverageForceIstanbul = false,
-  coverageV8MergeConflictIsExpected = false,
-
+  coverageV8ConflictWarning = true,
   coverageTextLog = true,
   coverageJsonFile = Boolean(process.env.CI),
   coverageJsonFileLog = true,
   coverageJsonFileRelativeUrl = "./coverage/coverage.json",
   coverageHtmlDirectory = !process.env.CI,
-  coverageHtmlDirectoryRelativeUrl = "./coverage",
+  coverageHtmlDirectoryRelativeUrl = "./coverage/",
   coverageHtmlDirectoryIndexLog = true,
   // skip empty means empty files won't appear in the coverage reports (log and html)
   coverageSkipEmpty = false,
@@ -153,7 +153,8 @@ export const executeTestPlan = async ({
     coverageConfig,
     coverageIncludeMissing,
     coverageForceIstanbul,
-    coverageV8MergeConflictIsExpected,
+    coverageV8ConflictWarning,
+    coverageTempDirectoryRelativeUrl,
 
     jsenvDirectoryClean,
     compileServerProtocol,
@@ -173,7 +174,7 @@ export const executeTestPlan = async ({
   }
 
   const planCoverage = result.planCoverage
-  // planCoverage can be null when execution is abortes
+  // planCoverage can be null when execution is aborted
   if (planCoverage) {
     const promises = []
     // keep this one first because it does ensureEmptyDirectory

package/src/internal/browser-launcher/executeHtmlFile.js

@@ -6,8 +6,8 @@ import {
 } from "@jsenv/filesystem"
 
 import { jsenvCompileProxyHtmlFileInfo } from "@jsenv/core/src/internal/jsenvInternalFiles.js"
-import { v8CoverageFromAllV8Coverages } from "@jsenv/core/src/internal/executing/coverage/v8CoverageFromAllV8Coverages.js"
-import { composeIstanbulCoverages } from "@jsenv/core/src/internal/executing/coverage/composeIstanbulCoverages.js"
+import { filterV8Coverage } from "@jsenv/core/src/internal/executing/coverage_utils/v8_coverage_from_directory.js"
+import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/core/src/internal/executing/coverage_utils/istanbul_coverage_composition.js"
 import { evalSource } from "../runtime/createNodeRuntime/evalSource.js"
 import { escapeRegexpSpecialCharacters } from "../escapeRegexpSpecialCharacters.js"
 
@@ -23,7 +23,7 @@ export const executeHtmlFile = async (
     // measurePerformance,
     collectPerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable,
     transformErrorHook,
@@ -76,7 +76,7 @@ export const executeHtmlFile = async (
         fileRelativeUrl,
         page,
         collectCoverage,
-        coverageConfig,
+        coverageIgnorePredicate,
         transformErrorHook,
       })
     } else {
@@ -149,7 +149,7 @@ const executeSource = async ({
   fileRelativeUrl,
   page,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   transformErrorHook,
 }) => {
   let transformResult = (result) => result
@@ -175,11 +175,12 @@ const executeSource = async ({
           }
         },
       )
-      const allV8Coverages = [{ result: v8CoveragesWithFsUrls }]
-      const coverage = v8CoverageFromAllV8Coverages(allV8Coverages, {
-        coverageRootUrl: projectDirectoryUrl,
-        coverageConfig,
-      })
+      const coverage = filterV8Coverage(
+        { result: v8CoveragesWithFsUrls },
+        {
+          coverageIgnorePredicate,
+        },
+      )
       return {
         ...result,
         coverage,
@@ -297,15 +298,18 @@ const executeCompiledVersion = async ({
 }
 
 const generateCoverageForPage = (fileExecutionResultMap) => {
-  const istanbulCoverages = []
+  let istanbulCoverageComposed = null
   Object.keys(fileExecutionResultMap).forEach((fileRelativeUrl) => {
     const istanbulCoverage = fileExecutionResultMap[fileRelativeUrl].coverage
-    if (istanbulCoverage) {
-      istanbulCoverages.push(istanbulCoverage)
-    }
+    istanbulCoverageComposed = istanbulCoverageComposed
+      ? composeTwoFileByFileIstanbulCoverages(
+          istanbulCoverageComposed,
+          istanbulCoverage,
+        )
+      : istanbulCoverage
   })
-  const istanbulCoverage = composeIstanbulCoverages(istanbulCoverages)
-  return istanbulCoverage
+
+  return istanbulCoverageComposed
 }
 
 const evalException = (

package/src/internal/executing/coverage/babel_plugin_instrument.js

@@ -3,6 +3,7 @@ import {
   normalizeStructuredMetaMap,
   urlToMeta,
 } from "@jsenv/filesystem"
+
 import { require } from "../../require.js"
 
 // https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js

package/src/internal/executing/coverage/reportToCoverage.js

@@ -1,8 +1,16 @@
-import { collectFiles } from "@jsenv/filesystem"
-
-import { relativeUrlToEmptyCoverage } from "./relativeUrlToEmptyCoverage.js"
-import { istanbulCoverageFromCoverages } from "./istanbulCoverageFromCoverages.js"
-import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
+import { readFile } from "@jsenv/filesystem"
+
+import {
+  visitNodeV8Directory,
+  filterV8Coverage,
+} from "../coverage_utils/v8_coverage_from_directory.js"
+import { composeTwoV8Coverages } from "../coverage_utils/v8_coverage_composition.js"
+import { composeTwoFileByFileIstanbulCoverages } from "../coverage_utils/istanbul_coverage_composition.js"
+import { v8CoverageToIstanbul } from "../coverage_utils/v8_coverage_to_istanbul.js"
+import { composeV8AndIstanbul } from "../coverage_utils/v8_and_istanbul.js"
+import { normalizeFileByFileCoveragePaths } from "../coverage_utils/file_by_file_coverage.js"
+import { listRelativeFileUrlToCover } from "../coverage_empty/list_files_not_covered.js"
+import { relativeUrlToEmptyCoverage } from "../coverage_empty/relativeUrlToEmptyCoverage.js"
 
 export const reportToCoverage = async (
   report,
@@ -13,134 +21,153 @@ export const reportToCoverage = async (
     babelPluginMap,
     coverageConfig,
     coverageIncludeMissing,
-    coverageV8MergeConflictIsExpected,
+    coverageIgnorePredicate,
+    coverageForceIstanbul,
+    coverageV8ConflictWarning,
   },
 ) => {
-  // here we should forward multipleExecutionsOperation.signal
-  // to allow aborting this too
-  const istanbulCoverageFromExecution = await executionReportToCoverage(
-    report,
-    {
-      logger,
-      projectDirectoryUrl,
-      coverageV8MergeConflictIsExpected,
-    },
-  )
+  let v8Coverage
+  let fileByFileIstanbulCoverage
 
-  if (!coverageIncludeMissing) {
-    return istanbulCoverageFromExecution
-  }
+  // collect v8 and istanbul coverage from executions
+  await Object.keys(report).reduce(async (previous, file) => {
+    await previous
 
-  const relativeFileUrlToCoverArray = await listRelativeFileUrlToCover({
-    multipleExecutionsOperation,
-    projectDirectoryUrl,
-    coverageConfig,
-  })
+    const executionResultForFile = report[file]
+    await Object.keys(executionResultForFile).reduce(
+      async (previous, executionName) => {
+        await previous
+
+        const executionResultForFileOnRuntime =
+          executionResultForFile[executionName]
+        const { status, coverageFileUrl } = executionResultForFileOnRuntime
+        if (!coverageFileUrl) {
+          // 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.
+
+          // 3. the file we wanted to execute contains syntax-error
+
+          // in any scenario we are fine because
+          // coverDescription will generate empty coverage for files
+          // that were suppose to be coverage but were not.
+          if (status === "completed") {
+            logger.debug(
+              `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
+            )
+          }
+          return
+        }
 
-  const relativeFileUrlMissingCoverageArray =
-    relativeFileUrlToCoverArray.filter((relativeFileUrlToCover) =>
-      Object.keys(istanbulCoverageFromExecution).every((key) => {
-        return key !== `./${relativeFileUrlToCover}`
-      }),
+        const executionCoverage = await readFile(coverageFileUrl, {
+          as: "json",
+        })
+        if (isV8Coverage(executionCoverage)) {
+          v8Coverage = v8Coverage
+            ? composeTwoV8Coverages(v8Coverage, executionCoverage)
+            : executionCoverage
+        } else {
+          fileByFileIstanbulCoverage = fileByFileIstanbulCoverage
+            ? composeTwoFileByFileIstanbulCoverages(
+                fileByFileIstanbulCoverage,
+                executionCoverage,
+              )
+            : executionCoverage
+        }
+      },
+      Promise.resolve(),
     )
-
-  const istanbulCoverageFromMissedFiles = {}
-  // maybe we should prefer reduce over Promise.all here
-  // because it creates a LOT of things to do
-  await Promise.all(
-    relativeFileUrlMissingCoverageArray.map(
-      async (relativeFileUrlMissingCoverage) => {
-        const emptyCoverage = await relativeUrlToEmptyCoverage(
-          relativeFileUrlMissingCoverage,
-          {
-            multipleExecutionsOperation,
-            projectDirectoryUrl,
-            babelPluginMap,
-          },
-        )
-        istanbulCoverageFromMissedFiles[relativeFileUrlMissingCoverage] =
-          emptyCoverage
-        return emptyCoverage
+  }, Promise.resolve())
+
+  if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
+    await visitNodeV8Directory({
+      signal: multipleExecutionsOperation.signal,
+      NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
+      onV8Coverage: (nodeV8Coverage) => {
+        const nodeV8CoverageLight = filterV8Coverage(nodeV8Coverage, {
+          coverageIgnorePredicate,
+        })
+        v8Coverage = v8Coverage
+          ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
+          : nodeV8CoverageLight
       },
-    ),
-  )
-
-  return {
-    ...istanbulCoverageFromExecution, // already normalized
-    ...normalizeIstanbulCoverage(
-      istanbulCoverageFromMissedFiles,
-      projectDirectoryUrl,
-    ),
-  }
-}
-
-const listRelativeFileUrlToCover = async ({
-  multipleExecutionsOperation,
-  projectDirectoryUrl,
-  coverageConfig,
-}) => {
-  const structuredMetaMapForCoverage = {
-    cover: coverageConfig,
+    })
   }
 
-  const matchingFileResultArray = await collectFiles({
-    signal: multipleExecutionsOperation.signal,
-    directoryUrl: projectDirectoryUrl,
-    structuredMetaMap: structuredMetaMapForCoverage,
-    predicate: ({ cover }) => cover,
-  })
-
-  return matchingFileResultArray.map(({ relativeUrl }) => relativeUrl)
-}
+  // try to merge v8 with istanbul, if any
+  let fileByFileCoverage
+  if (v8Coverage) {
+    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage)
 
-const executionReportToCoverage = async (
-  report,
-  { logger, projectDirectoryUrl, coverageV8MergeConflictIsExpected },
-) => {
-  const coverages = []
+    v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
+      v8FileByFileCoverage,
+      projectDirectoryUrl,
+    )
 
-  Object.keys(report).forEach((file) => {
-    const executionResultForFile = report[file]
-    Object.keys(executionResultForFile).forEach((executionName) => {
-      const executionResultForFileOnRuntime =
-        executionResultForFile[executionName]
-
-      const { status, coverage } = executionResultForFileOnRuntime
-      if (!coverage) {
-        // 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.
-
-        // 3. the file we wanted to execute contains syntax-error
-
-        // in any scenario we are fine because
-        // coverDescription will generate empty coverage for files
-        // that were suppose to be coverage but were not.
-
-        if (status === "completed") {
-          logger.warn(
-            `No execution.coverage from execution named "${executionName}" of ${file}`,
-          )
-        }
-        return
-      }
+    if (fileByFileIstanbulCoverage) {
+      fileByFileIstanbulCoverage = normalizeFileByFileCoveragePaths(
+        fileByFileIstanbulCoverage,
+        projectDirectoryUrl,
+      )
+      fileByFileCoverage = composeV8AndIstanbul(
+        v8FileByFileCoverage,
+        fileByFileIstanbulCoverage,
+        { coverageV8ConflictWarning },
+      )
+    } else {
+      fileByFileCoverage = v8FileByFileCoverage
+    }
+  }
+  // get istanbul only
+  else if (fileByFileIstanbulCoverage) {
+    fileByFileCoverage = normalizeFileByFileCoveragePaths(
+      fileByFileIstanbulCoverage,
+      projectDirectoryUrl,
+    )
+  }
+  // no coverage found in execution (or zero file where executed)
+  else {
+    fileByFileCoverage = {}
+  }
 
-      coverages.push(coverage)
+  // now add coverage for file not covered
+  if (coverageIncludeMissing) {
+    const relativeUrlsToCover = await listRelativeFileUrlToCover({
+      multipleExecutionsOperation,
+      projectDirectoryUrl,
+      coverageConfig,
     })
-  })
 
-  const istanbulCoverage = await istanbulCoverageFromCoverages(coverages, {
-    projectDirectoryUrl,
-    coverageV8MergeConflictIsExpected,
-  })
+    const relativeUrlsMissing = relativeUrlsToCover.filter(
+      (relativeUrlToCover) =>
+        Object.keys(fileByFileCoverage).every((key) => {
+          return key !== `./${relativeUrlToCover}`
+        }),
+    )
+
+    await relativeUrlsMissing.reduce(async (previous, relativeUrlMissing) => {
+      const emptyCoverage = await relativeUrlToEmptyCoverage(
+        relativeUrlMissing,
+        {
+          multipleExecutionsOperation,
+          projectDirectoryUrl,
+          babelPluginMap,
+        },
+      )
+      fileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage
+      return emptyCoverage
+    }, Promise.resolve())
+  }
 
-  return istanbulCoverage
+  return fileByFileCoverage
 }
+
+const isV8Coverage = (coverage) => Boolean(coverage.result)

package/src/internal/executing/coverage_empty/list_files_not_covered.js

@@ -0,0 +1,20 @@
+import { collectFiles } from "@jsenv/filesystem"
+
+export const listRelativeFileUrlToCover = async ({
+  multipleExecutionsOperation,
+  projectDirectoryUrl,
+  coverageConfig,
+}) => {
+  const structuredMetaMapForCoverage = {
+    cover: coverageConfig,
+  }
+
+  const matchingFileResultArray = await collectFiles({
+    signal: multipleExecutionsOperation.signal,
+    directoryUrl: projectDirectoryUrl,
+    structuredMetaMap: structuredMetaMapForCoverage,
+    predicate: ({ cover }) => cover,
+  })
+
+  return matchingFileResultArray.map(({ relativeUrl }) => relativeUrl)
+}

package/src/internal/executing/{coverage → coverage_empty}/relativeUrlToEmptyCoverage.js

@@ -4,7 +4,7 @@ import {
   babelPluginsFromBabelPluginMap,
   getMinimalBabelPluginMap,
 } from "@jsenv/core/src/internal/compiling/babel_plugins.js"
-import { babelPluginInstrument } from "./babel_plugin_instrument.js"
+import { babelPluginInstrument } from "../coverage/babel_plugin_instrument.js"
 import { createEmptyCoverage } from "./createEmptyCoverage.js"
 
 export const relativeUrlToEmptyCoverage = async (

package/src/internal/executing/{coverage/generateCoverageHtmlDirectory.js → coverage_reporter/coverage_reporter_html_directory.js}

@@ -1,13 +1,17 @@
-import { readFileSync } from "fs"
+import { readFileSync } from "node:fs"
 import { resolveUrl, urlToFileSystemPath } from "@jsenv/filesystem"
 
 import { require } from "../../require.js"
-
 import { istanbulCoverageMapFromCoverage } from "./istanbulCoverageMapFromCoverage.js"
 
 export const generateCoverageHtmlDirectory = async (
   coverage,
-  { projectDirectoryUrl, coverageHtmlDirectoryRelativeUrl, coverageSkipEmpty, coverageSkipFull },
+  {
+    projectDirectoryUrl,
+    coverageHtmlDirectoryRelativeUrl,
+    coverageSkipEmpty,
+    coverageSkipFull,
+  },
 ) => {
   const libReport = require("istanbul-lib-report")
   const reports = require("istanbul-reports")
@@ -16,7 +20,10 @@ export const generateCoverageHtmlDirectory = async (
     dir: urlToFileSystemPath(projectDirectoryUrl),
     coverageMap: istanbulCoverageMapFromCoverage(coverage),
     sourceFinder: (path) => {
-      return readFileSync(urlToFileSystemPath(resolveUrl(path, projectDirectoryUrl)), "utf8")
+      return readFileSync(
+        urlToFileSystemPath(resolveUrl(path, projectDirectoryUrl)),
+        "utf8",
+      )
     },
   })
 

package/src/internal/executing/{coverage/generateCoverageTextLog.js → coverage_reporter/coverage_reporter_text_log.js}

@@ -1,8 +1,10 @@
 import { require } from "../../require.js"
-
 import { istanbulCoverageMapFromCoverage } from "./istanbulCoverageMapFromCoverage.js"
 
-export const generateCoverageTextLog = (coverage, { coverageSkipEmpty, coverageSkipFull }) => {
+export const generateCoverageTextLog = (
+  coverage,
+  { coverageSkipEmpty, coverageSkipFull },
+) => {
   const libReport = require("istanbul-lib-report")
   const reports = require("istanbul-reports")
 

package/src/internal/executing/{coverage/normalizeIstanbulCoverage.js → coverage_utils/file_by_file_coverage.js}

@@ -5,22 +5,24 @@ import {
   resolveUrl,
 } from "@jsenv/filesystem"
 
-export const normalizeIstanbulCoverage = (istanbulCoverage, projectDirectoryUrl) => {
-  const istanbulCoverageNormalized = {}
+export const normalizeFileByFileCoveragePaths = (
+  fileByFileCoverage,
+  projectDirectoryUrl,
+) => {
+  const fileByFileNormalized = {}
 
-  Object.keys(istanbulCoverage).forEach((key) => {
-    const fileCoverage = istanbulCoverage[key]
+  Object.keys(fileByFileCoverage).forEach((key) => {
+    const fileCoverage = fileByFileCoverage[key]
     const { path } = fileCoverage
     const url = isFileSystemPath(path)
       ? fileSystemPathToUrl(path)
       : resolveUrl(path, projectDirectoryUrl)
     const relativeUrl = urlToRelativeUrl(url, projectDirectoryUrl)
-
-    istanbulCoverageNormalized[`./${relativeUrl}`] = {
+    fileByFileNormalized[`./${relativeUrl}`] = {
       ...fileCoverage,
       path: `./${relativeUrl}`,
     }
   })
 
-  return istanbulCoverageNormalized
+  return fileByFileNormalized
 }

package/src/internal/executing/coverage_utils/istanbul_coverage_composition.js

@@ -0,0 +1,28 @@
+import { require } from "../../require.js"
+
+export 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
+  })
+
+  return fileByFileIstanbulCoverage
+}
+
+const merge = (firstIstanbulCoverage, secondIstanbulCoverage) => {
+  const { createFileCoverage } = require("istanbul-lib-coverage")
+  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage)
+  istanbulFileCoverageObject.merge(secondIstanbulCoverage)
+  const istanbulCoverage = istanbulFileCoverageObject.toJSON()
+  return istanbulCoverage
+}

package/src/internal/executing/coverage_utils/v8_and_istanbul.js

@@ -0,0 +1,38 @@
+import { createDetailedMessage } from "@jsenv/logger"
+
+export const composeV8AndIstanbul = (
+  v8FileByFileCoverage,
+  istanbulFileByFileCoverage,
+  { coverageV8ConflictWarning },
+) => {
+  const fileByFileCoverage = {}
+  const v8Files = Object.keys(v8FileByFileCoverage)
+  const istanbulFiles = Object.keys(istanbulFileByFileCoverage)
+
+  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":
+                "You can disable this warning with coverageV8ConflictWarning: false",
+              "suggestion 2": `You can force usage of istanbul to prevent this conflict with coverageForceIstanbul: true`,
+            },
+          ),
+        )
+      }
+      fileByFileCoverage[key] = v8Coverage
+    } else {
+      fileByFileCoverage[key] = istanbulFileByFileCoverage[key]
+    }
+  })
+
+  return fileByFileCoverage
+}

package/src/internal/executing/coverage_utils/v8_coverage_composition.js

@@ -0,0 +1,23 @@
+import { require } from "@jsenv/core/src/internal/require.js"
+
+export const composeTwoV8Coverages = (firstV8Coverage, secondV8Coverage) => {
+  if (secondV8Coverage.result.length === 0) {
+    return firstV8Coverage
+  }
+
+  const { mergeProcessCovs } = require("@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
+}