@jsenv/core 27.3.2 → 27.4.0

package/dist/main.js

@@ -5928,19 +5928,6 @@ const generateInlineContentUrl = ({
   return inlineContentUrl;
 };
 
-const urlToFileSystemPath = url => {
-  let urlString = String(url);
-
-  if (urlString[urlString.length - 1] === "/") {
-    // remove trailing / so that nodejs path becomes predictable otherwise it logs
-    // the trailing slash on linux but does not on windows
-    urlString = urlString.slice(0, -1);
-  }
-
-  const fileSystemPath = fileURLToPath(urlString);
-  return fileSystemPath;
-};
-
 // consider switching to https://babeljs.io/docs/en/babel-code-frame
 const stringifyUrlSite = ({
   url,
@@ -5953,7 +5940,7 @@ const stringifyUrlSite = ({
   lineMaxLength,
   color
 } = {}) => {
-  let string = `${humanizeUrl(url)}`;
+  let string = url;
 
   if (typeof line === "number") {
     string += `:${line}`;
@@ -5978,15 +5965,6 @@ const stringifyUrlSite = ({
   return `${string}
 ${sourceLoc}`;
 };
-const humanizeUrl = url => {
-  if (url.startsWith("file://")) {
-    // we prefer file system path because vscode reliably make them clickable
-    // and sometimes it won't for file:// urls
-    return urlToFileSystemPath(url);
-  }
-
-  return url;
-};
 const showSourceLocation = ({
   content,
   line,
@@ -6489,6 +6467,19 @@ const urlToBasename = url => {
   return basename;
 };
 
+const urlToFileSystemPath = url => {
+  let urlString = String(url);
+
+  if (urlString[urlString.length - 1] === "/") {
+    // remove trailing / so that nodejs path becomes predictable otherwise it logs
+    // the trailing slash on linux but does not on windows
+    urlString = urlString.slice(0, -1);
+  }
+
+  const fileSystemPath = fileURLToPath(urlString);
+  return fileSystemPath;
+};
+
 const assertAndNormalizeDirectoryUrl = value => {
   let urlString;
 
@@ -8470,22 +8461,11 @@ const parseAndTransformJsUrls = async (urlInfo, context) => {
   } = context;
   const actions = [];
   const magicSource = createMagicSource(urlInfo.content);
-  urlInfo.data.usesImport = false;
-  urlInfo.data.usesExport = false;
-  urlInfo.data.usesImportAssertion = false;
   jsMentions.forEach(jsMention => {
-    if (jsMention.assert) {
-      urlInfo.data.usesImportAssertion = true;
-    }
-
     if (jsMention.subtype === "import_static" || jsMention.subtype === "import_dynamic") {
       urlInfo.data.usesImport = true;
     }
 
-    if (jsMention.subtype === "export") {
-      urlInfo.data.usesExport = true;
-    }
-
     const [reference] = referenceUtils.found({
       type: jsMention.type,
       subtype: jsMention.subtype,
@@ -8633,7 +8613,9 @@ const jsenvPluginUrlAnalysis = ({
             type: "filesystem",
             subtype: "directory_entry",
             specifier: directoryEntryName,
-            trace: `"${directoryRelativeUrl}${directoryEntryName}" entry in directory referenced by ${originalDirectoryReference.trace}`
+            trace: {
+              message: `"${directoryRelativeUrl}${directoryEntryName}" entry in directory referenced by ${originalDirectoryReference.trace.message}`
+            }
           });
         });
       }
@@ -10927,9 +10909,7 @@ const jsenvPluginNodeEsmResolution = ({
   const onFileChange = () => {
     packageScopesCache.clear();
     packageJsonsCache.clear();
-    Object.keys(urlGraph.urlInfos).forEach(url => {
-      const urlInfo = urlGraph.getUrlInfo(url);
-
+    urlGraph.urlInfoMap.forEach(urlInfo => {
       if (urlInfo.dependsOnPackageJson) {
         urlGraph.considerModified(urlInfo);
       }
@@ -12050,6 +12030,8 @@ const jsenvPluginInlineUrls = () => {
   };
 };
 
+const requireFromJsenv = createRequire(import.meta.url);
+
 /*
  * Things happening here
  * - html supervisor module injection
@@ -12067,13 +12049,32 @@ const jsenvPluginHtmlSupervisor = ({
       dev: true,
       test: true
     },
+    serve: request => {
+      if (!request.ressource.startsWith("/__open_in_editor__/")) {
+        return null;
+      }
+
+      const file = request.ressource.slice("/__open_in_editor__/".length);
+
+      if (!file) {
+        return {
+          status: 400,
+          body: 'Missing "file" in url search params'
+        };
+      }
+
+      const launch = requireFromJsenv("launch-editor");
+      launch(fileURLToPath(file), () => {// ignore error for now
+      });
+      return {
+        status: 200
+      };
+    },
     transformUrlContent: {
       html: ({
         url,
         content
-      }, {
-        referenceUtils
-      }) => {
+      }, context) => {
         const htmlAst = parseHtmlString(content);
         const scriptsToSupervise = [];
 
@@ -12096,7 +12097,7 @@ const jsenvPluginHtmlSupervisor = ({
             lineEnd,
             columnEnd
           });
-          const [inlineScriptReference] = referenceUtils.foundInline({
+          const [inlineScriptReference] = context.referenceUtils.foundInline({
             type: "script_src",
             expectedType: {
               classic: "js_classic",
@@ -12173,7 +12174,7 @@ const jsenvPluginHtmlSupervisor = ({
             }
           }
         });
-        const [htmlSupervisorInstallerFileReference] = referenceUtils.inject({
+        const [htmlSupervisorInstallerFileReference] = context.referenceUtils.inject({
           type: "js_import_export",
           expectedType: "js_module",
           specifier: htmlSupervisorInstallerFileUrl
@@ -12185,11 +12186,12 @@ const jsenvPluginHtmlSupervisor = ({
       import { installHtmlSupervisor } from ${htmlSupervisorInstallerFileReference.generatedSpecifier}
       installHtmlSupervisor(${JSON.stringify({
             logs,
-            measurePerf
+            measurePerf,
+            rootDirectoryUrl: context.rootDirectoryUrl
           }, null, "        ")})`,
           "injected-by": "jsenv:html_supervisor"
         }));
-        const [htmlSupervisorSetupFileReference] = referenceUtils.inject({
+        const [htmlSupervisorSetupFileReference] = context.referenceUtils.inject({
           type: "script_src",
           expectedType: "js_classic",
           specifier: htmlSupervisorSetupFileUrl
@@ -12776,8 +12778,6 @@ export default inlineContent.text`,
   return [asJsonModule, asCssModule, asTextModule];
 };
 
-const requireFromJsenv = createRequire(import.meta.url);
-
 const babelPluginPackagePath = requireFromJsenv.resolve("@jsenv/babel-plugins");
 const babelPluginPackageUrl = pathToFileURL(babelPluginPackagePath);
 const requireBabelPlugin = createRequire(babelPluginPackageUrl);
@@ -19338,8 +19338,7 @@ const rollupPluginJsenv = ({
             data: {
               generatedBy: "rollup",
               bundleRelativeUrl: rollupFileInfo.fileName,
-              usesImport: rollupFileInfo.imports.length > 0 || rollupFileInfo.dynamicImports.length > 0,
-              usesExport: rollupFileInfo.exports.length > 0
+              usesImport: rollupFileInfo.imports.length > 0 || rollupFileInfo.dynamicImports.length > 0
             },
             contentType: "text/javascript",
             content: rollupFileInfo.code,
@@ -20240,269 +20239,216 @@ const jsenvPluginDevSSEClient = () => {
   };
 };
 
-const createSSEService = ({
-  serverEventCallbackList
-}) => {
-  const destroyCallbackList = createCallbackListNotifiedOnce();
-  const cache = [];
-  const sseRoomLimit = 100;
-
-  const getOrCreateSSERoom = request => {
-    const htmlFileRelativeUrl = request.ressource.slice(1);
-    const cacheEntry = cache.find(cacheEntryCandidate => cacheEntryCandidate.htmlFileRelativeUrl === htmlFileRelativeUrl);
-
-    if (cacheEntry) {
-      return cacheEntry.sseRoom;
-    }
-
-    const sseRoom = createSSERoom({
-      retryDuration: 2000,
-      historyLength: 100,
-      welcomeEventEnabled: true,
-      effect: () => {
-        return serverEventCallbackList.add(event => {
-          sseRoom.sendEvent(event);
-        });
-      }
-    });
-    const removeSSECleanupCallback = destroyCallbackList.add(() => {
-      removeSSECleanupCallback();
-      sseRoom.close();
-    });
-    cache.push({
-      htmlFileRelativeUrl,
-      sseRoom,
-      cleanup: () => {
-        removeSSECleanupCallback();
-        sseRoom.close();
-      }
-    });
-
-    if (cache.length >= sseRoomLimit) {
-      const firstCacheEntry = cache.shift();
-      firstCacheEntry.cleanup();
-    }
-
-    return sseRoom;
-  };
-
-  return {
-    getOrCreateSSERoom,
-    destroy: () => {
-      destroyCallbackList.notify();
-    }
-  };
-};
-
 const jsenvPluginDevSSEServer = ({
-  rootDirectoryUrl,
-  urlGraph,
   clientFileChangeCallbackList,
   clientFilesPruneCallbackList
 }) => {
-  const serverEventCallbackList = createCallbackList();
-  const sseService = createSSEService({
-    serverEventCallbackList
-  });
-
-  const notifyDeclined = ({
-    cause,
-    reason,
-    declinedBy
-  }) => {
-    serverEventCallbackList.notify({
-      type: "reload",
-      data: JSON.stringify({
+  return {
+    name: "jsenv:sse_server",
+    appliesDuring: {
+      dev: true
+    },
+    registerServerEvents: ({
+      sendServerEvent
+    }, {
+      rootDirectoryUrl,
+      urlGraph
+    }) => {
+      const notifyDeclined = ({
         cause,
-        type: "full",
-        typeReason: reason,
+        reason,
         declinedBy
-      })
-    });
-  };
+      }) => {
+        sendServerEvent({
+          type: "reload",
+          data: {
+            cause,
+            type: "full",
+            typeReason: reason,
+            declinedBy
+          }
+        });
+      };
 
-  const notifyAccepted = ({
-    cause,
-    reason,
-    instructions
-  }) => {
-    serverEventCallbackList.notify({
-      type: "reload",
-      data: JSON.stringify({
+      const notifyAccepted = ({
         cause,
-        type: "hot",
-        typeReason: reason,
-        hotInstructions: instructions
-      })
-    });
-  };
-
-  const propagateUpdate = firstUrlInfo => {
-    const urlInfos = urlGraph.urlInfos;
+        reason,
+        instructions
+      }) => {
+        sendServerEvent({
+          type: "reload",
+          data: {
+            cause,
+            type: "hot",
+            typeReason: reason,
+            hotInstructions: instructions
+          }
+        });
+      };
 
-    const iterate = (urlInfo, trace) => {
-      if (urlInfo.data.hotAcceptSelf) {
-        return {
-          accepted: true,
-          reason: urlInfo === firstUrlInfo ? `file accepts hot reload` : `a dependent file accepts hot reload`,
-          instructions: [{
-            type: urlInfo.type,
-            boundary: urlToRelativeUrl(urlInfo.url, rootDirectoryUrl),
-            acceptedBy: urlToRelativeUrl(urlInfo.url, rootDirectoryUrl)
-          }]
-        };
-      }
+      const propagateUpdate = firstUrlInfo => {
+        const iterate = (urlInfo, seen) => {
+          if (urlInfo.data.hotAcceptSelf) {
+            return {
+              accepted: true,
+              reason: urlInfo === firstUrlInfo ? `file accepts hot reload` : `a dependent file accepts hot reload`,
+              instructions: [{
+                type: urlInfo.type,
+                boundary: urlToRelativeUrl(urlInfo.url, rootDirectoryUrl),
+                acceptedBy: urlToRelativeUrl(urlInfo.url, rootDirectoryUrl)
+              }]
+            };
+          }
 
-      const {
-        dependents
-      } = urlInfo;
-      const instructions = [];
+          const {
+            dependents
+          } = urlInfo;
+          const instructions = [];
 
-      for (const dependentUrl of dependents) {
-        const dependentUrlInfo = urlInfos[dependentUrl];
+          for (const dependentUrl of dependents) {
+            const dependentUrlInfo = urlGraph.getUrlInfo(dependentUrl);
 
-        if (dependentUrlInfo.data.hotDecline) {
-          return {
-            declined: true,
-            reason: `a dependent file declines hot reload`,
-            declinedBy: dependentUrl
-          };
-        }
+            if (dependentUrlInfo.data.hotDecline) {
+              return {
+                declined: true,
+                reason: `a dependent file declines hot reload`,
+                declinedBy: dependentUrl
+              };
+            }
 
-        const {
-          hotAcceptDependencies = []
-        } = dependentUrlInfo.data;
+            const {
+              hotAcceptDependencies = []
+            } = dependentUrlInfo.data;
+
+            if (hotAcceptDependencies.includes(urlInfo.url)) {
+              instructions.push({
+                type: dependentUrlInfo.type,
+                boundary: urlToRelativeUrl(dependentUrl, rootDirectoryUrl),
+                acceptedBy: urlToRelativeUrl(urlInfo.url, rootDirectoryUrl)
+              });
+              continue;
+            }
 
-        if (hotAcceptDependencies.includes(urlInfo.url)) {
-          instructions.push({
-            type: dependentUrlInfo.type,
-            boundary: urlToRelativeUrl(dependentUrl, rootDirectoryUrl),
-            acceptedBy: urlToRelativeUrl(urlInfo.url, rootDirectoryUrl)
-          });
-          continue;
-        }
+            if (seen.includes(dependentUrl)) {
+              return {
+                declined: true,
+                reason: "circular dependency",
+                declinedBy: urlToRelativeUrl(dependentUrl, rootDirectoryUrl)
+              };
+            }
 
-        if (trace.includes(dependentUrl)) {
-          return {
-            declined: true,
-            reason: "circular dependency",
-            declinedBy: urlToRelativeUrl(dependentUrl, rootDirectoryUrl)
-          };
-        }
+            const dependentPropagationResult = iterate(dependentUrlInfo, [...seen, dependentUrl]);
 
-        const dependentPropagationResult = iterate(dependentUrlInfo, [...trace, dependentUrl]);
+            if (dependentPropagationResult.accepted) {
+              instructions.push(...dependentPropagationResult.instructions);
+              continue;
+            }
 
-        if (dependentPropagationResult.accepted) {
-          instructions.push(...dependentPropagationResult.instructions);
-          continue;
-        }
+            if ( // declined explicitely by an other file, it must decline the whole update
+            dependentPropagationResult.declinedBy) {
+              return dependentPropagationResult;
+            } // declined by absence of boundary, we can keep searching
 
-        if ( // declined explicitely by an other file, it must decline the whole update
-        dependentPropagationResult.declinedBy) {
-          return dependentPropagationResult;
-        } // declined by absence of boundary, we can keep searching
 
+            continue;
+          }
 
-        continue;
-      }
+          if (instructions.length === 0) {
+            return {
+              declined: true,
+              reason: `there is no file accepting hot reload while propagating update`
+            };
+          }
 
-      if (instructions.length === 0) {
-        return {
-          declined: true,
-          reason: `there is no file accepting hot reload while propagating update`
+          return {
+            accepted: true,
+            reason: `${instructions.length} dependent file(s) accepts hot reload`,
+            instructions
+          };
         };
-      }
 
-      return {
-        accepted: true,
-        reason: `${instructions.length} dependent file(s) accepts hot reload`,
-        instructions
+        const seen = [];
+        return iterate(firstUrlInfo, seen);
       };
-    };
 
-    const trace = [];
-    return iterate(firstUrlInfo, trace);
-  };
-
-  clientFileChangeCallbackList.push(({
-    url,
-    event
-  }) => {
-    const urlInfo = urlGraph.getUrlInfo(url); // file not part of dependency graph
+      clientFileChangeCallbackList.push(({
+        url,
+        event
+      }) => {
+        const urlInfo = urlGraph.getUrlInfo(url); // file not part of dependency graph
 
-    if (!urlInfo) {
-      return;
-    }
+        if (!urlInfo) {
+          return;
+        }
 
-    const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
-    const hotUpdate = propagateUpdate(urlInfo);
+        const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
+        const hotUpdate = propagateUpdate(urlInfo);
 
-    if (hotUpdate.declined) {
-      notifyDeclined({
-        cause: `${relativeUrl} ${event}`,
-        reason: hotUpdate.reason,
-        declinedBy: hotUpdate.declinedBy
-      });
-    } else {
-      notifyAccepted({
-        cause: `${relativeUrl} ${event}`,
-        reason: hotUpdate.reason,
-        instructions: hotUpdate.instructions
+        if (hotUpdate.declined) {
+          notifyDeclined({
+            cause: `${relativeUrl} ${event}`,
+            reason: hotUpdate.reason,
+            declinedBy: hotUpdate.declinedBy
+          });
+        } else {
+          notifyAccepted({
+            cause: `${relativeUrl} ${event}`,
+            reason: hotUpdate.reason,
+            instructions: hotUpdate.instructions
+          });
+        }
       });
-    }
-  });
-  clientFilesPruneCallbackList.push(({
-    prunedUrlInfos,
-    firstUrlInfo
-  }) => {
-    const mainHotUpdate = propagateUpdate(firstUrlInfo);
-    const cause = `following files are no longer referenced: ${prunedUrlInfos.map(prunedUrlInfo => urlToRelativeUrl(prunedUrlInfo.url, rootDirectoryUrl))}`; // now check if we can hot update the main ressource
-    // then if we can hot update all dependencies
+      clientFilesPruneCallbackList.push(({
+        prunedUrlInfos,
+        firstUrlInfo
+      }) => {
+        const mainHotUpdate = propagateUpdate(firstUrlInfo);
+        const cause = `following files are no longer referenced: ${prunedUrlInfos.map(prunedUrlInfo => urlToRelativeUrl(prunedUrlInfo.url, rootDirectoryUrl))}`; // now check if we can hot update the main ressource
+        // then if we can hot update all dependencies
+
+        if (mainHotUpdate.declined) {
+          notifyDeclined({
+            cause,
+            reason: mainHotUpdate.reason,
+            declinedBy: mainHotUpdate.declinedBy
+          });
+          return;
+        } // main can hot update
 
-    if (mainHotUpdate.declined) {
-      notifyDeclined({
-        cause,
-        reason: mainHotUpdate.reason,
-        declinedBy: mainHotUpdate.declinedBy
-      });
-      return;
-    } // main can hot update
 
+        let i = 0;
+        const instructions = [];
 
-    let i = 0;
-    const instructions = [];
+        while (i < prunedUrlInfos.length) {
+          const prunedUrlInfo = prunedUrlInfos[i++];
+
+          if (prunedUrlInfo.data.hotDecline) {
+            notifyDeclined({
+              cause,
+              reason: `a pruned file declines hot reload`,
+              declinedBy: urlToRelativeUrl(prunedUrlInfo.url, rootDirectoryUrl)
+            });
+            return;
+          }
 
-    while (i < prunedUrlInfos.length) {
-      const prunedUrlInfo = prunedUrlInfos[i++];
+          instructions.push({
+            type: "prune",
+            boundary: urlToRelativeUrl(prunedUrlInfo.url, rootDirectoryUrl),
+            acceptedBy: urlToRelativeUrl(firstUrlInfo.url, rootDirectoryUrl)
+          });
+        }
 
-      if (prunedUrlInfo.data.hotDecline) {
-        notifyDeclined({
+        notifyAccepted({
           cause,
-          reason: `a pruned file declines hot reload`,
-          declinedBy: urlToRelativeUrl(prunedUrlInfo.url, rootDirectoryUrl)
+          reason: mainHotUpdate.reason,
+          instructions
         });
-        return;
-      }
-
-      instructions.push({
-        type: "prune",
-        boundary: urlToRelativeUrl(prunedUrlInfo.url, rootDirectoryUrl),
-        acceptedBy: urlToRelativeUrl(firstUrlInfo.url, rootDirectoryUrl)
       });
-    }
-
-    notifyAccepted({
-      cause,
-      reason: mainHotUpdate.reason,
-      instructions
-    });
-  });
-  return {
-    name: "jsenv:sse_server",
-    appliesDuring: {
-      dev: true
     },
-    serve: request => {
+    serve: (request, {
+      rootDirectoryUrl,
+      urlGraph
+    }) => {
       if (request.ressource === "/__graph__") {
         const graphJson = JSON.stringify(urlGraph.toJSON(rootDirectoryUrl));
         return {
@@ -20515,26 +20461,12 @@ const jsenvPluginDevSSEServer = ({
         };
       }
 
-      const {
-        accept
-      } = request.headers;
-
-      if (accept && accept.includes("text/event-stream")) {
-        const room = sseService.getOrCreateSSERoom(request);
-        return room.join(request);
-      }
-
-      return null;
-    },
-    destroy: () => {
-      sseService.destroy();
-    }
-  };
-};
+      return null;
+    }
+  };
+};
 
 const jsenvPluginAutoreload = ({
-  rootDirectoryUrl,
-  urlGraph,
   scenario,
   clientFileChangeCallbackList,
   clientFilesPruneCallbackList
@@ -20544,8 +20476,6 @@ const jsenvPluginAutoreload = ({
   }
 
   return [jsenvPluginHmr(), jsenvPluginDevSSEClient(), jsenvPluginDevSSEServer({
-    rootDirectoryUrl,
-    urlGraph,
     clientFileChangeCallbackList,
     clientFilesPruneCallbackList
   })];
@@ -20634,8 +20564,6 @@ const getCorePlugins = ({
   }), jsenvPluginUrlResolution(), jsenvPluginUrlVersion(), jsenvPluginCommonJsGlobals(), jsenvPluginImportMetaScenarios(), jsenvPluginNodeRuntime({
     runtimeCompat
   }), jsenvPluginBundling(bundling), jsenvPluginMinification(minification), jsenvPluginImportMetaHot(), ...(clientAutoreload ? [jsenvPluginAutoreload({ ...clientAutoreload,
-    rootDirectoryUrl,
-    urlGraph,
     scenario,
     clientFileChangeCallbackList,
     clientFilesPruneCallbackList
@@ -20722,15 +20650,15 @@ const createUrlGraph = ({
   clientFileChangeCallbackList,
   clientFilesPruneCallbackList
 } = {}) => {
-  const urlInfos = {};
+  const urlInfoMap = new Map();
 
-  const getUrlInfo = url => urlInfos[url];
+  const getUrlInfo = url => urlInfoMap.get(url);
 
   const deleteUrlInfo = url => {
-    const urlInfo = urlInfos[url];
+    const urlInfo = urlInfoMap.get(url);
 
     if (urlInfo) {
-      delete urlInfos[url];
+      urlInfoMap.delete(url);
 
       if (urlInfo.sourcemapReference) {
         deleteUrlInfo(urlInfo.sourcemapReference.url);
@@ -20739,15 +20667,15 @@ const createUrlGraph = ({
   };
 
   const reuseOrCreateUrlInfo = url => {
-    const existingUrlInfo = urlInfos[url];
+    const existingUrlInfo = getUrlInfo(url);
     if (existingUrlInfo) return existingUrlInfo;
     const urlInfo = createUrlInfo(url);
-    urlInfos[url] = urlInfo;
+    urlInfoMap.set(url, urlInfo);
     return urlInfo;
   };
 
   const inferReference = (specifier, parentUrl) => {
-    const parentUrlInfo = urlInfos[parentUrl];
+    const parentUrlInfo = getUrlInfo(parentUrl);
 
     if (!parentUrlInfo) {
       return null;
@@ -20760,7 +20688,7 @@ const createUrlGraph = ({
   };
 
   const findDependent = (url, predicate) => {
-    const urlInfo = urlInfos[url];
+    const urlInfo = getUrlInfo(url);
 
     if (!urlInfo) {
       return null;
@@ -20768,7 +20696,7 @@ const createUrlGraph = ({
 
     const visitDependents = urlInfo => {
       for (const dependentUrl of urlInfo.dependents) {
-        const dependent = urlInfos[dependentUrl];
+        const dependent = getUrlInfo(dependentUrl);
 
         if (predicate(dependent)) {
           return dependent;
@@ -20818,7 +20746,7 @@ const createUrlGraph = ({
     const removeDependencies = (urlInfo, urlsToPrune) => {
       urlsToPrune.forEach(urlToPrune => {
         urlInfo.dependencies.delete(urlToPrune);
-        const dependency = urlInfos[urlToPrune];
+        const dependency = getUrlInfo(urlToPrune);
 
         if (!dependency) {
           return;
@@ -20858,7 +20786,7 @@ const createUrlGraph = ({
     clientFileChangeCallbackList.push(({
       url
     }) => {
-      const urlInfo = urlInfos[url];
+      const urlInfo = getUrlInfo(url);
 
       if (urlInfo) {
         considerModified(urlInfo, Date.now());
@@ -20878,7 +20806,7 @@ const createUrlGraph = ({
       urlInfo.modifiedTimestamp = modifiedTimestamp;
       urlInfo.contentEtag = undefined;
       urlInfo.dependents.forEach(dependentUrl => {
-        const dependentUrlInfo = urlInfos[dependentUrl];
+        const dependentUrlInfo = getUrlInfo(dependentUrl);
         const {
           hotAcceptDependencies = []
         } = dependentUrlInfo.data;
@@ -20887,6 +20815,13 @@ const createUrlGraph = ({
           iterate(dependentUrlInfo);
         }
       });
+      urlInfo.dependencies.forEach(dependencyUrl => {
+        const dependencyUrlInfo = getUrlInfo(dependencyUrl);
+
+        if (dependencyUrlInfo.isInline) {
+          iterate(dependencyUrlInfo);
+        }
+      });
     };
 
     iterate(urlInfo);
@@ -20908,7 +20843,7 @@ const createUrlGraph = ({
   };
 
   return {
-    urlInfos,
+    urlInfoMap,
     reuseOrCreateUrlInfo,
     getUrlInfo,
     deleteUrlInfo,
@@ -20917,13 +20852,20 @@ const createUrlGraph = ({
     updateReferences,
     considerModified,
     getRelatedUrlInfos,
+    toObject: () => {
+      const data = {};
+      urlInfoMap.forEach(urlInfo => {
+        data[urlInfo.url] = urlInfo;
+      });
+      return data;
+    },
     toJSON: rootDirectoryUrl => {
       const data = {};
-      Object.keys(urlInfos).forEach(url => {
-        const dependencyUrls = Array.from(urlInfos[url].dependencies);
+      urlInfoMap.forEach(urlInfo => {
+        const dependencyUrls = Array.from(urlInfo.dependencies);
 
         if (dependencyUrls.length) {
-          const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
+          const relativeUrl = urlToRelativeUrl(urlInfo.url, rootDirectoryUrl);
           data[relativeUrl] = dependencyUrls.map(dependencyUrl => urlToRelativeUrl(dependencyUrl, rootDirectoryUrl));
         }
       });
@@ -21508,7 +21450,7 @@ const createResolveUrlError = ({
       reason,
       ...details,
       "specifier": `"${reference.specifier}"`,
-      "specifier trace": reference.trace,
+      "specifier trace": reference.trace.message,
       ...detailsFromPluginController(pluginController)
     }));
     resolveError.name = "RESOLVE_URL_ERROR";
@@ -21539,17 +21481,21 @@ const createFetchUrlContentError = ({
     reason,
     ...details
   }) => {
-    const fetchContentError = new Error(createDetailedMessage$1(`Failed to fetch url content`, {
+    const fetchError = new Error(createDetailedMessage$1(`Failed to fetch url content`, {
       reason,
       ...details,
       "url": urlInfo.url,
-      "url reference trace": reference.trace,
+      "url reference trace": reference.trace.message,
       ...detailsFromPluginController(pluginController)
     }));
-    fetchContentError.name = "FETCH_URL_CONTENT_ERROR";
-    fetchContentError.code = code;
-    fetchContentError.reason = reason;
-    return fetchContentError;
+    fetchError.name = "FETCH_URL_CONTENT_ERROR";
+    fetchError.code = code;
+    fetchError.reason = reason;
+    fetchError.url = reference.trace.url;
+    fetchError.line = reference.trace.line;
+    fetchError.column = reference.trace.column;
+    fetchError.contentFrame = reference.trace.message;
+    return fetchError;
   };
 
   if (error.code === "EPERM") {
@@ -21593,12 +21539,42 @@ const createTransformUrlContentError = ({
       reason,
       ...details,
       "url": urlInfo.url,
-      "url reference trace": reference.trace,
+      "url reference trace": reference.trace.message,
       ...detailsFromPluginController(pluginController)
     }));
     transformError.name = "TRANSFORM_URL_CONTENT_ERROR";
     transformError.code = code;
     transformError.reason = reason;
+    transformError.url = reference.trace.url;
+    transformError.line = reference.trace.line;
+    transformError.column = reference.trace.column;
+    transformError.stack = error.stack;
+    transformError.contentFrame = reference.trace.message;
+
+    if (code === "PARSE_ERROR") {
+      transformError.reason = error.message;
+
+      if (urlInfo.isInline) {
+        transformError.line = reference.trace.line + error.line - 1;
+        transformError.column = reference.trace.column + error.column;
+        transformError.contentFrame = stringifyUrlSite({
+          url: urlInfo.inlineUrlSite.url,
+          line: transformError.line,
+          column: transformError.column,
+          content: urlInfo.inlineUrlSite.content
+        });
+      } else {
+        transformError.line = error.line;
+        transformError.column = error.column;
+        transformError.contentFrame = stringifyUrlSite({
+          url: urlInfo.url,
+          line: transformError.line,
+          column: transformError.column,
+          content: urlInfo.content
+        });
+      }
+    }
+
     return transformError;
   };
 
@@ -21617,7 +21593,7 @@ const createFinalizeUrlContentError = ({
     "reason": `An error occured during "finalizeUrlContent"`,
     ...detailsFromValueThrown(error),
     "url": urlInfo.url,
-    "url reference trace": reference.trace,
+    "url reference trace": reference.trace.message,
     ...detailsFromPluginController(pluginController)
   }));
   finalizeError.name = "FINALIZE_URL_CONTENT_ERROR";
@@ -22012,7 +21988,10 @@ const createKitchen = ({
       specifier
     }) => {
       const sourcemapReference = createReference({
-        trace: `sourcemap comment placeholder for ${urlInfo.url}`,
+        trace: {
+          message: `sourcemap comment placeholder`,
+          url: urlInfo.url
+        },
         type: "sourcemap_comment",
         subtype: urlInfo.contentType === "text/javascript" ? "js" : "css",
         parentUrl: urlInfo.url,
@@ -22029,13 +22008,14 @@ const createKitchen = ({
       specifierLine,
       specifierColumn
     }) => {
+      const sourcemapUrlSite = adjustUrlSite(urlInfo, {
+        urlGraph,
+        url: urlInfo.url,
+        line: specifierLine,
+        column: specifierColumn
+      });
       const sourcemapReference = createReference({
-        trace: stringifyUrlSite(adjustUrlSite(urlInfo, {
-          urlGraph,
-          url: urlInfo.url,
-          line: specifierLine,
-          column: specifierColumn
-        })),
+        trace: traceFromUrlSite(sourcemapUrlSite),
         type,
         parentUrl: urlInfo.url,
         specifier,
@@ -22058,7 +22038,7 @@ const createKitchen = ({
       if (!fetchUrlContentReturnValue) {
         logger.warn(createDetailedMessage$1(`no plugin has handled url during "fetchUrlContent" hook -> url will be ignored`, {
           "url": urlInfo.url,
-          "url reference trace": reference.trace
+          "url reference trace": reference.trace.message
         }));
         return;
       }
@@ -22215,7 +22195,7 @@ const createKitchen = ({
           ...rest
         }) => {
           if (trace === undefined) {
-            trace = stringifyUrlSite(adjustUrlSite(urlInfo, {
+            trace = traceFromUrlSite(adjustUrlSite(urlInfo, {
               urlGraph,
               url: urlInfo.url,
               line: rest.specifierLine,
@@ -22231,22 +22211,22 @@ const createKitchen = ({
         },
         foundInline: ({
           isOriginalPosition,
-          line,
-          column,
+          specifierLine,
+          specifierColumn,
           ...rest
         }) => {
           const parentUrl = isOriginalPosition ? urlInfo.url : urlInfo.generatedUrl;
           const parentContent = isOriginalPosition ? urlInfo.originalContent : urlInfo.content;
           return addReference({
-            trace: stringifyUrlSite({
+            trace: traceFromUrlSite({
               url: parentUrl,
               content: parentContent,
-              line,
-              column
+              line: specifierLine,
+              column: specifierColumn
             }),
             isOriginalPosition,
-            line,
-            column,
+            specifierLine,
+            specifierColumn,
             isInline: true,
             ...rest
           });
@@ -22284,7 +22264,7 @@ const createKitchen = ({
           const parentUrl = isOriginalPosition ? urlInfo.url : urlInfo.generatedUrl;
           const parentContent = isOriginalPosition ? urlInfo.originalContent : urlInfo.content;
           return referenceUtils.update(reference, {
-            trace: stringifyUrlSite({
+            trace: traceFromUrlSite({
               url: parentUrl,
               content: parentContent,
               line: specifierLine,
@@ -22309,7 +22289,7 @@ const createKitchen = ({
               line,
               column
             } = getCallerPosition();
-            trace = stringifyUrlSite({
+            trace = traceFromUrlSite({
               url,
               line,
               column
@@ -22518,6 +22498,15 @@ const memoizeCook = cook => {
   };
 };
 
+const traceFromUrlSite = urlSite => {
+  return {
+    message: stringifyUrlSite(urlSite),
+    url: urlSite.url,
+    line: urlSite.line,
+    column: urlSite.column
+  };
+};
+
 const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
   if (reference.shouldHandle) {
     urlInfo.shouldHandle = true;
@@ -22746,6 +22735,60 @@ const determineFileUrlForOutDirectory = ({
 //   }
 // }
 
+const createSSEService = ({
+  serverEventCallbackList
+}) => {
+  const destroyCallbackList = createCallbackListNotifiedOnce();
+  const cache = [];
+  const sseRoomLimit = 100;
+
+  const getOrCreateSSERoom = request => {
+    const htmlFileRelativeUrl = request.ressource.slice(1);
+    const cacheEntry = cache.find(cacheEntryCandidate => cacheEntryCandidate.htmlFileRelativeUrl === htmlFileRelativeUrl);
+
+    if (cacheEntry) {
+      return cacheEntry.sseRoom;
+    }
+
+    const sseRoom = createSSERoom({
+      retryDuration: 2000,
+      historyLength: 100,
+      welcomeEventEnabled: true,
+      effect: () => {
+        return serverEventCallbackList.add(event => {
+          sseRoom.sendEvent(event);
+        });
+      }
+    });
+    const removeSSECleanupCallback = destroyCallbackList.add(() => {
+      removeSSECleanupCallback();
+      sseRoom.close();
+    });
+    cache.push({
+      htmlFileRelativeUrl,
+      sseRoom,
+      cleanup: () => {
+        removeSSECleanupCallback();
+        sseRoom.close();
+      }
+    });
+
+    if (cache.length >= sseRoomLimit) {
+      const firstCacheEntry = cache.shift();
+      firstCacheEntry.cleanup();
+    }
+
+    return sseRoom;
+  };
+
+  return {
+    getOrCreateSSERoom,
+    destroy: () => {
+      destroyCallbackList.notify();
+    }
+  };
+};
+
 const memoizeByFirstArgument = compute => {
   const urlCache = new Map();
 
@@ -22798,7 +22841,10 @@ const createFileService = ({
   rootDirectoryUrl,
   urlGraph,
   kitchen,
-  scenario
+  scenario,
+  onParseError,
+  onFileNotFound,
+  onUnexpectedError
 }) => {
   kitchen.pluginController.addHook("serve");
   kitchen.pluginController.addHook("augmentResponse");
@@ -22838,7 +22884,9 @@ const createFileService = ({
 
     if (!reference) {
       const entryPoint = kitchen.injectReference({
-        trace: parentUrl || rootDirectoryUrl,
+        trace: {
+          message: parentUrl || rootDirectoryUrl
+        },
         parentUrl: parentUrl || rootDirectoryUrl,
         type: "http_request",
         specifier: request.ressource
@@ -22918,10 +22966,18 @@ const createFileService = ({
       const code = e.code;
 
       if (code === "PARSE_ERROR") {
-        // let the browser re-throw the syntax error
+        onParseError({
+          reason: e.reason,
+          message: e.message,
+          url: e.url,
+          line: e.line,
+          column: e.column,
+          contentFrame: e.contentFrame
+        });
         return {
           url: reference.url,
           status: 200,
+          // let the browser re-throw the syntax error
           statusText: e.reason,
           statusMessage: e.message,
           headers: {
@@ -22952,6 +23008,14 @@ const createFileService = ({
       }
 
       if (code === "NOT_FOUND") {
+        onFileNotFound({
+          reason: e.reason,
+          message: e.message,
+          url: e.url,
+          line: e.line,
+          column: e.column,
+          contentFrame: e.contentFrame
+        });
         return {
           url: reference.url,
           status: 404,
@@ -22960,6 +23024,15 @@ const createFileService = ({
         };
       }
 
+      onUnexpectedError({
+        reason: e.reason,
+        message: e.message,
+        stack: e.stack,
+        url: e.url,
+        line: e.line,
+        column: e.column,
+        contentFrame: e.contentFrame
+      });
       return {
         url: reference.url,
         status: 500,
@@ -23026,12 +23099,75 @@ const startOmegaServer = async ({
   kitchen
 }) => {
   const serverStopCallbackList = createCallbackListNotifiedOnce();
+  const serverEventCallbackList = createCallbackList();
+  const sseService = createSSEService({
+    serverEventCallbackList
+  });
+
+  const sendServerEvent = ({
+    type,
+    data
+  }) => {
+    serverEventCallbackList.notify({
+      type,
+      data: JSON.stringify(data)
+    });
+  };
+
+  kitchen.pluginController.addHook("registerServerEvents");
+  kitchen.pluginController.callHooks("registerServerEvents", {
+    sendServerEvent
+  }, {
+    rootDirectoryUrl,
+    urlGraph,
+    scenario
+  }, () => {});
+
+  const sendServerErrorEvent = event => {
+    // setTimeout display first the error
+    // dispatched on window by browser
+    // then display the jsenv error
+    setTimeout(() => {
+      sendServerEvent(event);
+    }, 10);
+  };
+
   const coreServices = {
+    "service:server_events": request => {
+      const {
+        accept
+      } = request.headers;
+
+      if (accept && accept.includes("text/event-stream")) {
+        const room = sseService.getOrCreateSSERoom(request);
+        return room.join(request);
+      }
+
+      return null;
+    },
     "service:file": createFileService({
       rootDirectoryUrl,
       urlGraph,
       kitchen,
-      scenario
+      scenario,
+      onFileNotFound: data => {
+        sendServerErrorEvent({
+          type: "file_not_found",
+          data
+        });
+      },
+      onParseError: data => {
+        sendServerErrorEvent({
+          type: "parse_error",
+          data
+        });
+      },
+      onUnexpectedError: data => {
+        sendServerErrorEvent({
+          type: "unexpected_error",
+          data
+        });
+      }
     })
   };
   const server = await startServer({
@@ -23112,6 +23248,7 @@ const startOmegaServer = async ({
     }),
     onStop: reason => {
       onStop();
+      sseService.destroy();
       serverStopCallbackList.notify(reason);
     }
   });
@@ -24003,7 +24140,7 @@ const reportToCoverage = async (report, {
       // coverDescription will generate empty coverage for files
       // that were suppose to be coverage but were not.
       if (executionResult.status === "completed" && executionResult.type === "node" && coverageMethodForNodeJs !== "NODE_V8_COVERAGE") {
-        logger.warn(`No "coverageFileUrl" from execution named "${executionName}" of ${file}`);
+        logger.warn(`"${executionName}" execution of ${file} did not properly write coverage into ${executionResult.coverageFileUrl}`);
       }
     }
   });
@@ -24084,17 +24221,22 @@ const getCoverageFromReport = async ({
         const {
           coverageFileUrl
         } = executionResultForFileOnRuntime;
+        let executionCoverage;
 
-        if (!coverageFileUrl) {
-          onMissing({
-            executionName,
-            file,
-            executionResult: executionResultForFileOnRuntime
-          });
-          return;
-        }
+        try {
+          executionCoverage = JSON.parse(String(readFileSync$1(new URL(coverageFileUrl))));
+        } catch (e) {
+          if (e.code === "ENOENT" || e.name === "SyntaxError") {
+            onMissing({
+              executionName,
+              file,
+              executionResult: executionResultForFileOnRuntime
+            });
+            return;
+          }
 
-        const executionCoverage = JSON.parse(String(readFileSync$1(new URL(coverageFileUrl))));
+          throw e;
+        }
 
         if (isV8Coverage(executionCoverage)) {
           v8Coverage = v8Coverage ? composeTwoV8Coverages(v8Coverage, executionCoverage) : executionCoverage;
@@ -24127,7 +24269,7 @@ const run = async ({
   runtime,
   runtimeParams
 }) => {
-  let result = {};
+  const result = {};
   const callbacks = [];
   const onConsoleRef = {
     current: () => {}
@@ -24145,18 +24287,16 @@ const run = async ({
     const timeoutAbortSource = runOperation.timeout(allocatedMs);
     callbacks.push(() => {
       if (result.status === "errored" && Abort.isAbortError(result.error) && timeoutAbortSource.signal.aborted) {
-        result = {
-          status: "timedout"
-        };
+        result.status = "timedout";
+        delete result.error;
       }
     });
   }
 
   callbacks.push(() => {
     if (result.status === "errored" && Abort.isAbortError(result.error)) {
-      result = {
-        status: "aborted"
-      };
+      result.status = "aborted";
+      delete result.error;
     }
   });
   const consoleCalls = [];
@@ -24185,6 +24325,22 @@ const run = async ({
     callbacks.push(() => {
       result.consoleCalls = consoleCalls;
     });
+  } // we do not keep coverage in memory, it can grow very big
+  // instead we store it on the filesystem
+  // and they can be read later at "coverageFileUrl"
+
+
+  let coverageFileUrl;
+
+  if (coverageEnabled) {
+    coverageFileUrl = new URL(`./${runtime.name}/${cuid()}.json`, coverageTempDirectoryUrl).href;
+    await ensureParentDirectories(coverageFileUrl);
+
+    if (coverageEnabled) {
+      result.coverageFileUrl = coverageFileUrl; // written within the child_process/worker_thread or during runtime.run()
+      // for browsers
+      // (because it takes time to serialize and transfer the coverage object)
+    }
   }
 
   const startMs = Date.now();
@@ -24209,7 +24365,9 @@ const run = async ({
               signal: runOperation.signal,
               logger,
               ...runtimeParams,
+              collectConsole,
               collectPerformance,
+              coverageFileUrl,
               keepRunning,
               stopSignal,
               onConsole: log => onConsoleRef.current(log)
@@ -24234,8 +24392,7 @@ const run = async ({
       status,
       namespace,
       error,
-      performance,
-      coverage
+      performance
     } = winner.data;
     result.status = status;
 
@@ -24249,27 +24406,13 @@ const run = async ({
       result.performance = performance;
     }
 
-    if (coverageEnabled) {
-      if (coverage) {
-        // we do not keep coverage in memory, it can grow very big
-        // instead we store it on the filesystem
-        // and they can be read later at "coverageFileUrl"
-        const coverageFileUrl = new URL(`./${runtime.name}/${cuid()}.json`, coverageTempDirectoryUrl);
-        writeFileSync(coverageFileUrl, JSON.stringify(coverage, null, "  "));
-        result.coverageFileUrl = coverageFileUrl.href;
-      } else {// will eventually log a warning in report_to_coverage.js
-      }
-    }
-
     callbacks.forEach(callback => {
       callback();
     });
     return result;
   } catch (e) {
-    result = {
-      status: "errored",
-      error: e
-    };
+    result.status = "errored";
+    result.error = e;
     callbacks.forEach(callback => {
       callback();
     });
@@ -24567,20 +24710,78 @@ const formatConsoleCalls = consoleCalls => {
     error: 0,
     log: 0
   };
-  let consoleOutput = ``;
   consoleCalls.forEach(consoleCall => {
     repartition[consoleCall.type]++;
-    const text = consoleCall.text;
+  });
+  const consoleOutput = formatConsoleOutput(consoleCalls);
+  return `${ANSI.color(`-------- ${formatConsoleSummary(repartition)} --------`, ANSI.GREY)}
+${consoleOutput}
+${ANSI.color(`-------------------------`, ANSI.GREY)}`;
+};
+
+const formatConsoleOutput = consoleCalls => {
+  // inside Node.js you can do process.stdout.write()
+  // and in that case the consoleCall is not suffixed with "\n"
+  // we want to keep these calls together in the output
+  const regroupedCalls = [];
+  consoleCalls.forEach((consoleCall, index) => {
+    if (index === 0) {
+      regroupedCalls.push(consoleCall);
+      return;
+    }
+
+    const previousCall = consoleCalls[index - 1];
+
+    if (previousCall.type !== consoleCall.type) {
+      regroupedCalls.push(consoleCall);
+      return;
+    }
+
+    if (previousCall.text.endsWith("\n")) {
+      regroupedCalls.push(consoleCall);
+      return;
+    }
+
+    if (previousCall.text.endsWith("\r")) {
+      regroupedCalls.push(consoleCall);
+      return;
+    }
+
+    const previousRegroupedCallIndex = regroupedCalls.length - 1;
+    const previousRegroupedCall = regroupedCalls[previousRegroupedCallIndex];
+    previousRegroupedCall.text = `${previousRegroupedCall.text}${consoleCall.text}`;
+  });
+  let consoleOutput = ``;
+  regroupedCalls.forEach((regroupedCall, index) => {
+    const text = regroupedCall.text;
     const textFormatted = prefixFirstAndIndentRemainingLines({
-      prefix: CONSOLE_ICONS[consoleCall.type],
+      prefix: CONSOLE_ICONS[regroupedCall.type],
       text,
-      trimLastLine: consoleCall === consoleCalls[consoleCalls.length - 1]
+      trimLastLine: index === regroupedCalls.length - 1
     });
     consoleOutput += textFormatted;
   });
-  return `${ANSI.color(`-------- ${formatConsoleSummary(repartition)} --------`, ANSI.GREY)}
-${consoleOutput}
-${ANSI.color(`-------------------------`, ANSI.GREY)}`;
+  return consoleOutput;
+};
+
+const prefixFirstAndIndentRemainingLines = ({
+  prefix,
+  text,
+  trimLastLine
+}) => {
+  const lines = text.split(/\r?\n/);
+  const firstLine = lines.shift();
+  let result = `${prefix} ${firstLine}`;
+  let i = 0;
+  const indentation = `  `;
+
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    i++;
+    result += line.length ? `\n${indentation}${line}` : trimLastLine && i === lines.length ? "" : `\n`;
+  }
+
+  return result;
 };
 
 const CONSOLE_ICONS = {
@@ -24623,26 +24824,6 @@ const formatConsoleSummary = repartition => {
   return `console (${parts.join(" ")})`;
 };
 
-const prefixFirstAndIndentRemainingLines = ({
-  prefix,
-  text,
-  trimLastLine
-}) => {
-  const lines = text.split(/\r?\n/);
-  const firstLine = lines.shift();
-  let result = `${prefix} ${firstLine}`;
-  let i = 0;
-  const indentation = `  `;
-
-  while (i < lines.length) {
-    const line = lines[i].trim();
-    i++;
-    result += line.length ? `\n${indentation}${line}` : trimLastLine && i === lines.length ? "" : `\n`;
-  }
-
-  return result;
-};
-
 const formatExecution = ({
   label,
   details = {},
@@ -24767,7 +24948,7 @@ const executePlan = async (plan, {
       } else {
         coverageMethodForNodeJs = "Profiler";
         logger.warn(createDetailedMessage$1(`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": `set process.env.NODE_V8_COVERAGE`,
           "suggestion 2": `use coverageMethodForNodeJs: "Profiler". But it means coverage for child_process and worker_thread cannot be collected`
         }));
       }
@@ -24845,7 +25026,7 @@ const executePlan = async (plan, {
             getCustomBabelPlugins: ({
               clientRuntimeCompat
             }) => {
-              if (coverageEnabled && Object.keys(clientRuntimeCompat)[0] !== "chrome") {
+              if (coverageEnabled && (coverageMethodForBrowsers !== "playwright_api" || Object.keys(clientRuntimeCompat)[0] !== "chrome")) {
                 return {
                   "transform-instrument": [babelPluginInstrument, {
                     rootDirectoryUrl,
@@ -25269,8 +25450,7 @@ const executeTestPlan = async ({
   },
   coverageIncludeMissing = true,
   coverageAndExecutionAllowed = false,
-  coverageMethodForNodeJs = "NODE_V8_COVERAGE",
-  // "Profiler" also accepted
+  coverageMethodForNodeJs = process.env.NODE_V8_COVERAGE ? "NODE_V8_COVERAGE" : "Profiler",
   coverageMethodForBrowsers = "playwright_api",
   // "istanbul" also accepted
   coverageV8ConflictWarning = true,
@@ -25508,6 +25688,7 @@ const createRuntimeFromPlaywright = ({
     coverageEnabled = false,
     coverageConfig,
     coverageMethodForBrowsers,
+    coverageFileUrl,
     stopAfterAllSignal,
     stopSignal,
     keepRunning,
@@ -25590,13 +25771,14 @@ const createRuntimeFromPlaywright = ({
       }
     };
 
-    let resultTransformer = result => result;
+    const result = {};
+    const callbacks = [];
 
     if (coverageEnabled) {
       if (coveragePlaywrightAPIAvailable && coverageMethodForBrowsers === "playwright_api") {
         await page.coverage.startJSCoverage({// reportAnonymousScripts: true,
         });
-        resultTransformer = composeTransformer(resultTransformer, async result => {
+        callbacks.push(async () => {
           const v8CoveragesWithWebUrls = await page.coverage.stopJSCoverage(); // we convert urls starting with http:// to file:// because we later
           // convert the url to filesystem path in istanbulCoverageFromV8Coverage function
 
@@ -25617,23 +25799,20 @@ const createRuntimeFromPlaywright = ({
             rootDirectoryUrl,
             coverageConfig
           });
-          return { ...result,
-            coverage
-          };
+          writeFileSync$1(new URL(coverageFileUrl), JSON.stringify(coverage, null, "  "));
         });
       } else {
-        resultTransformer = composeTransformer(resultTransformer, async result => {
+        callbacks.push(() => {
           const scriptExecutionResults = result.namespace;
 
           if (scriptExecutionResults) {
-            result.coverage = generateCoverageForPage(scriptExecutionResults);
+            const coverage = generateCoverageForPage(scriptExecutionResults) || {};
+            writeFileSync$1(new URL(coverageFileUrl), JSON.stringify(coverage, null, "  "));
           }
-
-          return result;
         });
       }
     } else {
-      resultTransformer = composeTransformer(resultTransformer, result => {
+      callbacks.push(() => {
         const scriptExecutionResults = result.namespace;
 
         if (scriptExecutionResults) {
@@ -25641,13 +25820,11 @@ const createRuntimeFromPlaywright = ({
             delete scriptExecutionResults[fileRelativeUrl].coverage;
           });
         }
-
-        return result;
       });
     }
 
     if (collectPerformance) {
-      resultTransformer = composeTransformer(resultTransformer, async result => {
+      callbacks.push(async () => {
         const performance = await page.evaluate(
         /* eslint-disable no-undef */
 
@@ -25676,7 +25853,6 @@ const createRuntimeFromPlaywright = ({
         /* eslint-enable no-undef */
         );
         result.performance = performance;
-        return result;
       });
     }
 
@@ -25770,7 +25946,7 @@ const createRuntimeFromPlaywright = ({
             await page.goto(fileClientUrl, {
               timeout: 0
             });
-            const result = await page.evaluate(
+            const returnValue = await page.evaluate(
             /* eslint-disable no-undef */
 
             /* istanbul ignore next */
@@ -25786,12 +25962,12 @@ const createRuntimeFromPlaywright = ({
             const {
               status,
               scriptExecutionResults
-            } = result;
+            } = returnValue;
 
             if (status === "errored") {
               const {
                 exceptionSource
-              } = result;
+              } = returnValue;
               const error = evalException(exceptionSource, {
                 rootDirectoryUrl,
                 server,
@@ -25842,16 +26018,32 @@ const createRuntimeFromPlaywright = ({
       return winner.data;
     };
 
-    let result;
-
     try {
-      result = await getResult();
-      result = await resultTransformer(result);
+      const {
+        status,
+        error,
+        namespace,
+        performance
+      } = await getResult();
+      result.status = status;
+
+      if (status === "errored") {
+        result.error = error;
+      } else {
+        result.namespace = namespace;
+      }
+
+      if (collectPerformance) {
+        result.performance = performance;
+      }
+
+      await callbacks.reduce(async (previous, callback) => {
+        await previous;
+        await callback();
+      }, Promise.resolve());
     } catch (e) {
-      result = {
-        status: "errored",
-        error: e
-      };
+      result.status = "errored";
+      result.error = e;
     }
 
     if (keepRunning) {
@@ -25969,13 +26161,6 @@ const isTargetClosedError = error => {
   return false;
 };
 
-const composeTransformer = (previousTransformer, transformer) => {
-  return async value => {
-    const transformedValue = await previousTransformer(value);
-    return transformer(transformedValue);
-  };
-};
-
 const extractTextFromConsoleMessage = consoleMessage => {
   return consoleMessage.text(); // ensure we use a string so that istanbul won't try
   // to put any coverage statement inside it
@@ -26385,6 +26570,7 @@ nodeChildProcess.run = async ({
   coverageEnabled = false,
   coverageConfig,
   coverageMethodForNodeJs,
+  coverageFileUrl,
   collectPerformance,
   env,
   debugPort,
@@ -26548,6 +26734,7 @@ nodeChildProcess.run = async ({
           coverageEnabled,
           coverageConfig,
           coverageMethodForNodeJs,
+          coverageFileUrl,
           exitAfterAction: true
         }
       }
@@ -26728,10 +26915,12 @@ nodeWorkerThread.run = async ({
   keepRunning,
   stopSignal,
   onConsole,
+  collectConsole = false,
+  collectPerformance,
+  coverageEnabled = false,
   coverageConfig,
   coverageMethodForNodeJs,
-  coverageEnabled = false,
-  collectPerformance,
+  coverageFileUrl,
   env,
   debugPort,
   debugMode,
@@ -26797,11 +26986,14 @@ nodeWorkerThread.run = async ({
   const stop = memoize(async () => {
     // read all stdout before terminating
     // (no need for stderr because it's sync)
-    while (workerThread.stdout.read() !== null) {}
+    if (collectConsole) {
+      while (workerThread.stdout.read() !== null) {}
+
+      await new Promise(resolve => {
+        setTimeout(resolve, 50);
+      });
+    }
 
-    await new Promise(resolve => {
-      setTimeout(resolve);
-    });
     await workerThread.terminate();
   });
   const winnerPromise = new Promise(resolve => {
@@ -26841,6 +27033,7 @@ nodeWorkerThread.run = async ({
           coverageEnabled,
           coverageConfig,
           coverageMethodForNodeJs,
+          coverageFileUrl,
           exitAfterAction: true
         }
       }
@@ -27098,9 +27291,6 @@ ${createRepartitionMessage(graphReport)}
 };
 
 const createUrlGraphReport = urlGraph => {
-  const {
-    urlInfos
-  } = urlGraph;
   const countGroups = {
     sourcemaps: 0,
     html: 0,
@@ -27119,15 +27309,14 @@ const createUrlGraphReport = urlGraph => {
     other: 0,
     total: 0
   };
-  Object.keys(urlInfos).forEach(url => {
-    if (url.startsWith("data:")) {
+  urlGraph.urlInfoMap.forEach(urlInfo => {
+    if (urlInfo.url.startsWith("data:")) {
       return;
-    }
-
-    const urlInfo = urlInfos[url]; // ignore:
+    } // ignore:
     // - inline files: they are already taken into account in the file where they appear
     // - ignored files: we don't know their content
 
+
     if (urlInfo.isInline || !urlInfo.shouldHandle) {
       return;
     } // file loaded via import assertion are already inside the graph
@@ -27305,20 +27494,18 @@ const createRepartitionMessage = ({
 
 const GRAPH = {
   map: (graph, callback) => {
-    return Object.keys(graph.urlInfos).map(url => {
-      return callback(graph.urlInfos[url]);
+    const array = [];
+    graph.urlInfoMap.forEach(urlInfo => {
+      array.push(callback(urlInfo));
     });
+    return array;
   },
   forEach: (graph, callback) => {
-    Object.keys(graph.urlInfos).forEach(url => {
-      callback(graph.urlInfos[url], url);
-    });
+    graph.urlInfoMap.forEach(callback);
   },
   filter: (graph, callback) => {
     const urlInfos = [];
-    Object.keys(graph.urlInfos).forEach(url => {
-      const urlInfo = graph.urlInfos[url];
-
+    graph.urlInfoMap.forEach(urlInfo => {
       if (callback(urlInfo)) {
         urlInfos.push(urlInfo);
       }
@@ -27326,10 +27513,16 @@ const GRAPH = {
     return urlInfos;
   },
   find: (graph, callback) => {
-    const urlFound = Object.keys(graph.urlInfos).find(url => {
-      return callback(graph.urlInfos[url]);
-    });
-    return graph.urlInfos[urlFound];
+    let found = null;
+
+    for (const urlInfo of graph.urlInfoMap.values()) {
+      if (callback(urlInfo)) {
+        found = urlInfo;
+        break;
+      }
+    }
+
+    return found;
   }
 };
 
@@ -27964,7 +28157,9 @@ build ${entryPointKeys.length} entry points`);
         startLoading: cookEntryFile => {
           Object.keys(entryPoints).forEach(key => {
             const [, entryUrlInfo] = cookEntryFile({
-              trace: `"${key}" in entryPoints parameter`,
+              trace: {
+                message: `"${key}" in entryPoints parameter`
+              },
               type: "entry_point",
               specifier: key
             });
@@ -28460,7 +28655,9 @@ build ${entryPointKeys.length} entry points`);
         startLoading: cookEntryFile => {
           entryUrls.forEach(entryUrl => {
             const [, postBuildEntryUrlInfo] = cookEntryFile({
-              trace: `entryPoint`,
+              trace: {
+                message: `entryPoint`
+              },
               type: "entry_point",
               specifier: entryUrl
             });
@@ -28475,7 +28672,7 @@ build ${entryPointKeys.length} entry points`);
 
     buildTask.done();
     logger.debug(`graph urls pre-versioning:
-${Object.keys(finalGraph.urlInfos).join("\n")}`);
+${Array.from(finalGraph.urlInfoMap.keys()).join("\n")}`);
 
     if (versioning) {
       await applyUrlVersioning({
@@ -28731,7 +28928,7 @@ const applyUrlVersioning = async ({
   });
 
   try {
-    const urlsSorted = sortByDependencies(finalGraph.urlInfos);
+    const urlsSorted = sortByDependencies(finalGraph.toObject());
     urlsSorted.forEach(url => {
       if (url.startsWith("data:")) {
         return;