@jsenv/core 34.0.3 → 34.1.0

package/dist/jsenv.js

@@ -18947,54 +18947,6 @@ const splitFileExtension$1 = filename => {
   return [filename.slice(0, dotLastIndex), filename.slice(dotLastIndex)];
 };
 
-// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
-
-const babelPluginInstrument = (api, {
-  useInlineSourceMaps = false
-}) => {
-  const {
-    programVisitor
-  } = requireFromJsenv("istanbul-lib-instrument");
-  const {
-    types
-  } = api;
-  return {
-    name: "transform-instrument",
-    visitor: {
-      Program: {
-        enter(path) {
-          const {
-            file
-          } = this;
-          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;
-          }
-          this.__dv__ = programVisitor(types, opts.filenameRelative || opts.filename, {
-            coverageVariable: "__coverage__",
-            inputSourceMap
-          });
-          this.__dv__.enter(path);
-        },
-        exit(path) {
-          if (!this.__dv__) {
-            return;
-          }
-          const object = this.__dv__.exit(path);
-          // object got two properties: fileCoverage and sourceMappingURL
-          this.file.metadata.coverage = object.fileCoverage;
-        }
-      }
-    }
-  };
-};
-
 /*
  * Generated helpers
  * - https://github.com/babel/babel/commits/main/packages/babel-helpers/src/helpers.ts
@@ -19804,21 +19756,6 @@ const jsenvPluginBabel = ({
       isJsModule,
       getImportSpecifier
     });
-    if (context.dev) {
-      const requestHeaders = context.request.headers;
-      if (requestHeaders["x-coverage-instanbul"]) {
-        const coverageConfig = JSON.parse(requestHeaders["x-coverage-instanbul"]);
-        const associations = URL_META.resolveAssociations({
-          cover: coverageConfig
-        }, context.rootDirectoryUrl);
-        if (URL_META.applyAssociations({
-          url: urlInfo.url,
-          associations
-        }).cover) {
-          babelPluginStructure["transform-instrument"] = [babelPluginInstrument];
-        }
-      }
-    }
     if (getCustomBabelPlugins) {
       Object.assign(babelPluginStructure, getCustomBabelPlugins(context));
     }
@@ -23921,6 +23858,54 @@ const listRelativeFileUrlToCover = async ({
   }) => relativeUrl);
 };
 
+// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
+
+const babelPluginInstrument = (api, {
+  useInlineSourceMaps = false
+}) => {
+  const {
+    programVisitor
+  } = requireFromJsenv("istanbul-lib-instrument");
+  const {
+    types
+  } = api;
+  return {
+    name: "transform-instrument",
+    visitor: {
+      Program: {
+        enter(path) {
+          const {
+            file
+          } = this;
+          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;
+          }
+          this.__dv__ = programVisitor(types, opts.filenameRelative || opts.filename, {
+            coverageVariable: "__coverage__",
+            inputSourceMap
+          });
+          this.__dv__.enter(path);
+        },
+        exit(path) {
+          if (!this.__dv__) {
+            return;
+          }
+          const object = this.__dv__.exit(path);
+          // object got two properties: fileCoverage and sourceMappingURL
+          this.file.metadata.coverage = object.fileCoverage;
+        }
+      }
+    }
+  };
+};
+
 const relativeUrlToEmptyCoverage = async (relativeUrl, {
   signal,
   rootDirectoryUrl
@@ -24800,7 +24785,6 @@ const executeSteps = async (executionSteps, {
     process.exitCode !== 1;
     const startMs = Date.now();
     let rawOutput = "";
-    logger.info("");
     let executionLog = createLog({
       newLine: ""
     });
@@ -25109,7 +25093,10 @@ const executeTestPlan = async ({
     "file:///**/.*": false,
     "file:///**/.*/": false,
     "file:///**/node_modules/": false,
-    "./**/src/": true,
+    "./**/src/**/*.js": true,
+    "./**/src/**/*.ts": true,
+    "./**/src/**/*.jsx": true,
+    "./**/src/**/*.tsx": true,
     "./**/tests/": false,
     "./**/*.test.html": false,
     "./**/*.test.js": false,
@@ -25118,8 +25105,15 @@ const executeTestPlan = async ({
   coverageIncludeMissing = true,
   coverageAndExecutionAllowed = false,
   coverageMethodForNodeJs = process.env.NODE_V8_COVERAGE ? "NODE_V8_COVERAGE" : "Profiler",
-  coverageMethodForBrowsers = "playwright_api",
-  // "istanbul" also accepted
+  // - When chromium only -> coverage generated by v8
+  // - When chromium + node -> coverage generated by v8 are merged
+  // - When firefox only -> coverage generated by babel+istanbul
+  // - When chromium + firefox
+  //   -> by default only coverage from chromium is used
+  //   and a warning is logged according to coverageV8ConflictWarning
+  //   -> to collect coverage from both browsers, pass coverageMethodForBrowsers: "istanbul"
+  coverageMethodForBrowsers,
+  // undefined | "playwright" | "istanbul"
   coverageV8ConflictWarning = true,
   coverageTempDirectoryUrl,
   // skip empty means empty files won't appear in the coverage reports (json and html)
@@ -25134,6 +25128,7 @@ const executeTestPlan = async ({
   ...rest
 }) => {
   let someNeedsServer = false;
+  let someHasCoverageV8 = false;
   let someNodeRuntime = false;
   const runtimes = {};
   // param validation
@@ -25160,6 +25155,9 @@ const executeTestPlan = async ({
         if (runtime) {
           runtimes[runtime.name] = runtime.version;
           if (runtime.type === "browser") {
+            if (runtime.capabilities && runtime.capabilities.coverageV8) {
+              someHasCoverageV8 = true;
+            }
             someNeedsServer = true;
           }
           if (runtime.type === "node") {
@@ -25172,6 +25170,9 @@ const executeTestPlan = async ({
       await assertAndNormalizeWebServer(webServer);
     }
     if (coverageEnabled) {
+      if (coverageMethodForBrowsers === undefined) {
+        coverageMethodForBrowsers = someHasCoverageV8 ? "playwright" : "istanbul";
+      }
       if (typeof coverageConfig !== "object") {
         throw new TypeError(`coverageConfig must be an object, got ${coverageConfig}`);
       }
@@ -25332,6 +25333,172 @@ const executeTestPlan = async ({
   };
 };
 
+const initJsSupervisorMiddleware = async (page, {
+  webServer,
+  fileUrl,
+  fileServerUrl
+}) => {
+  const inlineScriptContents = new Map();
+  const interceptHtmlToExecute = async ({
+    route
+  }) => {
+    const response = await route.fetch();
+    const originalBody = await response.text();
+    const injectionResult = await injectSupervisorIntoHTML({
+      content: originalBody,
+      url: fileUrl
+    }, {
+      supervisorScriptSrc: `/@fs/${supervisorFileUrl$1.slice("file:///".length)}`,
+      supervisorOptions: {},
+      inlineAsRemote: true,
+      webServer,
+      onInlineScript: ({
+        src,
+        textContent
+      }) => {
+        const inlineScriptWebUrl = new URL(src, `${webServer.origin}/`).href;
+        inlineScriptContents.set(inlineScriptWebUrl, textContent);
+      }
+    });
+    route.fulfill({
+      response,
+      body: injectionResult.content,
+      headers: {
+        ...response.headers(),
+        "content-length": Buffer.byteLength(injectionResult.content)
+      }
+    });
+  };
+  const interceptInlineScript = ({
+    url,
+    route
+  }) => {
+    const inlineScriptContent = inlineScriptContents.get(url);
+    route.fulfill({
+      status: 200,
+      body: inlineScriptContent,
+      headers: {
+        "content-type": "text/javascript",
+        "content-length": Buffer.byteLength(inlineScriptContent)
+      }
+    });
+  };
+  const interceptFileSystemUrl = ({
+    url,
+    route
+  }) => {
+    const relativeUrl = url.slice(webServer.origin.length);
+    const fsPath = relativeUrl.slice("/@fs/".length);
+    const fsUrl = `file:///${fsPath}`;
+    const fileContent = readFileSync$1(new URL(fsUrl), "utf8");
+    route.fulfill({
+      status: 200,
+      body: fileContent,
+      headers: {
+        "content-type": "text/javascript",
+        "content-length": Buffer.byteLength(fileContent)
+      }
+    });
+  };
+  await page.route("**", async route => {
+    const request = route.request();
+    const url = request.url();
+    if (url === fileServerUrl && urlToExtension$1(url) === ".html") {
+      interceptHtmlToExecute({
+        url,
+        request,
+        route
+      });
+      return;
+    }
+    if (inlineScriptContents.has(url)) {
+      interceptInlineScript({
+        url,
+        request,
+        route
+      });
+      return;
+    }
+    const fsServerUrl = new URL("/@fs/", webServer.origin);
+    if (url.startsWith(fsServerUrl)) {
+      interceptFileSystemUrl({
+        url,
+        request,
+        route
+      });
+      return;
+    }
+    route.fallback();
+  });
+};
+
+const initIstanbulMiddleware = async (page, {
+  webServer,
+  rootDirectoryUrl,
+  coverageConfig
+}) => {
+  const associations = URL_META.resolveAssociations({
+    cover: coverageConfig
+  }, rootDirectoryUrl);
+  await page.route("**", async route => {
+    const request = route.request();
+    const url = request.url(); // transform into a local url
+    const fileUrl = moveUrl({
+      url,
+      from: `${webServer.origin}/`,
+      to: rootDirectoryUrl
+    });
+    const needsInstrumentation = URL_META.applyAssociations({
+      url: fileUrl,
+      associations
+    }).cover;
+    if (!needsInstrumentation) {
+      route.fallback();
+      return;
+    }
+    const response = await route.fetch();
+    const originalBody = await response.text();
+    try {
+      const result = await applyBabelPlugins({
+        babelPlugins: [babelPluginInstrument],
+        urlInfo: {
+          originalUrl: fileUrl,
+          // jsenv server could send info to know it's a js module or js classic
+          // but in the end it's not super important
+          // - it's ok to parse js classic as js module considering it's only for istanbul instrumentation
+          type: "js_module",
+          content: originalBody
+        }
+      });
+      let code = result.code;
+      code = SOURCEMAP.writeComment({
+        contentType: "text/javascript",
+        content: code,
+        specifier: generateSourcemapDataUrl(result.map)
+      });
+      route.fulfill({
+        response,
+        body: code,
+        headers: {
+          ...response.headers(),
+          "content-length": Buffer.byteLength(code)
+        }
+      });
+    } catch (e) {
+      if (e.code === "PARSE_ERROR") {
+        route.fulfill({
+          response
+        });
+      } else {
+        console.error(e);
+        route.fulfill({
+          response
+        });
+      }
+    }
+  });
+};
+
 const createRuntimeFromPlaywright = ({
   browserName,
   browserVersion,
@@ -25343,7 +25510,10 @@ const createRuntimeFromPlaywright = ({
   const runtime = {
     type: "browser",
     name: browserName,
-    version: browserVersion
+    version: browserVersion,
+    capabilities: {
+      coverageV8: coveragePlaywrightAPIAvailable
+    }
   };
   let browserAndContextPromise;
   runtime.run = async ({
@@ -25434,16 +25604,17 @@ ${webServer.rootDirectoryUrl}`);
       }
       await disconnected;
     };
-    const coverageInHeaders = coverageEnabled && (!coveragePlaywrightAPIAvailable || coverageMethodForBrowsers !== "playwright_api");
-    const page = await browserContext.newPage({
-      extraHTTPHeaders: {
-        ...(coverageInHeaders ? {
-          "x-coverage-istanbul": JSON.stringify(coverageConfig)
-        } : {})
-      }
-    });
+    const page = await browserContext.newPage();
+    const istanbulInstrumentationEnabled = coverageEnabled && (!runtime.capabilities.coverageV8 || coverageMethodForBrowsers === "istanbul");
+    if (istanbulInstrumentationEnabled) {
+      await initIstanbulMiddleware(page, {
+        webServer,
+        rootDirectoryUrl,
+        coverageConfig
+      });
+    }
     if (!webServer.isJsenvDevServer) {
-      await initJsExecutionMiddleware(page, {
+      await initJsSupervisorMiddleware(page, {
         webServer,
         fileUrl,
         fileServerUrl
@@ -25466,7 +25637,7 @@ ${webServer.rootDirectoryUrl}`);
     };
     const callbacks = [];
     if (coverageEnabled) {
-      if (coveragePlaywrightAPIAvailable && coverageMethodForBrowsers === "playwright_api") {
+      if (runtime.capabilities.coverageV8 && coverageMethodForBrowsers === "playwright") {
         await page.coverage.startJSCoverage({
           // reportAnonymousScripts: true,
         });
@@ -25848,106 +26019,6 @@ const extractTextFromConsoleMessage = consoleMessage => {
   //   return text
 };
 
-const initJsExecutionMiddleware = async (page, {
-  webServer,
-  fileUrl,
-  fileServerUrl
-}) => {
-  const inlineScriptContents = new Map();
-  const interceptHtmlToExecute = async ({
-    route
-  }) => {
-    // Fetch original response.
-    const response = await route.fetch();
-    // Add a prefix to the title.
-    const originalBody = await response.text();
-    const injectionResult = await injectSupervisorIntoHTML({
-      content: originalBody,
-      url: fileUrl
-    }, {
-      supervisorScriptSrc: `/@fs/${supervisorFileUrl$1.slice("file:///".length)}`,
-      supervisorOptions: {},
-      inlineAsRemote: true,
-      webServer,
-      onInlineScript: ({
-        src,
-        textContent
-      }) => {
-        const inlineScriptWebUrl = new URL(src, `${webServer.origin}/`).href;
-        inlineScriptContents.set(inlineScriptWebUrl, textContent);
-      }
-    });
-    route.fulfill({
-      response,
-      body: injectionResult.content,
-      headers: {
-        ...response.headers(),
-        "content-length": Buffer.byteLength(injectionResult.content)
-      }
-    });
-  };
-  const interceptInlineScript = ({
-    url,
-    route
-  }) => {
-    const inlineScriptContent = inlineScriptContents.get(url);
-    route.fulfill({
-      status: 200,
-      body: inlineScriptContent,
-      headers: {
-        "content-type": "text/javascript",
-        "content-length": Buffer.byteLength(inlineScriptContent)
-      }
-    });
-  };
-  const interceptFileSystemUrl = ({
-    url,
-    route
-  }) => {
-    const relativeUrl = url.slice(webServer.origin.length);
-    const fsPath = relativeUrl.slice("/@fs/".length);
-    const fsUrl = `file:///${fsPath}`;
-    const fileContent = readFileSync$1(new URL(fsUrl), "utf8");
-    route.fulfill({
-      status: 200,
-      body: fileContent,
-      headers: {
-        "content-type": "text/javascript",
-        "content-length": Buffer.byteLength(fileContent)
-      }
-    });
-  };
-  await page.route("**", async route => {
-    const request = route.request();
-    const url = request.url();
-    if (url === fileServerUrl && urlToExtension$1(url) === ".html") {
-      interceptHtmlToExecute({
-        url,
-        request,
-        route
-      });
-      return;
-    }
-    if (inlineScriptContents.has(url)) {
-      interceptInlineScript({
-        url,
-        request,
-        route
-      });
-      return;
-    }
-    const fsServerUrl = new URL("/@fs/", webServer.origin);
-    if (url.startsWith(fsServerUrl)) {
-      interceptFileSystemUrl({
-        url,
-        request,
-        route
-      });
-      return;
-    }
-    route.fallback();
-  });
-};
 const registerEvent = ({
   object,
   eventType,

package/package.json

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

package/src/execute/runtimes/browsers/from_playwright.js

@@ -1,5 +1,4 @@
-import { readFileSync, writeFileSync } from "node:fs"
-
+import { writeFileSync } from "node:fs"
 import { createDetailedMessage } from "@jsenv/log"
 import {
   Abort,
@@ -7,15 +6,13 @@ import {
   raceProcessTeardownEvents,
   raceCallbacks,
 } from "@jsenv/abort"
-import { moveUrl, urlIsInsideOf, urlToExtension } from "@jsenv/urls"
+import { moveUrl, urlIsInsideOf } from "@jsenv/urls"
 import { memoize } from "@jsenv/utils/src/memoize/memoize.js"
 
+import { initJsSupervisorMiddleware } from "./middleware_js_supervisor.js"
+import { initIstanbulMiddleware } from "./middleware_istanbul.js"
 import { filterV8Coverage } from "@jsenv/core/src/test/coverage/v8_coverage.js"
 import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/core/src/test/coverage/istanbul_coverage_composition.js"
-import {
-  injectSupervisorIntoHTML,
-  supervisorFileUrl,
-} from "../../../plugins/supervisor/html_supervisor_injection.js"
 
 export const createRuntimeFromPlaywright = ({
   browserName,
@@ -29,6 +26,9 @@ export const createRuntimeFromPlaywright = ({
     type: "browser",
     name: browserName,
     version: browserVersion,
+    capabilities: {
+      coverageV8: coveragePlaywrightAPIAvailable,
+    },
   }
   let browserAndContextPromise
   runtime.run = async ({
@@ -116,21 +116,22 @@ ${webServer.rootDirectoryUrl}`)
       }
       await disconnected
     }
-    const coverageInHeaders =
+
+    const page = await browserContext.newPage()
+
+    const istanbulInstrumentationEnabled =
       coverageEnabled &&
-      (!coveragePlaywrightAPIAvailable ||
-        coverageMethodForBrowsers !== "playwright_api")
-    const page = await browserContext.newPage({
-      extraHTTPHeaders: {
-        ...(coverageInHeaders
-          ? {
-              "x-coverage-istanbul": JSON.stringify(coverageConfig),
-            }
-          : {}),
-      },
-    })
+      (!runtime.capabilities.coverageV8 ||
+        coverageMethodForBrowsers === "istanbul")
+    if (istanbulInstrumentationEnabled) {
+      await initIstanbulMiddleware(page, {
+        webServer,
+        rootDirectoryUrl,
+        coverageConfig,
+      })
+    }
     if (!webServer.isJsenvDevServer) {
-      await initJsExecutionMiddleware(page, {
+      await initJsSupervisorMiddleware(page, {
         webServer,
         fileUrl,
         fileServerUrl,
@@ -155,8 +156,8 @@ ${webServer.rootDirectoryUrl}`)
     const callbacks = []
     if (coverageEnabled) {
       if (
-        coveragePlaywrightAPIAvailable &&
-        coverageMethodForBrowsers === "playwright_api"
+        runtime.capabilities.coverageV8 &&
+        coverageMethodForBrowsers === "playwright"
       ) {
         await page.coverage.startJSCoverage({
           // reportAnonymousScripts: true,
@@ -570,100 +571,6 @@ const extractTextFromConsoleMessage = (consoleMessage) => {
   //   return text
 }
 
-const initJsExecutionMiddleware = async (
-  page,
-  { webServer, fileUrl, fileServerUrl },
-) => {
-  const inlineScriptContents = new Map()
-
-  const interceptHtmlToExecute = async ({ route }) => {
-    // Fetch original response.
-    const response = await route.fetch()
-    // Add a prefix to the title.
-    const originalBody = await response.text()
-    const injectionResult = await injectSupervisorIntoHTML(
-      {
-        content: originalBody,
-        url: fileUrl,
-      },
-      {
-        supervisorScriptSrc: `/@fs/${supervisorFileUrl.slice(
-          "file:///".length,
-        )}`,
-        supervisorOptions: {},
-        inlineAsRemote: true,
-        webServer,
-        onInlineScript: ({ src, textContent }) => {
-          const inlineScriptWebUrl = new URL(src, `${webServer.origin}/`).href
-          inlineScriptContents.set(inlineScriptWebUrl, textContent)
-        },
-      },
-    )
-    route.fulfill({
-      response,
-      body: injectionResult.content,
-      headers: {
-        ...response.headers(),
-        "content-length": Buffer.byteLength(injectionResult.content),
-      },
-    })
-  }
-
-  const interceptInlineScript = ({ url, route }) => {
-    const inlineScriptContent = inlineScriptContents.get(url)
-    route.fulfill({
-      status: 200,
-      body: inlineScriptContent,
-      headers: {
-        "content-type": "text/javascript",
-        "content-length": Buffer.byteLength(inlineScriptContent),
-      },
-    })
-  }
-
-  const interceptFileSystemUrl = ({ url, route }) => {
-    const relativeUrl = url.slice(webServer.origin.length)
-    const fsPath = relativeUrl.slice("/@fs/".length)
-    const fsUrl = `file:///${fsPath}`
-    const fileContent = readFileSync(new URL(fsUrl), "utf8")
-    route.fulfill({
-      status: 200,
-      body: fileContent,
-      headers: {
-        "content-type": "text/javascript",
-        "content-length": Buffer.byteLength(fileContent),
-      },
-    })
-  }
-
-  await page.route("**", async (route) => {
-    const request = route.request()
-    const url = request.url()
-    if (url === fileServerUrl && urlToExtension(url) === ".html") {
-      interceptHtmlToExecute({
-        url,
-        request,
-        route,
-      })
-      return
-    }
-    if (inlineScriptContents.has(url)) {
-      interceptInlineScript({
-        url,
-        request,
-        route,
-      })
-      return
-    }
-    const fsServerUrl = new URL("/@fs/", webServer.origin)
-    if (url.startsWith(fsServerUrl)) {
-      interceptFileSystemUrl({ url, request, route })
-      return
-    }
-    route.fallback()
-  })
-}
-
 const registerEvent = ({ object, eventType, callback }) => {
   object.on(eventType, callback)
   return () => {

package/src/execute/runtimes/browsers/middleware_istanbul.js

@@ -0,0 +1,69 @@
+import { URL_META } from "@jsenv/url-meta"
+import { moveUrl } from "@jsenv/urls"
+import { applyBabelPlugins } from "@jsenv/ast"
+import { SOURCEMAP, generateSourcemapDataUrl } from "@jsenv/sourcemap"
+
+import { babelPluginInstrument } from "../../../test/coverage/babel_plugin_instrument.js"
+
+export const initIstanbulMiddleware = async (
+  page,
+  { webServer, rootDirectoryUrl, coverageConfig },
+) => {
+  const associations = URL_META.resolveAssociations(
+    { cover: coverageConfig },
+    rootDirectoryUrl,
+  )
+  await page.route("**", async (route) => {
+    const request = route.request()
+    const url = request.url() // transform into a local url
+    const fileUrl = moveUrl({
+      url,
+      from: `${webServer.origin}/`,
+      to: rootDirectoryUrl,
+    })
+    const needsInstrumentation = URL_META.applyAssociations({
+      url: fileUrl,
+      associations,
+    }).cover
+    if (!needsInstrumentation) {
+      route.fallback()
+      return
+    }
+    const response = await route.fetch()
+    const originalBody = await response.text()
+    try {
+      const result = await applyBabelPlugins({
+        babelPlugins: [babelPluginInstrument],
+        urlInfo: {
+          originalUrl: fileUrl,
+          // jsenv server could send info to know it's a js module or js classic
+          // but in the end it's not super important
+          // - it's ok to parse js classic as js module considering it's only for istanbul instrumentation
+          type: "js_module",
+          content: originalBody,
+        },
+      })
+      let code = result.code
+      code = SOURCEMAP.writeComment({
+        contentType: "text/javascript",
+        content: code,
+        specifier: generateSourcemapDataUrl(result.map),
+      })
+      route.fulfill({
+        response,
+        body: code,
+        headers: {
+          ...response.headers(),
+          "content-length": Buffer.byteLength(code),
+        },
+      })
+    } catch (e) {
+      if (e.code === "PARSE_ERROR") {
+        route.fulfill({ response })
+      } else {
+        console.error(e)
+        route.fulfill({ response })
+      }
+    }
+  })
+}

package/src/execute/runtimes/browsers/middleware_js_supervisor.js

@@ -0,0 +1,100 @@
+import { readFileSync } from "node:fs"
+
+import { urlToExtension } from "@jsenv/urls"
+
+import {
+  injectSupervisorIntoHTML,
+  supervisorFileUrl,
+} from "../../../plugins/supervisor/html_supervisor_injection.js"
+
+export const initJsSupervisorMiddleware = async (
+  page,
+  { webServer, fileUrl, fileServerUrl },
+) => {
+  const inlineScriptContents = new Map()
+
+  const interceptHtmlToExecute = async ({ route }) => {
+    const response = await route.fetch()
+    const originalBody = await response.text()
+    const injectionResult = await injectSupervisorIntoHTML(
+      {
+        content: originalBody,
+        url: fileUrl,
+      },
+      {
+        supervisorScriptSrc: `/@fs/${supervisorFileUrl.slice(
+          "file:///".length,
+        )}`,
+        supervisorOptions: {},
+        inlineAsRemote: true,
+        webServer,
+        onInlineScript: ({ src, textContent }) => {
+          const inlineScriptWebUrl = new URL(src, `${webServer.origin}/`).href
+          inlineScriptContents.set(inlineScriptWebUrl, textContent)
+        },
+      },
+    )
+    route.fulfill({
+      response,
+      body: injectionResult.content,
+      headers: {
+        ...response.headers(),
+        "content-length": Buffer.byteLength(injectionResult.content),
+      },
+    })
+  }
+
+  const interceptInlineScript = ({ url, route }) => {
+    const inlineScriptContent = inlineScriptContents.get(url)
+    route.fulfill({
+      status: 200,
+      body: inlineScriptContent,
+      headers: {
+        "content-type": "text/javascript",
+        "content-length": Buffer.byteLength(inlineScriptContent),
+      },
+    })
+  }
+
+  const interceptFileSystemUrl = ({ url, route }) => {
+    const relativeUrl = url.slice(webServer.origin.length)
+    const fsPath = relativeUrl.slice("/@fs/".length)
+    const fsUrl = `file:///${fsPath}`
+    const fileContent = readFileSync(new URL(fsUrl), "utf8")
+    route.fulfill({
+      status: 200,
+      body: fileContent,
+      headers: {
+        "content-type": "text/javascript",
+        "content-length": Buffer.byteLength(fileContent),
+      },
+    })
+  }
+
+  await page.route("**", async (route) => {
+    const request = route.request()
+    const url = request.url()
+    if (url === fileServerUrl && urlToExtension(url) === ".html") {
+      interceptHtmlToExecute({
+        url,
+        request,
+        route,
+      })
+      return
+    }
+    if (inlineScriptContents.has(url)) {
+      interceptInlineScript({
+        url,
+        request,
+        route,
+      })
+      return
+    }
+    const fsServerUrl = new URL("/@fs/", webServer.origin)
+    if (url.startsWith(fsServerUrl)) {
+      interceptFileSystemUrl({ url, request, route })
+      return
+    }
+    route.fallback()
+  })
+}

package/src/plugins/transpilation/babel/jsenv_plugin_babel.js

@@ -1,7 +1,5 @@
 import { applyBabelPlugins } from "@jsenv/ast"
-import { URL_META } from "@jsenv/url-meta"
 
-import { babelPluginInstrument } from "@jsenv/core/src/test/coverage/babel_plugin_instrument.js"
 import { RUNTIME_COMPAT } from "@jsenv/core/src/kitchen/compat/runtime_compat.js"
 import { getBaseBabelPluginStructure } from "./helpers/babel_plugin_structure.js"
 import { babelPluginBabelHelpersAsJsenvImports } from "./helpers/babel_plugin_babel_helpers_as_jsenv_imports.js"
@@ -33,23 +31,6 @@ export const jsenvPluginBabel = ({
       isJsModule,
       getImportSpecifier,
     })
-    if (context.dev) {
-      const requestHeaders = context.request.headers
-      if (requestHeaders["x-coverage-instanbul"]) {
-        const coverageConfig = JSON.parse(
-          requestHeaders["x-coverage-instanbul"],
-        )
-        const associations = URL_META.resolveAssociations(
-          { cover: coverageConfig },
-          context.rootDirectoryUrl,
-        )
-        if (
-          URL_META.applyAssociations({ url: urlInfo.url, associations }).cover
-        ) {
-          babelPluginStructure["transform-instrument"] = [babelPluginInstrument]
-        }
-      }
-    }
     if (getCustomBabelPlugins) {
       Object.assign(babelPluginStructure, getCustomBabelPlugins(context))
     }

package/src/test/execute_steps.js

@@ -146,8 +146,6 @@ export const executeSteps = async (
 
     const startMs = Date.now()
     let rawOutput = ""
-
-    logger.info("")
     let executionLog = createLog({ newLine: "" })
     const counters = {
       total: executionSteps.length,

package/src/test/execute_test_plan.js

@@ -67,7 +67,10 @@ export const executeTestPlan = async ({
     "file:///**/.*": false,
     "file:///**/.*/": false,
     "file:///**/node_modules/": false,
-    "./**/src/": true,
+    "./**/src/**/*.js": true,
+    "./**/src/**/*.ts": true,
+    "./**/src/**/*.jsx": true,
+    "./**/src/**/*.tsx": true,
     "./**/tests/": false,
     "./**/*.test.html": false,
     "./**/*.test.js": false,
@@ -78,7 +81,14 @@ export const executeTestPlan = async ({
   coverageMethodForNodeJs = process.env.NODE_V8_COVERAGE
     ? "NODE_V8_COVERAGE"
     : "Profiler",
-  coverageMethodForBrowsers = "playwright_api", // "istanbul" also accepted
+  // - When chromium only -> coverage generated by v8
+  // - When chromium + node -> coverage generated by v8 are merged
+  // - When firefox only -> coverage generated by babel+istanbul
+  // - When chromium + firefox
+  //   -> by default only coverage from chromium is used
+  //   and a warning is logged according to coverageV8ConflictWarning
+  //   -> to collect coverage from both browsers, pass coverageMethodForBrowsers: "istanbul"
+  coverageMethodForBrowsers, // undefined | "playwright" | "istanbul"
   coverageV8ConflictWarning = true,
   coverageTempDirectoryUrl,
   // skip empty means empty files won't appear in the coverage reports (json and html)
@@ -93,6 +103,7 @@ export const executeTestPlan = async ({
   ...rest
 }) => {
   let someNeedsServer = false
+  let someHasCoverageV8 = false
   let someNodeRuntime = false
   const runtimes = {}
   // param validation
@@ -123,6 +134,9 @@ export const executeTestPlan = async ({
         if (runtime) {
           runtimes[runtime.name] = runtime.version
           if (runtime.type === "browser") {
+            if (runtime.capabilities && runtime.capabilities.coverageV8) {
+              someHasCoverageV8 = true
+            }
             someNeedsServer = true
           }
           if (runtime.type === "node") {
@@ -137,6 +151,11 @@ export const executeTestPlan = async ({
     }
 
     if (coverageEnabled) {
+      if (coverageMethodForBrowsers === undefined) {
+        coverageMethodForBrowsers = someHasCoverageV8
+          ? "playwright"
+          : "istanbul"
+      }
       if (typeof coverageConfig !== "object") {
         throw new TypeError(
           `coverageConfig must be an object, got ${coverageConfig}`,