@jsenv/core 27.0.0-alpha.82 → 27.0.0-alpha.85

package/dist/main.js

@@ -1,56 +1,89 @@
-import { parentPort } from "node:worker_threads";
-import { registerFileLifecycle, readFileSync as readFileSync$1, bufferToEtag, writeFileSync, ensureWindowsDriveLetter, collectFiles, assertAndNormalizeDirectoryUrl, registerDirectoryLifecycle, writeFile, ensureEmptyDirectory, writeDirectory } from "@jsenv/filesystem";
-import { createDetailedMessage, createLogger, createTaskLog, loggerToLevels, ANSI, msAsDuration, msAsEllapsedTime, byteAsMemoryUsage, UNICODE, createLog, startSpinner, distributePercentages, byteAsFileSize } from "@jsenv/log";
+import { createSSERoom, timeStart, fetchFileSystem, composeTwoResponses, serveDirectory, startServer, pluginCORS, jsenvAccessControlAllowedHeaders, pluginServerTiming, pluginRequestWaitingCheck, composeServices, findFreePort } from "@jsenv/server";
+import { registerFileLifecycle, readFileSync as readFileSync$1, bufferToEtag, writeFileSync, ensureWindowsDriveLetter, collectFiles, assertAndNormalizeDirectoryUrl, registerDirectoryLifecycle, writeFile, readFile, readDirectory, ensureEmptyDirectory, writeDirectory } from "@jsenv/filesystem";
+import { createCallbackListNotifiedOnce, createCallbackList, Abort, raceProcessTeardownEvents, raceCallbacks } from "@jsenv/abort";
+import { createDetailedMessage, createLogger, createTaskLog, loggerToLevels, byteAsFileSize, ANSI, msAsDuration, msAsEllapsedTime, byteAsMemoryUsage, UNICODE, createLog, startSpinner, distributePercentages } from "@jsenv/log";
 import { urlToRelativeUrl, generateInlineContentUrl, ensurePathnameTrailingSlash, urlIsInsideOf, urlToFilename, DATA_URL, injectQueryParams, injectQueryParamsIntoSpecifier, fileSystemPathToUrl, urlToFileSystemPath, isFileSystemPath, normalizeUrl, stringifyUrlSite, setUrlFilename, moveUrl, getCallerPosition, resolveUrl, resolveDirectoryUrl, asUrlWithoutSearch, asUrlUntilPathname, urlToBasename, urlToExtension } from "@jsenv/urls";
-import { initReloadableProcess } from "@jsenv/utils/process_reload/process_reload.js";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { workerData, Worker } from "node:worker_threads";
 import { URL_META } from "@jsenv/url-meta";
-import { parseHtmlString, stringifyHtmlAst, visitHtmlAst, getHtmlNodeAttributeByName, htmlNodePosition, findNode, getHtmlNodeTextNode, removeHtmlNode, setHtmlNodeGeneratedText, removeHtmlNodeAttributeByName, parseScriptNode, injectScriptAsEarlyAsPossible, createHtmlNode, removeHtmlNodeText, assignHtmlNodeAttributes, parseLinkNode } from "@jsenv/utils/html_ast/html_ast.js";
-import { htmlAttributeSrcSet } from "@jsenv/utils/html_ast/html_attribute_src_set.js";
-import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js";
-import { applyPostCss } from "@jsenv/utils/css_ast/apply_post_css.js";
-import { postCssPluginUrlVisitor } from "@jsenv/utils/css_ast/postcss_plugin_url_visitor.js";
-import { parseJsUrls } from "@jsenv/utils/js_ast/parse_js_urls.js";
+import { parseHtmlString, stringifyHtmlAst, visitHtmlNodes, getHtmlNodeAttribute, setHtmlNodeAttributes, parseSrcSet, getHtmlNodePosition, getHtmlNodeAttributePosition, applyPostCss, postCssPluginUrlVisitor, parseJsUrls, findHtmlNode, getHtmlNodeText, removeHtmlNode, setHtmlNodeText, analyzeScriptNode, applyBabelPlugins, injectScriptNodeAsEarlyAsPossible, createHtmlNode, removeHtmlNodeText, transpileWithParcel, injectJsImport, minifyWithParcel, analyzeLinkNode } from "@jsenv/ast";
+import { createMagicSource, composeTwoSourcemaps, sourcemapConverter, SOURCEMAP, generateSourcemapFileUrl, generateSourcemapDataUrl } from "@jsenv/sourcemap";
 import { resolveImport, normalizeImportMap, composeTwoImportMaps } from "@jsenv/importmap";
 import { applyNodeEsmResolution, defaultLookupPackageScope, defaultReadPackageJson, readCustomConditionsFromProcessArgs, applyFileSystemMagicResolution, getExtensionsToTry } from "@jsenv/node-esm-resolution";
 import { statSync, realpathSync, readdirSync, readFileSync, existsSync } from "node:fs";
-import { pathToFileURL } from "node:url";
-import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js";
-import { JS_QUOTES } from "@jsenv/utils/string/js_quotes.js";
-import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js";
-import { transpileWithParcel, minifyWithParcel } from "@jsenv/utils/css_ast/parcel_css.js";
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
+import { JS_QUOTES } from "@jsenv/utils/src/string/js_quotes.js";
 import { createRequire } from "node:module";
-import { composeTwoSourcemaps } from "@jsenv/utils/sourcemap/sourcemap_composition_v3.js";
 import babelParser from "@babel/parser";
-import { findHighestVersion } from "@jsenv/utils/semantic_versioning/highest_version.js";
-import { injectImport } from "@jsenv/utils/js_ast/babel_utils.js";
-import { sortByDependencies } from "@jsenv/utils/graph/sort_by_dependencies.js";
-import { applyRollupPlugins } from "@jsenv/utils/js_ast/apply_rollup_plugins.js";
-import { sourcemapConverter } from "@jsenv/utils/sourcemap/sourcemap_converter.js";
-import { createCallbackList, createCallbackListNotifiedOnce, Abort, raceCallbacks, raceProcessTeardownEvents } from "@jsenv/abort";
-import { createSSEService } from "@jsenv/utils/event_source/sse_service.js";
-import { timeStart, fetchFileSystem, composeTwoResponses, serveDirectory, startServer, pluginCORS, jsenvAccessControlAllowedHeaders, pluginServerTiming, pluginRequestWaitingCheck, composeServices, findFreePort } from "@jsenv/server";
-import { SOURCEMAP, generateSourcemapUrl, sourcemapToBase64Url } from "@jsenv/utils/sourcemap/sourcemap_utils.js";
+import { findHighestVersion } from "@jsenv/utils/src/semantic_versioning/highest_version.js";
 import { validateResponseIntegrity } from "@jsenv/integrity";
 import { convertFileSystemErrorToResponseProperties } from "@jsenv/server/src/internal/convertFileSystemErrorToResponseProperties.js";
-import { memoizeByFirstArgument } from "@jsenv/utils/memoize/memoize_by_first_argument.js";
-import { generateCoverageJsonFile } from "@jsenv/utils/coverage/coverage_reporter_json_file.js";
-import { generateCoverageHtmlDirectory } from "@jsenv/utils/coverage/coverage_reporter_html_directory.js";
-import { generateCoverageTextLog } from "@jsenv/utils/coverage/coverage_reporter_text_log.js";
+import { memoizeByFirstArgument } from "@jsenv/utils/src/memoize/memoize_by_first_argument.js";
 import { memoryUsage } from "node:process";
 import wrapAnsi from "wrap-ansi";
 import stripAnsi from "strip-ansi";
 import cuid from "cuid";
-import { babelPluginInstrument } from "@jsenv/utils/coverage/babel_plugin_instrument.js";
-import { reportToCoverage } from "@jsenv/utils/coverage/report_to_coverage.js";
 import v8 from "node:v8";
 import { runInNewContext, Script } from "node:vm";
-import { memoize } from "@jsenv/utils/memoize/memoize.js";
-import { filterV8Coverage } from "@jsenv/utils/coverage/v8_coverage_from_directory.js";
-import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/utils/coverage/istanbul_coverage_composition.js";
-import { escapeRegexpSpecialChars } from "@jsenv/utils/string/escape_regexp_special_chars.js";
+import { memoize } from "@jsenv/utils/src/memoize/memoize.js";
+import { escapeRegexpSpecialChars } from "@jsenv/utils/src/string/escape_regexp_special_chars.js";
 import { fork } from "node:child_process";
 import { uneval } from "@jsenv/uneval";
-import { createVersionGenerator } from "@jsenv/utils/versioning/version_generator.js";
+import { createVersionGenerator } from "@jsenv/utils/src/versioning/version_generator.js";
+
+const createReloadableWorker = (workerFileUrl, options = {}) => {
+  const workerFilePath = fileURLToPath(workerFileUrl);
+  const isPrimary = !workerData || workerData.workerFilePath !== workerFilePath;
+  let worker;
+
+  const terminate = async () => {
+    if (worker) {
+      let _worker = worker;
+      worker = null;
+      const exitPromise = new Promise(resolve => {
+        _worker.once("exit", resolve);
+      });
+
+      _worker.terminate();
+
+      await exitPromise;
+    }
+  };
+
+  const load = async () => {
+    if (!isPrimary) {
+      throw new Error(`worker can be loaded from primary file only`);
+    }
+
+    worker = new Worker(workerFilePath, { ...options,
+      workerData: { ...options.workerData,
+        workerFilePath
+      }
+    });
+    worker.once("error", error => {
+      console.error(error);
+    });
+    await new Promise(resolve => {
+      worker.once("online", resolve);
+    });
+    worker.once("exit", () => {
+      worker = null;
+    });
+    return worker;
+  };
+
+  const reload = async () => {
+    await terminate();
+    await load();
+  };
+
+  return {
+    isPrimary,
+    load,
+    reload,
+    terminate
+  };
+};
 
 const parseAndTransformHtmlUrls = async (urlInfo, context) => {
   const url = urlInfo.originalUrl;
@@ -74,9 +107,14 @@ const parseAndTransformHtmlUrls = async (urlInfo, context) => {
       column,
       originalLine,
       originalColumn,
-      specifier,
-      attribute
+      node,
+      attributeName,
+      specifier
     }) => {
+      const {
+        crossorigin,
+        integrity
+      } = readFetchMetas(node);
       const isRessourceHint = ["preconnect", "dns-prefetch", "prefetch", "preload", "modulepreload"].includes(subtype);
       const [reference] = referenceUtils.found({
         type,
@@ -86,10 +124,14 @@ const parseAndTransformHtmlUrls = async (urlInfo, context) => {
         specifier,
         specifierLine: line,
         specifierColumn: column,
-        isRessourceHint
+        isRessourceHint,
+        crossorigin,
+        integrity
       });
       actions.push(async () => {
-        attribute.value = await referenceUtils.readGeneratedSpecifier(reference);
+        setHtmlNodeAttributes(node, {
+          [attributeName]: await referenceUtils.readGeneratedSpecifier(reference)
+        });
       });
     }
   });
@@ -103,6 +145,24 @@ const parseAndTransformHtmlUrls = async (urlInfo, context) => {
     content: stringifyHtmlAst(htmlAst)
   };
 };
+const crossOriginCompatibleTagNames = ["script", "link", "img", "source"];
+const integrityCompatibleTagNames = ["script", "link", "img", "source"];
+
+const readFetchMetas = node => {
+  const meta = {};
+
+  if (crossOriginCompatibleTagNames.includes(node.nodeName)) {
+    const crossorigin = getHtmlNodeAttribute(node, "crossorigin") !== undefined;
+    meta.crossorigin = crossorigin;
+  }
+
+  if (integrityCompatibleTagNames.includes(node.nodeName)) {
+    const integrity = getHtmlNodeAttribute(node, "integrity");
+    meta.integrity = integrity;
+  }
+
+  return meta;
+};
 
 const visitHtmlUrls = ({
   url,
@@ -114,18 +174,18 @@ const visitHtmlUrls = ({
     subtype,
     expectedType,
     node,
-    attribute,
+    attributeName,
     specifier
   }) => {
-    const generatedFromInlineContent = Boolean(getHtmlNodeAttributeByName(node, "generated-from-inline-content"));
+    const generatedFromInlineContent = getHtmlNodeAttribute(node, "generated-from-inline-content") !== undefined;
     let position;
 
     if (generatedFromInlineContent) {
       // when generated from inline content,
       // line, column is not "src" nor "generated-from-src" but "original-position"
-      position = htmlNodePosition.readNodePosition(node);
+      position = getHtmlNodePosition(node);
     } else {
-      position = htmlNodePosition.readAttributePosition(node, attribute.name);
+      position = getHtmlNodeAttributePosition(node, attributeName);
     }
 
     const {
@@ -141,19 +201,68 @@ const visitHtmlUrls = ({
       column,
       // originalLine, originalColumn
       specifier,
-      attribute,
-      // injected:Boolean(getHtmlNodeAttributeByName(node, "injected-by"))
-      // srcGeneratedFromInlineContent
-      ...readFetchMetas(node)
+      node,
+      attributeName
     });
   };
 
-  const visitors = {
+  const visitAttributeAsUrlSpecifier = ({
+    node,
+    attributeName,
+    ...rest
+  }) => {
+    const value = getHtmlNodeAttribute(node, attributeName);
+
+    if (value) {
+      const generatedBy = getHtmlNodeAttribute(node, "generated-by");
+
+      if (generatedBy !== undefined) {
+        // during build the importmap is inlined
+        // and shoud not be considered as a dependency anymore
+        return;
+      }
+
+      addDependency({ ...rest,
+        node,
+        attributeName,
+        specifier: attributeName === "generated-from-src" || attributeName === "generated-from-href" ? new URL(value, url).href : value
+      });
+    } else if (attributeName === "src") {
+      visitAttributeAsUrlSpecifier({ ...rest,
+        node,
+        attributeName: "generated-from-src"
+      });
+    } else if (attributeName === "href") {
+      visitAttributeAsUrlSpecifier({ ...rest,
+        node,
+        attributeName: "generated-from-href"
+      });
+    }
+  };
+
+  const visitSrcset = ({
+    type,
+    node
+  }) => {
+    const srcset = getHtmlNodeAttribute(node, "srcset");
+
+    if (srcset) {
+      const srcCandidates = parseSrcSet(srcset);
+      srcCandidates.forEach(srcCandidate => {
+        addDependency({
+          type,
+          node,
+          attributeName: "srcset",
+          specifier: srcCandidate.specifier
+        });
+      });
+    }
+  };
+
+  visitHtmlNodes(htmlAst, {
     link: node => {
-      const relAttribute = getHtmlNodeAttributeByName(node, "rel");
-      const rel = relAttribute ? relAttribute.value : undefined;
-      const typeAttribute = getHtmlNodeAttributeByName(node, "type");
-      const type = typeAttribute ? typeAttribute.value : undefined;
+      const rel = getHtmlNodeAttribute(node, "rel");
+      const type = getHtmlNodeAttribute(node, "type");
       visitAttributeAsUrlSpecifier({
         type: "link_href",
         subtype: rel,
@@ -169,15 +278,16 @@ const visitHtmlUrls = ({
     },
     // style: () => {},
     script: node => {
-      const typeAttributeNode = getHtmlNodeAttributeByName(node, "type");
+      const type = getHtmlNodeAttribute(node, "type");
+      const expectedType = {
+        "undefined": "js_classic",
+        "text/javascript": "js_classic",
+        "module": "js_module",
+        "importmap": "importmap"
+      }[type];
       visitAttributeAsUrlSpecifier({
         type: "script_src",
-        expectedType: {
-          "undefined": "js_classic",
-          "text/javascript": "js_classic",
-          "module": "js_module",
-          "importmap": "importmap"
-        }[typeAttributeNode ? typeAttributeNode.value : undefined],
+        expectedType,
         node,
         attributeName: "src"
       });
@@ -233,102 +343,9 @@ const visitHtmlUrls = ({
         attributeName: "href"
       });
     }
-  };
-
-  const visitAttributeAsUrlSpecifier = ({
-    type,
-    subtype,
-    expectedType,
-    node,
-    attributeName
-  }) => {
-    const attribute = getHtmlNodeAttributeByName(node, attributeName);
-    const value = attribute ? attribute.value : undefined;
-
-    if (value) {
-      const generatedBy = getHtmlNodeAttributeByName(node, "generated-by");
-
-      if (generatedBy) {
-        // during build the importmap is inlined
-        // and shoud not be considered as a dependency anymore
-        return;
-      }
-
-      addDependency({
-        type,
-        subtype,
-        expectedType,
-        node,
-        attribute,
-        specifier: attributeName === "generated-from-src" || attributeName === "generated-from-href" ? new URL(value, url).href : value
-      });
-    } else if (attributeName === "src") {
-      visitAttributeAsUrlSpecifier({
-        type,
-        subtype,
-        expectedType,
-        node,
-        attributeName: "generated-from-src"
-      });
-    } else if (attributeName === "href") {
-      visitAttributeAsUrlSpecifier({
-        type,
-        subtype,
-        expectedType,
-        node,
-        attributeName: "generated-from-href"
-      });
-    }
-  };
-
-  const visitSrcset = ({
-    type,
-    node
-  }) => {
-    const srcsetAttribute = getHtmlNodeAttributeByName(node, "srcset");
-    const srcset = srcsetAttribute ? srcsetAttribute.value : undefined;
-
-    if (srcset) {
-      const srcCandidates = htmlAttributeSrcSet.parse(srcset);
-      srcCandidates.forEach(srcCandidate => {
-        addDependency({
-          type,
-          node,
-          attribute: srcsetAttribute,
-          specifier: srcCandidate.specifier
-        });
-      });
-    }
-  };
-
-  visitHtmlAst(htmlAst, node => {
-    const visitor = visitors[node.nodeName];
-
-    if (visitor) {
-      visitor(node);
-    }
   });
 };
 
-const crossOriginCompatibleTagNames = ["script", "link", "img", "source"];
-const integrityCompatibleTagNames = ["script", "link", "img", "source"];
-
-const readFetchMetas = node => {
-  const meta = {};
-
-  if (crossOriginCompatibleTagNames.includes(node.nodeName)) {
-    const crossoriginAttribute = getHtmlNodeAttributeByName(node, "crossorigin");
-    meta.crossorigin = crossoriginAttribute ? crossoriginAttribute.value : undefined;
-  }
-
-  if (integrityCompatibleTagNames.includes(node.nodeName)) {
-    const integrityAttribute = getHtmlNodeAttributeByName(node, "integrity");
-    meta.integrity = integrityAttribute ? integrityAttribute.value : undefined;
-  }
-
-  return meta;
-};
-
 /*
  * https://github.com/parcel-bundler/parcel/blob/v2/packages/transformers/css/src/CSSTransformer.js
  */
@@ -704,14 +721,14 @@ const jsenvPluginImportmap = () => {
     transformUrlContent: {
       html: async (htmlUrlInfo, context) => {
         const htmlAst = parseHtmlString(htmlUrlInfo.content);
-        const importmap = findNode(htmlAst, node => {
+        const importmap = findHtmlNode(htmlAst, node => {
           if (node.nodeName !== "script") {
             return false;
           }
 
-          const typeAttribute = getHtmlNodeAttributeByName(node, "type");
+          const type = getHtmlNodeAttribute(node, "type");
 
-          if (!typeAttribute || typeAttribute.value !== "importmap") {
+          if (type === undefined || type !== "importmap") {
             return false;
           }
 
@@ -730,7 +747,7 @@ const jsenvPluginImportmap = () => {
             lineEnd,
             columnEnd,
             isOriginal
-          } = htmlNodePosition.readNodePosition(importmap, {
+          } = getHtmlNodePosition(importmap, {
             preferOriginal: true
           });
           const inlineImportmapUrl = generateInlineContentUrl({
@@ -753,9 +770,9 @@ const jsenvPluginImportmap = () => {
           await context.cook(inlineImportmapUrlInfo, {
             reference: inlineImportmapReference
           });
-          setHtmlNodeGeneratedText(importmap, {
-            generatedText: inlineImportmapUrlInfo.content,
-            generatedBy: "jsenv:importmap"
+          setHtmlNodeText(importmap, inlineImportmapUrlInfo.content);
+          setHtmlNodeAttributes(importmap, {
+            "generated-by": "jsenv:importmap"
           });
           onHtmlImportmapParsed(JSON.parse(inlineImportmapUrlInfo.content), htmlUrlInfo.url);
         };
@@ -772,11 +789,11 @@ const jsenvPluginImportmap = () => {
             reference: importmapReference
           });
           onHtmlImportmapParsed(JSON.parse(importmapUrlInfo.content), htmlUrlInfo.url);
-          removeHtmlNodeAttributeByName(importmap, "src");
-          setHtmlNodeGeneratedText(importmap, {
-            generatedText: importmapUrlInfo.content,
-            generatedBy: "jsenv:importmap",
-            generatedFromSrc: src
+          setHtmlNodeText(importmap, importmapUrlInfo.content);
+          setHtmlNodeAttributes(importmap, {
+            "src": undefined,
+            "generated-by": "jsenv:importmap",
+            "generated-from-src": src
           });
           const {
             line,
@@ -784,7 +801,7 @@ const jsenvPluginImportmap = () => {
             lineEnd,
             columnEnd,
             isOriginal
-          } = htmlNodePosition.readNodePosition(importmap, {
+          } = getHtmlNodePosition(importmap, {
             preferOriginal: true
           });
           const inlineImportmapUrl = generateInlineContentUrl({
@@ -805,16 +822,15 @@ const jsenvPluginImportmap = () => {
           });
         };
 
-        const srcAttribute = getHtmlNodeAttributeByName(importmap, "src");
-        const src = srcAttribute ? srcAttribute.value : undefined;
+        const src = getHtmlNodeAttribute(importmap, "src");
 
         if (src) {
           await handleImportmapWithSrc(importmap, src);
         } else {
-          const textNode = getHtmlNodeTextNode(importmap);
+          const htmlNodeText = getHtmlNodeText(importmap);
 
-          if (textNode) {
-            await handleInlineImportmap(importmap, textNode);
+          if (htmlNodeText) {
+            await handleInlineImportmap(importmap, htmlNodeText);
           }
         } // once this plugin knows the importmap, it will use it
         // to map imports. These import specifiers will be normalized
@@ -1063,7 +1079,7 @@ const jsenvPluginUrlVersion = () => {
 const jsenvPluginFileUrls = ({
   magicExtensions = ["inherit", ".js"],
   magicDirectoryIndex = true,
-  preservesSymlink = true,
+  preserveSymlinks = false,
   directoryReferenceAllowed = false
 }) => {
   return [{
@@ -1118,7 +1134,7 @@ const jsenvPluginFileUrls = ({
       if (foundADirectory && directoryReferenceAllowed) {
         reference.data.foundADirectory = true;
         const directoryFacadeUrl = urlObject.href;
-        const directoryUrlRaw = preservesSymlink ? directoryFacadeUrl : resolveSymlink(directoryFacadeUrl);
+        const directoryUrlRaw = preserveSymlinks ? directoryFacadeUrl : resolveSymlink(directoryFacadeUrl);
         const directoryUrl = `${directoryUrlRaw}${search}${hash}`;
         return directoryUrl;
       }
@@ -1137,7 +1153,7 @@ const jsenvPluginFileUrls = ({
 
       reference.data.foundADirectory = filesystemResolution.isDirectory;
       const fileFacadeUrl = filesystemResolution.url;
-      const fileUrlRaw = preservesSymlink ? fileFacadeUrl : resolveSymlink(fileFacadeUrl);
+      const fileUrlRaw = preserveSymlinks ? fileFacadeUrl : resolveSymlink(fileFacadeUrl);
       const fileUrl = `${fileUrlRaw}${search}${hash}`;
       return fileUrl;
     }
@@ -1257,13 +1273,9 @@ const jsenvPluginHtmlInlineContent = ({
         const actions = [];
 
         const handleInlineStyle = node => {
-          if (node.nodeName !== "style") {
-            return;
-          }
+          const htmlNodeText = getHtmlNodeText(node);
 
-          const textNode = getHtmlNodeTextNode(node);
-
-          if (!textNode) {
+          if (!htmlNodeText) {
             return;
           }
 
@@ -1274,7 +1286,7 @@ const jsenvPluginHtmlInlineContent = ({
               lineEnd,
               columnEnd,
               isOriginal
-            } = htmlNodePosition.readNodePosition(node, {
+            } = getHtmlNodePosition(node, {
               preferOriginal: true
             });
             const inlineStyleUrl = generateInlineContentUrl({
@@ -1296,55 +1308,47 @@ const jsenvPluginHtmlInlineContent = ({
               specifierColumn: column,
               specifier: inlineStyleUrl,
               contentType: "text/css",
-              content: textNode.value
+              content: htmlNodeText
             });
             await context.cook(inlineStyleUrlInfo, {
               reference: inlineStyleReference
             });
-            setHtmlNodeGeneratedText(node, {
-              generatedText: inlineStyleUrlInfo.content,
-              generatedBy: "jsenv:html_inline_content"
+            setHtmlNodeText(node, inlineStyleUrlInfo.content);
+            setHtmlNodeAttributes(node, {
+              "generated-by": "jsenv:html_inline_content"
             });
           });
         };
 
         const handleInlineScript = node => {
-          if (node.nodeName !== "script") {
-            return;
-          }
+          const htmlNodeText = getHtmlNodeText(node);
 
-          const textNode = getHtmlNodeTextNode(node);
-
-          if (!textNode) {
+          if (!htmlNodeText) {
             return;
           } // If the inline script was already handled by an other plugin, ignore it
           // - we want to preserve inline scripts generated by html supervisor during dev
           // - we want to avoid cooking twice a script during build
 
 
-          const generatedBy = getHtmlNodeAttributeByName(node, "generated-by");
+          const generatedBy = getHtmlNodeAttribute(node, "generated-by");
 
-          if (generatedBy) {
-            if (generatedBy.value === "jsenv:as_js_classic_html") {
-              if (!analyzeConvertedScripts) {
-                return;
-              }
-            }
+          if (generatedBy === "jsenv:as_js_classic_html" && !analyzeConvertedScripts) {
+            return;
+          }
 
-            if (generatedBy.value === "jsenv:html_supervisor") {
-              return;
-            }
+          if (generatedBy === "jsenv:html_supervisor") {
+            return;
           }
 
           actions.push(async () => {
-            const scriptCategory = parseScriptNode(node);
+            const scriptCategory = analyzeScriptNode(node);
             const {
               line,
               column,
               lineEnd,
               columnEnd,
               isOriginal
-            } = htmlNodePosition.readNodePosition(node, {
+            } = getHtmlNodePosition(node, {
               preferOriginal: true
             }); // from MDN about [type] attribute:
             // "Any other value: The embedded content is treated as a data block
@@ -1380,21 +1384,25 @@ const jsenvPluginHtmlInlineContent = ({
               isOriginalPosition: isOriginal,
               specifier: inlineScriptUrl,
               contentType,
-              content: textNode.value
+              content: htmlNodeText
             });
             await context.cook(inlineScriptUrlInfo, {
               reference: inlineScriptReference
             });
-            setHtmlNodeGeneratedText(node, {
-              generatedText: inlineScriptUrlInfo.content,
-              generatedBy: "jsenv:html_inline_content"
+            setHtmlNodeText(node, inlineScriptUrlInfo.content);
+            setHtmlNodeAttributes(node, {
+              "generated-by": "jsenv:html_inline_content"
             });
           });
         };
 
-        visitHtmlAst(htmlAst, node => {
-          handleInlineStyle(node);
-          handleInlineScript(node);
+        visitHtmlNodes(htmlAst, {
+          style: node => {
+            handleInlineStyle(node);
+          },
+          script: node => {
+            handleInlineScript(node);
+          }
         });
 
         if (actions.length === 0) {
@@ -1934,15 +1942,15 @@ const jsenvPluginHtmlSupervisor = ({
         const htmlAst = parseHtmlString(content);
         const scriptsToSupervise = [];
 
-        const handleInlineScript = (node, textNode) => {
-          const scriptCategory = parseScriptNode(node);
+        const handleInlineScript = (node, htmlNodeText) => {
+          const scriptCategory = analyzeScriptNode(node);
           const {
             line,
             column,
             lineEnd,
             columnEnd,
             isOriginal
-          } = htmlNodePosition.readNodePosition(node, {
+          } = getHtmlNodePosition(node, {
             preferOriginal: true
           });
           let inlineScriptUrl = generateInlineContentUrl({
@@ -1964,7 +1972,7 @@ const jsenvPluginHtmlSupervisor = ({
             specifierColumn: column,
             specifier: inlineScriptUrl,
             contentType: "text/javascript",
-            content: textNode.value
+            content: htmlNodeText
           });
           removeHtmlNodeText(node);
           scriptsToSupervise.push({
@@ -1975,21 +1983,19 @@ const jsenvPluginHtmlSupervisor = ({
           });
         };
 
-        const handleScriptWithSrc = (node, srcAttribute) => {
-          const scriptCategory = parseScriptNode(node);
-          const integrityAttribute = getHtmlNodeAttributeByName(node, "integrity");
-          const integrity = integrityAttribute ? integrityAttribute.value : undefined;
-          const crossoriginAttribute = getHtmlNodeAttributeByName(node, "crossorigin");
-          const crossorigin = crossoriginAttribute ? crossoriginAttribute.value : undefined;
-          const deferAttribute = getHtmlNodeAttributeByName(node, "crossorigin");
-          const defer = deferAttribute ? deferAttribute.value : undefined;
-          const asyncAttribute = getHtmlNodeAttributeByName(node, "crossorigin");
-          const async = asyncAttribute ? asyncAttribute.value : undefined;
-          removeHtmlNodeAttributeByName(node, "src");
+        const handleScriptWithSrc = (node, src) => {
+          const scriptCategory = analyzeScriptNode(node);
+          const integrity = getHtmlNodeAttribute(node, "integrity");
+          const crossorigin = getHtmlNodeAttribute(node, "crossorigin") !== undefined;
+          const defer = getHtmlNodeAttribute(node, "defer") !== undefined;
+          const async = getHtmlNodeAttribute(node, "async") !== undefined;
+          setHtmlNodeAttributes(node, {
+            src: undefined
+          });
           scriptsToSupervise.push({
             node,
             type: scriptCategory,
-            src: srcAttribute.value,
+            src,
             defer,
             async,
             integrity,
@@ -1997,41 +2003,39 @@ const jsenvPluginHtmlSupervisor = ({
           });
         };
 
-        visitHtmlAst(htmlAst, node => {
-          if (node.nodeName !== "script") {
-            return;
-          }
-
-          const scriptCategory = parseScriptNode(node);
+        visitHtmlNodes(htmlAst, {
+          script: node => {
+            const scriptCategory = analyzeScriptNode(node);
 
-          if (scriptCategory !== "classic" && scriptCategory !== "module") {
-            return;
-          }
+            if (scriptCategory !== "classic" && scriptCategory !== "module") {
+              return;
+            }
 
-          const injectedByAttribute = getHtmlNodeAttributeByName(node, "injected-by");
+            const injectedBy = getHtmlNodeAttribute(node, "injected-by");
 
-          if (injectedByAttribute) {
-            return;
-          }
+            if (injectedBy !== undefined) {
+              return;
+            }
 
-          const noHtmlSupervisor = getHtmlNodeAttributeByName(node, "no-html-supervisor");
+            const noHtmlSupervisor = getHtmlNodeAttribute(node, "no-html-supervisor");
 
-          if (noHtmlSupervisor) {
-            return;
-          }
+            if (noHtmlSupervisor !== undefined) {
+              return;
+            }
 
-          const textNode = getHtmlNodeTextNode(node);
+            const htmlNodeText = getHtmlNodeText(node);
 
-          if (textNode) {
-            handleInlineScript(node, textNode);
-            return;
-          }
+            if (htmlNodeText) {
+              handleInlineScript(node, htmlNodeText);
+              return;
+            }
 
-          const srcAttribute = getHtmlNodeAttributeByName(node, "src");
+            const src = getHtmlNodeAttribute(node, "src");
 
-          if (srcAttribute) {
-            handleScriptWithSrc(node, srcAttribute);
-            return;
+            if (src) {
+              handleScriptWithSrc(node, src);
+              return;
+            }
           }
         });
         const [htmlSupervisorInstallerFileReference] = referenceUtils.inject({
@@ -2039,7 +2043,7 @@ const jsenvPluginHtmlSupervisor = ({
           expectedType: "js_module",
           specifier: htmlSupervisorInstallerFileUrl
         });
-        injectScriptAsEarlyAsPossible(htmlAst, createHtmlNode({
+        injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
           "tagName": "script",
           "type": "module",
           "textContent": `
@@ -2055,7 +2059,7 @@ const jsenvPluginHtmlSupervisor = ({
           expectedType: "js_classic",
           specifier: htmlSupervisorSetupFileUrl
         });
-        injectScriptAsEarlyAsPossible(htmlAst, createHtmlNode({
+        injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
           "tagName": "script",
           "src": htmlSupervisorSetupFileReference.generatedSpecifier,
           "injected-by": "jsenv:html_supervisor"
@@ -2070,20 +2074,24 @@ const jsenvPluginHtmlSupervisor = ({
           integrity,
           crossorigin
         }) => {
-          setHtmlNodeGeneratedText(node, {
-            generatedText: generateCodeToSuperviseScript({
-              type,
-              src,
-              isInline,
-              defer,
-              async,
-              integrity,
-              crossorigin,
-              htmlSupervisorInstallerSpecifier: htmlSupervisorInstallerFileReference.generatedSpecifier
-            }),
-            generatedBy: "jsenv:html_supervisor",
-            generatedFromSrc: src,
-            generatedFromInlineContent: isInline
+          setHtmlNodeText(node, generateCodeToSuperviseScript({
+            type,
+            src,
+            isInline,
+            defer,
+            async,
+            integrity,
+            crossorigin,
+            htmlSupervisorInstallerSpecifier: htmlSupervisorInstallerFileReference.generatedSpecifier
+          }));
+          setHtmlNodeAttributes(node, {
+            "generated-by": "jsenv:html_supervisor",
+            ...(src ? {
+              "generated-from-src": src
+            } : {}),
+            ...(isInline ? {
+              "generated-from-inline-content": ""
+            } : {})
           });
         });
         const htmlModified = stringifyHtmlAst(htmlAst);
@@ -2698,12 +2706,7 @@ const jsenvPluginAsJsClassicHtml = ({
         const classicScriptNodes = [];
 
         const visitLinkNodes = node => {
-          if (node.nodeName !== "link") {
-            return;
-          }
-
-          const relAttribute = getHtmlNodeAttributeByName(node, "rel");
-          const rel = relAttribute ? relAttribute.value : undefined;
+          const rel = getHtmlNodeAttribute(node, "rel");
 
           if (rel === "modulepreload") {
             modulePreloadNodes.push(node);
@@ -2711,8 +2714,7 @@ const jsenvPluginAsJsClassicHtml = ({
           }
 
           if (rel === "preload") {
-            const asAttribute = getHtmlNodeAttributeByName(node, "as");
-            const asValue = asAttribute ? asAttribute.value : undefined;
+            const asValue = getHtmlNodeAttribute(node, "as");
 
             if (asValue === "script") {
               preloadAsScriptNodes.push(node);
@@ -2723,12 +2725,7 @@ const jsenvPluginAsJsClassicHtml = ({
         };
 
         const visitScriptNodes = node => {
-          if (node.nodeName !== "script") {
-            return;
-          }
-
-          const typeAttribute = getHtmlNodeAttributeByName(node, "type");
-          const type = typeAttribute ? typeAttribute.value : undefined;
+          const type = getHtmlNodeAttribute(node, "type");
 
           if (type === "module") {
             moduleScriptNodes.push(node);
@@ -2741,9 +2738,13 @@ const jsenvPluginAsJsClassicHtml = ({
           }
         };
 
-        visitHtmlAst(htmlAst, node => {
-          visitLinkNodes(node);
-          visitScriptNodes(node);
+        visitHtmlNodes(htmlAst, {
+          link: node => {
+            visitLinkNodes(node);
+          },
+          script: node => {
+            visitScriptNodes(node);
+          }
         });
         const actions = [];
         const jsModuleUrls = [];
@@ -2785,10 +2786,10 @@ const jsenvPluginAsJsClassicHtml = ({
         };
 
         classicScriptNodes.forEach(classicScriptNode => {
-          const srcAttribute = getHtmlNodeAttributeByName(classicScriptNode, "src");
+          const src = getHtmlNodeAttribute(classicScriptNode, "src");
 
-          if (srcAttribute) {
-            const reference = urlInfo.references.find(ref => ref.generatedSpecifier === srcAttribute.value && ref.type === "script_src");
+          if (src !== undefined) {
+            const reference = urlInfo.references.find(ref => ref.generatedSpecifier === src && ref.type === "script_src");
             const urlObject = new URL(reference.url);
 
             if (urlObject.searchParams.has("as_js_classic")) {
@@ -2807,10 +2808,10 @@ const jsenvPluginAsJsClassicHtml = ({
           }
         });
         moduleScriptNodes.forEach(moduleScriptNode => {
-          const srcAttribute = getHtmlNodeAttributeByName(moduleScriptNode, "src");
+          const src = getHtmlNodeAttribute(moduleScriptNode, "src");
 
-          if (srcAttribute) {
-            const reference = urlInfo.references.find(ref => ref.generatedSpecifier === srcAttribute.value && ref.type === "script_src" && ref.expectedType === "js_module");
+          if (src !== undefined) {
+            const reference = urlInfo.references.find(ref => ref.generatedSpecifier === src && ref.type === "script_src" && ref.expectedType === "js_module");
             jsModuleUrls.push(reference.url);
 
             if (shouldTransformScriptTypeModule) {
@@ -2818,8 +2819,10 @@ const jsenvPluginAsJsClassicHtml = ({
                 const [newReference] = await getReferenceAsJsClassic(reference, {
                   cookIt: true
                 });
-                removeHtmlNodeAttributeByName(moduleScriptNode, "type");
-                srcAttribute.value = newReference.generatedSpecifier;
+                setHtmlNodeAttributes(moduleScriptNode, {
+                  type: undefined,
+                  src: newReference.generatedSpecifier
+                });
               });
             }
 
@@ -2827,7 +2830,7 @@ const jsenvPluginAsJsClassicHtml = ({
           }
 
           if (shouldTransformScriptTypeModule) {
-            const textNode = getHtmlNodeTextNode(moduleScriptNode);
+            const htmlNodeText = getHtmlNodeText(moduleScriptNode);
             actions.push(async () => {
               const {
                 line,
@@ -2835,7 +2838,7 @@ const jsenvPluginAsJsClassicHtml = ({
                 lineEnd,
                 columnEnd,
                 isOriginal
-              } = htmlNodePosition.readNodePosition(moduleScriptNode, {
+              } = getHtmlNodePosition(moduleScriptNode, {
                 preferOriginal: true
               });
               let inlineScriptUrl = generateInlineContentUrl({
@@ -2858,15 +2861,15 @@ const jsenvPluginAsJsClassicHtml = ({
                 specifierColumn: column,
                 specifier: inlineScriptUrl,
                 contentType: "text/javascript",
-                content: textNode.value
+                content: htmlNodeText
               });
               const [, newUrlInfo] = await getReferenceAsJsClassic(inlineReference, {
                 cookIt: true
               });
-              removeHtmlNodeAttributeByName(moduleScriptNode, "type");
-              setHtmlNodeGeneratedText(moduleScriptNode, {
-                generatedText: newUrlInfo.content,
-                generatedBy: "jsenv:as_js_classic_html"
+              setHtmlNodeText(moduleScriptNode, newUrlInfo.content);
+              setHtmlNodeAttributes(moduleScriptNode, {
+                "type": undefined,
+                "generated-by": "jsenv:as_js_classic_html"
               });
             });
           }
@@ -2874,8 +2877,7 @@ const jsenvPluginAsJsClassicHtml = ({
 
         if (shouldTransformScriptTypeModule) {
           preloadAsScriptNodes.forEach(preloadAsScriptNode => {
-            const hrefAttribute = getHtmlNodeAttributeByName(preloadAsScriptNode, "href");
-            const href = hrefAttribute.value;
+            const href = getHtmlNodeAttribute(preloadAsScriptNode, "href");
             const reference = urlInfo.references.find(ref => ref.generatedSpecifier === href && ref.type === "link_href" && ref.expectedType === undefined);
             const expectedScriptType = jsModuleUrls.includes(reference.url) ? "module" : "classic";
 
@@ -2890,16 +2892,15 @@ const jsenvPluginAsJsClassicHtml = ({
                   [newReference] = await getReferenceAsJsClassic(reference);
                 }
 
-                assignHtmlNodeAttributes(preloadAsScriptNode, {
-                  href: newReference.generatedSpecifier
+                setHtmlNodeAttributes(preloadAsScriptNode, {
+                  href: newReference.generatedSpecifier,
+                  crossorigin: undefined
                 });
-                removeHtmlNodeAttributeByName(preloadAsScriptNode, "crossorigin");
               });
             }
           });
           modulePreloadNodes.forEach(modulePreloadNode => {
-            const hrefAttribute = getHtmlNodeAttributeByName(modulePreloadNode, "href");
-            const href = hrefAttribute.value;
+            const href = getHtmlNodeAttribute(modulePreloadNode, "href");
             const reference = urlInfo.references.find(ref => ref.generatedSpecifier === href && ref.type === "link_href" && ref.expectedType === "js_module");
             actions.push(async () => {
               let newReference;
@@ -2910,7 +2911,7 @@ const jsenvPluginAsJsClassicHtml = ({
                 [newReference] = await getReferenceAsJsClassic(reference);
               }
 
-              assignHtmlNodeAttributes(modulePreloadNode, {
+              setHtmlNodeAttributes(modulePreloadNode, {
                 rel: "preload",
                 as: "script",
                 href: newReference.generatedSpecifier
@@ -2934,7 +2935,7 @@ const jsenvPluginAsJsClassicHtml = ({
               expectedType: "js_classic",
               specifier: systemJsClientFileUrl
             });
-            injectScriptAsEarlyAsPossible(htmlAst, createHtmlNode({
+            injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
               "tagName": "script",
               "src": systemJsReference.generatedSpecifier,
               "injected-by": "jsenv:as_js_classic_html"
@@ -4013,7 +4014,7 @@ const babelPluginBabelHelpersAsJsenvImports = (babel, {
         }
 
         const babelHelperImportSpecifier = getBabelHelperFileUrl(name);
-        const helper = injectImport({
+        const helper = injectJsImport({
           programPath: file.path,
           from: getImportSpecifier(babelHelperImportSpecifier),
           nameHint: `_${name}`,
@@ -4116,7 +4117,7 @@ const babelPluginNewStylesheetAsJsenvImport = (babel, {
         });
 
         if (usesNewStylesheet) {
-          injectImport({
+          injectJsImport({
             programPath,
             from: getImportSpecifier(newStylesheetClientFileUrl),
             sideEffect: true
@@ -4181,7 +4182,7 @@ const babelPluginGlobalThisAsJsenvImport = (babel, {
         } = path; // we should do this once, tree shaking will remote it but still
 
         if (node.name === "globalThis") {
-          injectImport({
+          injectJsImport({
             programPath: path.scope.getProgramParent().path,
             from: getImportSpecifier(globalThisClientFileUrl),
             sideEffect: true
@@ -4215,7 +4216,7 @@ const babelPluginRegeneratorRuntimeAsJsenvImport = (babel, {
         } = path;
 
         if (node.name === "regeneratorRuntime") {
-          injectImport({
+          injectJsImport({
             programPath: path.scope.getProgramParent().path,
             from: getImportSpecifier(regeneratorRuntimeClientFileUrl),
             sideEffect: true
@@ -4459,6 +4460,39 @@ const jsenvPluginNodeRuntime = ({
   };
 };
 
+const sortByDependencies = nodes => {
+  const visited = [];
+  const sorted = [];
+  const circular = [];
+
+  const visit = url => {
+    const isSorted = sorted.includes(url);
+
+    if (isSorted) {
+      return;
+    }
+
+    const isVisited = visited.includes(url);
+
+    if (isVisited) {
+      circular.push(url);
+      sorted.push(url);
+    } else {
+      visited.push(url);
+      nodes[url].dependencies.forEach(dependencyUrl => {
+        visit(dependencyUrl);
+      });
+      sorted.push(url);
+    }
+  };
+
+  Object.keys(nodes).forEach(url => {
+    visit(url);
+  });
+  sorted.circular = circular;
+  return sorted;
+};
+
 /*
  * Each @import found in css is replaced by the file content
  * - There is no need to worry about urls (such as background-image: url())
@@ -4676,85 +4710,20 @@ const bundleJsModule = async ({
   });
   return jsModuleBundleUrlInfos;
 };
-const buildWithRollup = async ({
-  signal,
-  logger,
+
+const rollupPluginJsenv = ({
+  // logger,
   rootDirectoryUrl,
   buildDirectoryUrl,
   urlGraph,
   jsModuleUrlInfos,
-  runtimeCompat,
   sourcemaps,
   include,
-  babelHelpersChunk
+  babelHelpersChunk,
+  resultRef
 }) => {
-  const resultRef = {
-    current: null
-  };
-
-  try {
-    await applyRollupPlugins({
-      rollupPlugins: [rollupPluginJsenv({
-        signal,
-        logger,
-        rootDirectoryUrl,
-        buildDirectoryUrl,
-        urlGraph,
-        jsModuleUrlInfos,
-        runtimeCompat,
-        sourcemaps,
-        include,
-        babelHelpersChunk,
-        resultRef
-      })],
-      inputOptions: {
-        input: [],
-        onwarn: warning => {
-          if (warning.code === "CIRCULAR_DEPENDENCY") {
-            return;
-          }
-
-          if (warning.code === "THIS_IS_UNDEFINED" && pathToFileURL(warning.id).href === globalThisClientFileUrl) {
-            return;
-          }
-
-          if (warning.code === "EVAL") {
-            // ideally we should disable only for jsenv files
-            return;
-          }
-
-          logger.warn(String(warning));
-        }
-      }
-    });
-    return resultRef.current;
-  } catch (e) {
-    if (e.code === "MISSING_EXPORT") {
-      const detailedMessage = createDetailedMessage(e.message, {
-        frame: e.frame
-      });
-      throw new Error(detailedMessage, {
-        cause: e
-      });
-    }
-
-    throw e;
-  }
-};
-
-const rollupPluginJsenv = ({
-  // logger,
-  rootDirectoryUrl,
-  buildDirectoryUrl,
-  urlGraph,
-  jsModuleUrlInfos,
-  sourcemaps,
-  include,
-  babelHelpersChunk,
-  resultRef
-}) => {
-  let _rollupEmitFile = () => {
-    throw new Error("not implemented");
+  let _rollupEmitFile = () => {
+    throw new Error("not implemented");
   };
 
   const emitChunk = chunk => {
@@ -4966,6 +4935,91 @@ const rollupPluginJsenv = ({
   };
 };
 
+const buildWithRollup = async ({
+  signal,
+  logger,
+  rootDirectoryUrl,
+  buildDirectoryUrl,
+  urlGraph,
+  jsModuleUrlInfos,
+  runtimeCompat,
+  sourcemaps,
+  include,
+  babelHelpersChunk
+}) => {
+  const resultRef = {
+    current: null
+  };
+
+  try {
+    await applyRollupPlugins({
+      rollupPlugins: [rollupPluginJsenv({
+        signal,
+        logger,
+        rootDirectoryUrl,
+        buildDirectoryUrl,
+        urlGraph,
+        jsModuleUrlInfos,
+        runtimeCompat,
+        sourcemaps,
+        include,
+        babelHelpersChunk,
+        resultRef
+      })],
+      inputOptions: {
+        input: [],
+        onwarn: warning => {
+          if (warning.code === "CIRCULAR_DEPENDENCY") {
+            return;
+          }
+
+          if (warning.code === "THIS_IS_UNDEFINED" && pathToFileURL(warning.id).href === globalThisClientFileUrl) {
+            return;
+          }
+
+          if (warning.code === "EVAL") {
+            // ideally we should disable only for jsenv files
+            return;
+          }
+
+          logger.warn(String(warning));
+        }
+      }
+    });
+    return resultRef.current;
+  } catch (e) {
+    if (e.code === "MISSING_EXPORT") {
+      const detailedMessage = createDetailedMessage(e.message, {
+        frame: e.frame
+      });
+      throw new Error(detailedMessage, {
+        cause: e
+      });
+    }
+
+    throw e;
+  }
+};
+
+const applyRollupPlugins = async ({
+  rollupPlugins,
+  inputOptions = {},
+  outputOptions = {}
+}) => {
+  const {
+    rollup
+  } = await import("rollup");
+  const {
+    importAssertions
+  } = await import("acorn-import-assertions");
+  const rollupReturnValue = await rollup({ ...inputOptions,
+    plugins: rollupPlugins,
+    acornInjectPlugins: [importAssertions, ...(inputOptions.acornInjectPlugins || [])]
+  });
+  const rollupOutputArray = await rollupReturnValue.generate(outputOptions);
+  return rollupOutputArray;
+};
+
 const willBeInsideJsDirectory = ({
   chunkInfo,
   fileUrlConverter,
@@ -5208,8 +5262,7 @@ const collectHotDataFromHtmlAst = htmlAst => {
     attributeName,
     hotAccepted
   }) => {
-    const attribute = getHtmlNodeAttributeByName(node, attributeName);
-    const value = attribute ? attribute.value : undefined;
+    const value = getHtmlNodeAttribute(node, attributeName);
 
     if (value) {
       onSpecifier({
@@ -5256,11 +5309,10 @@ const collectHotDataFromHtmlAst = htmlAst => {
     }
 
     if (nodeNamesWithSrcset.includes(node.nodeName)) {
-      const srcsetAttribute = getHtmlNodeAttributeByName(node, "srcset");
-      const srcset = srcsetAttribute ? srcsetAttribute.value : undefined;
+      const srcset = getHtmlNodeAttribute(node, "srcset");
 
       if (srcset) {
-        const srcCandidates = htmlAttributeSrcSet.parse(srcset);
+        const srcCandidates = parseSrcSet(srcset);
         srcCandidates.forEach(srcCandidate => {
           onSpecifier({
             node,
@@ -5301,15 +5353,15 @@ const nodeNamesWithSrcset = ["img", "source"];
 
 const getNodeContext = node => {
   const context = {};
-  const hotAcceptAttribute = getHtmlNodeAttributeByName(node, "hot-accept");
+  const hotAccept = getHtmlNodeAttribute(node, "hot-accept");
 
-  if (hotAcceptAttribute) {
+  if (hotAccept !== undefined) {
     context.hotAccepted = true;
   }
 
-  const hotDeclineAttribute = getHtmlNodeAttributeByName(node, "hot-decline");
+  const hotDecline = getHtmlNodeAttribute(node, "hot-decline");
 
-  if (hotDeclineAttribute) {
+  if (hotDecline !== undefined) {
     context.hotAccepted = false;
   }
 
@@ -5322,7 +5374,7 @@ const htmlNodeCanHotReload = node => {
       isStylesheet,
       isRessourceHint,
       rel
-    } = parseLinkNode(node);
+    } = analyzeLinkNode(node);
 
     if (isStylesheet) {
       // stylesheets can be hot replaced by default
@@ -5622,7 +5674,7 @@ const jsenvPluginDevSSEClient = () => {
           expectedType: "js_module",
           specifier: eventSourceClientFileUrl
         });
-        injectScriptAsEarlyAsPossible(htmlAst, createHtmlNode({
+        injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
           "tagName": "script",
           "type": "module",
           "src": eventSourceClientReference.generatedSpecifier,
@@ -5637,6 +5689,60 @@ 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,
@@ -6608,13 +6714,27 @@ const createUrlInfoTransformer = ({
   const sourcemapsEnabled = sourcemaps === "inline" || sourcemaps === "file" || sourcemaps === "programmatic";
 
   const normalizeSourcemap = (urlInfo, sourcemap) => {
+    let {
+      sources
+    } = sourcemap;
+
+    if (sources) {
+      sources = sources.map(source => {
+        if (source && isFileSystemPath(source)) {
+          return String(pathToFileURL(source));
+        }
+
+        return source;
+      });
+    }
+
     const wantSourcesContent = // for inline content (<script> insdide html)
     // chrome won't be able to fetch the file as it does not exists
     // so sourcemap must contain sources
-    sourcemapsSourcesContent || urlInfo.isInline || sourcemap.sources && sourcemap.sources.some(source => !source || !source.startsWith("file:"));
+    sourcemapsSourcesContent || urlInfo.isInline || sources && sources.some(source => !source || !source.startsWith("file:"));
 
-    if (sourcemap.sources && sourcemap.sources.length > 1) {
-      sourcemap.sources = sourcemap.sources.map(source => new URL(source, urlInfo.originalUrl).href);
+    if (sources && sources.length > 1) {
+      sourcemap.sources = sources.map(source => new URL(source, urlInfo.originalUrl).href);
 
       if (!wantSourcesContent) {
         sourcemap.sourcesContent = undefined;
@@ -6650,7 +6770,7 @@ const createUrlInfoTransformer = ({
     //   but otherwise it's generatedUrl to be inside .jsenv/ directory
 
 
-    urlInfo.sourcemapGeneratedUrl = generateSourcemapUrl(urlInfo.generatedUrl);
+    urlInfo.sourcemapGeneratedUrl = generateSourcemapFileUrl(urlInfo.generatedUrl);
     const [sourcemapReference, sourcemapUrlInfo] = injectSourcemapPlaceholder({
       urlInfo,
       specifier: urlInfo.sourcemapGeneratedUrl
@@ -6756,7 +6876,7 @@ const createUrlInfoTransformer = ({
       sourcemapUrlInfo.content = JSON.stringify(sourcemap, null, "  ");
 
       if (sourcemaps === "inline") {
-        sourcemapReference.generatedSpecifier = sourcemapToBase64Url(sourcemap);
+        sourcemapReference.generatedSpecifier = generateSourcemapDataUrl(sourcemap);
       }
 
       if (sourcemaps === "file" || sourcemaps === "inline") {
@@ -7661,6 +7781,8 @@ const memoizeCook = cook => {
 const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
   if (reference.shouldHandle) {
     urlInfo.shouldHandle = true;
+  } else {
+    urlInfo.shouldHandle = false;
   }
 
   urlInfo.originalUrl = urlInfo.originalUrl || reference.url;
@@ -8295,7 +8417,7 @@ const jsenvPluginExplorer = ({
 
 const startDevServer = async ({
   signal = new AbortController().signal,
-  handleSIGINT,
+  handleSIGINT = true,
   logLevel = "info",
   omegaServerLogLevel = "warn",
   port = 3456,
@@ -8315,9 +8437,9 @@ const startDevServer = async ({
   devServerMainFile = getCallerPosition().url,
   // force disable server autoreload when this code is executed:
   // - inside a forked child process
-  // - inside a worker thread
-  // (because node cluster won't work)
-  devServerAutoreload = typeof process.send !== "function" && !parentPort && !process.env.VSCODE_INSPECTOR_OPTIONS,
+  // - debugged by vscode
+  // otherwise we get net:ERR_CONNECTION_REFUSED
+  devServerAutoreload = typeof process.send !== "function" && !process.env.VSCODE_INSPECTOR_OPTIONS,
   clientFiles = {
     "./src/": true,
     "./test/": true
@@ -8349,198 +8471,882 @@ const startDevServer = async ({
     test: {
       "./test/**/*.test.html": true
     }
-  },
-  // toolbar = false,
-  writeGeneratedFiles = true
+  },
+  // toolbar = false,
+  writeGeneratedFiles = true
+}) => {
+  const logger = createLogger({
+    logLevel
+  });
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+
+  if (handleSIGINT) {
+    operation.addAbortSource(abort => {
+      return raceProcessTeardownEvents({
+        SIGINT: true
+      }, abort);
+    });
+  }
+
+  if (port === 0) {
+    port = await findFreePort(port, {
+      signal: operation.signal
+    });
+  }
+
+  const reloadableWorker = createReloadableWorker(devServerMainFile);
+
+  if (devServerAutoreload && reloadableWorker.isPrimary) {
+    const devServerFileChangeCallback = ({
+      relativeUrl,
+      event
+    }) => {
+      const url = new URL(relativeUrl, rootDirectoryUrl).href;
+      logger.info(`file ${event} ${url} -> restarting server...`);
+      reloadableWorker.reload();
+    };
+
+    const stopWatchingDevServerFiles = registerDirectoryLifecycle(rootDirectoryUrl, {
+      watchPatterns: {
+        [devServerMainFile]: true,
+        ...devServerFiles
+      },
+      cooldownBetweenFileEvents,
+      keepProcessAlive: false,
+      recursive: true,
+      added: ({
+        relativeUrl
+      }) => {
+        devServerFileChangeCallback({
+          relativeUrl,
+          event: "added"
+        });
+      },
+      updated: ({
+        relativeUrl
+      }) => {
+        devServerFileChangeCallback({
+          relativeUrl,
+          event: "modified"
+        });
+      },
+      removed: ({
+        relativeUrl
+      }) => {
+        devServerFileChangeCallback({
+          relativeUrl,
+          event: "removed"
+        });
+      }
+    });
+    operation.addAbortCallback(() => {
+      stopWatchingDevServerFiles();
+      reloadableWorker.terminate();
+    });
+    const worker = await reloadableWorker.load();
+
+    if (!keepProcessAlive) {
+      worker.unref();
+    }
+
+    return {
+      origin: `${protocol}://127.0.0.1:${port}`,
+      stop: () => {
+        stopWatchingDevServerFiles();
+        reloadableWorker.terminate();
+      }
+    };
+  }
+
+  const startDevServerTask = createTaskLog("start dev server", {
+    disabled: !loggerToLevels(logger).info
+  });
+  const clientFileChangeCallbackList = [];
+  const clientFilesPruneCallbackList = [];
+
+  const clientFileChangeCallback = ({
+    relativeUrl,
+    event
+  }) => {
+    const url = new URL(relativeUrl, rootDirectoryUrl).href;
+    clientFileChangeCallbackList.forEach(callback => {
+      callback({
+        url,
+        event
+      });
+    });
+  };
+
+  const stopWatchingClientFiles = registerDirectoryLifecycle(rootDirectoryUrl, {
+    watchPatterns: clientFiles,
+    cooldownBetweenFileEvents,
+    keepProcessAlive: false,
+    recursive: true,
+    added: ({
+      relativeUrl
+    }) => {
+      clientFileChangeCallback({
+        event: "added",
+        relativeUrl
+      });
+    },
+    updated: ({
+      relativeUrl
+    }) => {
+      clientFileChangeCallback({
+        event: "modified",
+        relativeUrl
+      });
+    },
+    removed: ({
+      relativeUrl
+    }) => {
+      clientFileChangeCallback({
+        event: "removed",
+        relativeUrl
+      });
+    }
+  });
+  const urlGraph = createUrlGraph({
+    clientFileChangeCallbackList,
+    clientFilesPruneCallbackList
+  });
+  const kitchen = createKitchen({
+    signal,
+    logger,
+    rootDirectoryUrl,
+    urlGraph,
+    scenario: "dev",
+    runtimeCompat,
+    sourcemaps,
+    writeGeneratedFiles,
+    plugins: [...plugins, ...getCorePlugins({
+      rootDirectoryUrl,
+      urlGraph,
+      scenario: "dev",
+      runtimeCompat,
+      urlAnalysis,
+      htmlSupervisor,
+      nodeEsmResolution,
+      fileSystemMagicResolution,
+      transpilation,
+      clientAutoreload,
+      clientFileChangeCallbackList,
+      clientFilesPruneCallbackList
+    }), jsenvPluginExplorer({
+      groups: explorerGroups
+    }) // ...(toolbar ? [jsenvPluginToolbar(toolbar)] : []),
+    ]
+  });
+  const server = await startOmegaServer({
+    logLevel: omegaServerLogLevel,
+    keepProcessAlive,
+    listenAnyIp,
+    port,
+    protocol,
+    http2,
+    certificate,
+    privateKey,
+    rootDirectoryUrl,
+    urlGraph,
+    kitchen,
+    scenario: "dev"
+  });
+  startDevServerTask.done();
+  logger.info(``);
+  Object.keys(server.origins).forEach(key => {
+    logger.info(`- ${server.origins[key]}`);
+  });
+  logger.info(``);
+  server.addEffect(() => {
+    return () => {
+      kitchen.pluginController.callHooks("destroy", {});
+    };
+  });
+  return {
+    origin: server.origin,
+    stop: () => {
+      stopWatchingClientFiles();
+      server.stop();
+    }
+  };
+};
+
+const generateCoverageJsonFile = async ({
+  coverage,
+  coverageJsonFileUrl,
+  coverageJsonFileLog,
+  logger
+}) => {
+  const coverageAsText = JSON.stringify(coverage, null, "  ");
+
+  if (coverageJsonFileLog) {
+    logger.info(`-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(Buffer.byteLength(coverageAsText))})`);
+  }
+
+  await writeFile(coverageJsonFileUrl, coverageAsText);
+};
+
+const istanbulCoverageMapFromCoverage = coverage => {
+  const {
+    createCoverageMap
+  } = requireFromJsenv("istanbul-lib-coverage");
+  const coverageAdjusted = {};
+  Object.keys(coverage).forEach(key => {
+    coverageAdjusted[key.slice(2)] = { ...coverage[key],
+      path: key.slice(2)
+    };
+  });
+  const coverageMap = createCoverageMap(coverageAdjusted);
+  return coverageMap;
+};
+
+const generateCoverageHtmlDirectory = async (coverage, {
+  rootDirectoryUrl,
+  coverageHtmlDirectoryRelativeUrl,
+  coverageSkipEmpty,
+  coverageSkipFull
+}) => {
+  const libReport = requireFromJsenv("istanbul-lib-report");
+  const reports = requireFromJsenv("istanbul-reports");
+  const context = libReport.createContext({
+    dir: urlToFileSystemPath(rootDirectoryUrl),
+    coverageMap: istanbulCoverageMapFromCoverage(coverage),
+    sourceFinder: path => {
+      return readFileSync(urlToFileSystemPath(resolveUrl(path, rootDirectoryUrl)), "utf8");
+    }
+  });
+  const report = reports.create("html", {
+    skipEmpty: coverageSkipEmpty,
+    skipFull: coverageSkipFull,
+    subdir: coverageHtmlDirectoryRelativeUrl
+  });
+  report.execute(context);
+};
+
+const generateCoverageTextLog = (coverage, {
+  coverageSkipEmpty,
+  coverageSkipFull
+}) => {
+  const libReport = requireFromJsenv("istanbul-lib-report");
+  const reports = requireFromJsenv("istanbul-reports");
+  const context = libReport.createContext({
+    coverageMap: istanbulCoverageMapFromCoverage(coverage)
+  });
+  const report = reports.create("text", {
+    skipEmpty: coverageSkipEmpty,
+    skipFull: coverageSkipFull
+  });
+  report.execute(context);
+};
+
+const babelPluginInstrument = (api, {
+  rootDirectoryUrl,
+  useInlineSourceMaps = false,
+  coverageConfig = {
+    "./**/*": true
+  }
+}) => {
+  const {
+    programVisitor
+  } = requireFromJsenv("istanbul-lib-instrument");
+  const {
+    types
+  } = api;
+  const associations = URL_META.resolveAssociations({
+    cover: coverageConfig
+  }, rootDirectoryUrl);
+
+  const shouldInstrument = url => {
+    return URL_META.applyAssociations({
+      url,
+      associations
+    }).cover;
+  };
+
+  return {
+    name: "transform-instrument",
+    visitor: {
+      Program: {
+        enter(path) {
+          const {
+            file
+          } = this;
+          const {
+            opts
+          } = file;
+
+          if (!opts.sourceFileName) {
+            console.warn(`cannot instrument file when "sourceFileName" option is not set`);
+            return;
+          }
+
+          const fileUrl = fileSystemPathToUrl(opts.sourceFileName);
+
+          if (!shouldInstrument(fileUrl)) {
+            return;
+          }
+
+          this.__dv__ = null;
+          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 visitNodeV8Directory = async ({
+  logger,
+  signal,
+  NODE_V8_COVERAGE,
+  onV8Coverage,
+  maxMsWaitingForNodeToWriteCoverageFile = 2000
+}) => {
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+
+  const tryReadDirectory = async () => {
+    const dirContent = await readDirectory(NODE_V8_COVERAGE);
+
+    if (dirContent.length > 0) {
+      return dirContent;
+    }
+
+    logger.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`);
+    return dirContent;
+  };
+
+  try {
+    operation.throwIfAborted();
+    const dirContent = await tryReadDirectory();
+    const coverageDirectoryUrl = assertAndNormalizeDirectoryUrl(NODE_V8_COVERAGE);
+    await dirContent.reduce(async (previous, dirEntry) => {
+      operation.throwIfAborted();
+      await previous;
+      const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl);
+
+      const tryReadJsonFile = async (timeSpentTrying = 0) => {
+        const fileContent = await readFile(dirEntryUrl, {
+          as: "string"
+        });
+
+        if (fileContent === "") {
+          if (timeSpentTrying < 400) {
+            await new Promise(resolve => setTimeout(resolve, 200));
+            return tryReadJsonFile(timeSpentTrying + 200);
+          }
+
+          console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`);
+          return null;
+        }
+
+        try {
+          const fileAsJson = JSON.parse(fileContent);
+          return fileAsJson;
+        } catch (e) {
+          if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
+            await new Promise(resolve => setTimeout(resolve, 200));
+            return tryReadJsonFile(timeSpentTrying + 200);
+          }
+
+          console.warn(createDetailedMessage(`Error while reading coverage file`, {
+            "error stack": e.stack,
+            "file": dirEntryUrl
+          }));
+          return null;
+        }
+      };
+
+      const fileContent = await tryReadJsonFile();
+
+      if (fileContent) {
+        onV8Coverage(fileContent);
+      }
+    }, Promise.resolve());
+  } finally {
+    await operation.end();
+  }
+};
+const filterV8Coverage = (v8Coverage, {
+  urlShouldBeCovered
+}) => {
+  const v8CoverageFiltered = { ...v8Coverage,
+    result: v8Coverage.result.filter(fileReport => urlShouldBeCovered(fileReport.url))
+  };
+  return v8CoverageFiltered;
+};
+
+const composeTwoV8Coverages = (firstV8Coverage, secondV8Coverage) => {
+  if (secondV8Coverage.result.length === 0) {
+    return firstV8Coverage;
+  } // eslint-disable-next-line import/no-unresolved
+
+
+  const {
+    mergeProcessCovs
+  } = requireFromJsenv("@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;
+};
+
+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
+  } = requireFromJsenv("istanbul-lib-coverage");
+  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage);
+  istanbulFileCoverageObject.merge(secondIstanbulCoverage);
+  const istanbulCoverage = istanbulFileCoverageObject.toJSON();
+  return istanbulCoverage;
+};
+
+const v8CoverageToIstanbul = async (v8Coverage, {
+  signal
+}) => {
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+
+  try {
+    const v8ToIstanbul = requireFromJsenv("v8-to-istanbul");
+    const sourcemapCache = v8Coverage["source-map-cache"];
+    let istanbulCoverageComposed = null;
+    await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
+      operation.throwIfAborted();
+      await previous;
+      const {
+        source
+      } = fileV8Coverage;
+      let sources; // when v8 coverage comes from playwright (chromium) v8Coverage.source is set
+
+      if (typeof source === "string") {
+        sources = {
+          source
+        };
+      } // when v8 coverage comes from Node.js, the source can be read from sourcemapCache
+      else if (sourcemapCache) {
+        sources = sourcesFromSourceMapCache(fileV8Coverage.url, sourcemapCache);
+      }
+
+      const path = urlToFileSystemPath(fileV8Coverage.url);
+      const converter = v8ToIstanbul(path, // wrapperLength is undefined we don't need it
+      // https://github.com/istanbuljs/v8-to-istanbul/blob/2b54bc97c5edf8a37b39a171ec29134ba9bfd532/lib/v8-to-istanbul.js#L27
+      undefined, sources);
+      await converter.load();
+      converter.applyCoverage(fileV8Coverage.functions);
+      const istanbulCoverage = converter.toIstanbul();
+      istanbulCoverageComposed = istanbulCoverageComposed ? composeTwoFileByFileIstanbulCoverages(istanbulCoverageComposed, istanbulCoverage) : istanbulCoverage;
+    }, Promise.resolve());
+
+    if (!istanbulCoverageComposed) {
+      return {};
+    }
+
+    istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed);
+    return istanbulCoverageComposed;
+  } finally {
+    await operation.end();
+  }
+};
+
+const markAsConvertedFromV8 = fileByFileCoverage => {
+  const fileByFileMarked = {};
+  Object.keys(fileByFileCoverage).forEach(key => {
+    const fileCoverage = fileByFileCoverage[key];
+    fileByFileMarked[key] = { ...fileCoverage,
+      fromV8: true
+    };
+  });
+  return fileByFileMarked;
+};
+
+const sourcesFromSourceMapCache = (url, sourceMapCache) => {
+  const sourceMapAndLineLengths = sourceMapCache[url];
+
+  if (!sourceMapAndLineLengths) {
+    return {};
+  }
+
+  const {
+    data,
+    lineLengths
+  } = sourceMapAndLineLengths; // See: https://github.com/nodejs/node/pull/34305
+
+  if (!data) {
+    return undefined;
+  }
+
+  const sources = {
+    sourcemap: data,
+    ...(lineLengths ? {
+      source: sourcesFromLineLengths(lineLengths)
+    } : {})
+  };
+  return sources;
+};
+
+const sourcesFromLineLengths = lineLengths => {
+  let source = "";
+  lineLengths.forEach(length => {
+    source += `${"".padEnd(length, ".")}\n`;
+  });
+  return source;
+};
+
+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"
+        }));
+      }
+
+      fileByFileCoverage[key] = v8Coverage;
+    } else {
+      fileByFileCoverage[key] = istanbulFileByFileCoverage[key];
+    }
+  });
+  return fileByFileCoverage;
+};
+
+const normalizeFileByFileCoveragePaths = (fileByFileCoverage, rootDirectoryUrl) => {
+  const fileByFileNormalized = {};
+  Object.keys(fileByFileCoverage).forEach(key => {
+    const fileCoverage = fileByFileCoverage[key];
+    const {
+      path
+    } = fileCoverage;
+    const url = isFileSystemPath(path) ? fileSystemPathToUrl(path) : new URL(path, rootDirectoryUrl).href;
+    const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
+    fileByFileNormalized[`./${relativeUrl}`] = { ...fileCoverage,
+      path: `./${relativeUrl}`
+    };
+  });
+  return fileByFileNormalized;
+};
+
+const listRelativeFileUrlToCover = async ({
+  signal,
+  rootDirectoryUrl,
+  coverageConfig
+}) => {
+  const matchingFileResultArray = await collectFiles({
+    signal,
+    directoryUrl: rootDirectoryUrl,
+    associations: {
+      cover: coverageConfig
+    },
+    predicate: ({
+      cover
+    }) => cover
+  });
+  return matchingFileResultArray.map(({
+    relativeUrl
+  }) => relativeUrl);
+};
+
+const relativeUrlToEmptyCoverage = async (relativeUrl, {
+  signal,
+  rootDirectoryUrl
+}) => {
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+
+  try {
+    const fileUrl = resolveUrl(relativeUrl, rootDirectoryUrl);
+    const content = await readFile(fileUrl, {
+      as: "string"
+    });
+    operation.throwIfAborted();
+    const {
+      metadata
+    } = await applyBabelPlugins({
+      babelPlugins: [[babelPluginInstrument, {
+        rootDirectoryUrl
+      }]],
+      urlInfo: {
+        originalUrl: fileUrl,
+        content
+      }
+    });
+    const {
+      coverage
+    } = metadata;
+
+    if (!coverage) {
+      throw new Error(`missing coverage for file`);
+    } // https://github.com/gotwarlost/istanbul/blob/bc84c315271a5dd4d39bcefc5925cfb61a3d174a/lib/command/common/run-with-cover.js#L229
+
+
+    Object.keys(coverage.s).forEach(function (key) {
+      coverage.s[key] = 0;
+    });
+    return coverage;
+  } catch (e) {
+    if (e && e.code === "PARSE_ERROR") {
+      // return an empty coverage for that file when
+      // it contains a syntax error
+      return createEmptyCoverage(relativeUrl);
+    }
+
+    throw e;
+  } finally {
+    await operation.end();
+  }
+};
+
+const createEmptyCoverage = relativeUrl => {
+  const {
+    createFileCoverage
+  } = requireFromJsenv("istanbul-lib-coverage");
+  return createFileCoverage(relativeUrl).toJSON();
+};
+
+const getMissingFileByFileCoverage = async ({
+  signal,
+  rootDirectoryUrl,
+  coverageConfig,
+  fileByFileCoverage
 }) => {
-  const logger = createLogger({
-    logLevel
-  });
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
-  const reloadableProcess = await initReloadableProcess({
+  const relativeUrlsToCover = await listRelativeFileUrlToCover({
     signal,
-    handleSIGINT,
-    ...(devServerAutoreload ? {
-      enabled: true,
-      logLevel: "warn",
-      fileToRestart: devServerMainFile
-    } : {
-      enabled: false
-    })
+    rootDirectoryUrl,
+    coverageConfig
   });
+  const relativeUrlsMissing = relativeUrlsToCover.filter(relativeUrlToCover => Object.keys(fileByFileCoverage).every(key => {
+    return key !== `./${relativeUrlToCover}`;
+  }));
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+  const missingFileByFileCoverage = {};
+  await relativeUrlsMissing.reduce(async (previous, relativeUrlMissing) => {
+    operation.throwIfAborted();
+    await previous;
+    await operation.withSignal(async signal => {
+      const emptyCoverage = await relativeUrlToEmptyCoverage(relativeUrlMissing, {
+        signal,
+        rootDirectoryUrl
+      });
+      missingFileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage;
+    });
+  }, Promise.resolve());
+  return missingFileByFileCoverage;
+};
 
-  if (reloadableProcess.isPrimary) {
-    const devServerFileChangeCallback = ({
-      relativeUrl,
-      event
+const reportToCoverage = async (report, {
+  signal,
+  logger,
+  rootDirectoryUrl,
+  coverageConfig,
+  coverageIncludeMissing,
+  urlShouldBeCovered,
+  coverageForceIstanbul,
+  coverageV8ConflictWarning
+}) => {
+  // collect v8 and istanbul coverage from executions
+  let {
+    v8Coverage,
+    fileByFileIstanbulCoverage
+  } = await getCoverageFromReport({
+    signal,
+    report,
+    onMissing: ({
+      file,
+      executionResult,
+      executionName
     }) => {
-      const url = new URL(relativeUrl, rootDirectoryUrl).href;
-
-      if (devServerAutoreload) {
-        logger.info(`file ${event} ${url} -> restarting server...`);
-        reloadableProcess.reload();
+      // 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 (executionResult.status === "completed" && executionResult.runtimeName !== "node" && !process.env.NODE_V8_COVERAGE) {
+        logger.warn(`No execution.coverageFileUrl from execution named "${executionName}" of ${file}`);
       }
-    };
+    }
+  });
 
-    const unregisterDevServerFilesWatcher = registerDirectoryLifecycle(rootDirectoryUrl, {
-      watchPatterns: {
-        [devServerMainFile]: true,
-        ...devServerFiles
-      },
-      cooldownBetweenFileEvents,
-      keepProcessAlive: false,
-      recursive: true,
-      added: ({
-        relativeUrl
-      }) => {
-        devServerFileChangeCallback({
-          relativeUrl,
-          event: "added"
-        });
-      },
-      updated: ({
-        relativeUrl
-      }) => {
-        devServerFileChangeCallback({
-          relativeUrl,
-          event: "modified"
-        });
-      },
-      removed: ({
-        relativeUrl
-      }) => {
-        devServerFileChangeCallback({
-          relativeUrl,
-          event: "removed"
+  if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
+    await visitNodeV8Directory({
+      logger,
+      signal,
+      NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
+      onV8Coverage: nodeV8Coverage => {
+        const nodeV8CoverageLight = filterV8Coverage(nodeV8Coverage, {
+          urlShouldBeCovered
         });
+        v8Coverage = v8Coverage ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight) : nodeV8CoverageLight;
       }
     });
-    signal.addEventListener("abort", () => {
-      unregisterDevServerFilesWatcher();
-    });
-    return {
-      origin: `${protocol}://127.0.0.1:${port}`,
-      stop: () => {
-        unregisterDevServerFilesWatcher();
-        reloadableProcess.stop();
-      }
-    };
-  }
+  } // try to merge v8 with istanbul, if any
 
-  const startDevServerTask = createTaskLog("start dev server", {
-    disabled: !loggerToLevels(logger).info
-  });
-  const clientFileChangeCallbackList = [];
-  const clientFilesPruneCallbackList = [];
 
-  const clientFileChangeCallback = ({
-    relativeUrl,
-    event
-  }) => {
-    const url = new URL(relativeUrl, rootDirectoryUrl).href;
-    clientFileChangeCallbackList.forEach(callback => {
-      callback({
-        url,
-        event
-      });
+  let fileByFileCoverage;
+
+  if (v8Coverage) {
+    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage, {
+      signal
     });
-  };
+    v8FileByFileCoverage = normalizeFileByFileCoveragePaths(v8FileByFileCoverage, rootDirectoryUrl);
 
-  const stopWatchingClientFiles = registerDirectoryLifecycle(rootDirectoryUrl, {
-    watchPatterns: clientFiles,
-    cooldownBetweenFileEvents,
-    keepProcessAlive: false,
-    recursive: true,
-    added: ({
-      relativeUrl
-    }) => {
-      clientFileChangeCallback({
-        event: "added",
-        relativeUrl
-      });
-    },
-    updated: ({
-      relativeUrl
-    }) => {
-      clientFileChangeCallback({
-        event: "modified",
-        relativeUrl
-      });
-    },
-    removed: ({
-      relativeUrl
-    }) => {
-      clientFileChangeCallback({
-        event: "removed",
-        relativeUrl
+    if (fileByFileIstanbulCoverage) {
+      fileByFileIstanbulCoverage = normalizeFileByFileCoveragePaths(fileByFileIstanbulCoverage, rootDirectoryUrl);
+      fileByFileCoverage = composeV8AndIstanbul(v8FileByFileCoverage, fileByFileIstanbulCoverage, {
+        coverageV8ConflictWarning
       });
+    } else {
+      fileByFileCoverage = v8FileByFileCoverage;
     }
-  });
-  const urlGraph = createUrlGraph({
-    clientFileChangeCallbackList,
-    clientFilesPruneCallbackList
-  });
-  const kitchen = createKitchen({
-    signal,
-    logger,
-    rootDirectoryUrl,
-    urlGraph,
-    scenario: "dev",
-    runtimeCompat,
-    sourcemaps,
-    writeGeneratedFiles,
-    plugins: [...plugins, ...getCorePlugins({
+  } // get istanbul only
+  else if (fileByFileIstanbulCoverage) {
+    fileByFileCoverage = normalizeFileByFileCoveragePaths(fileByFileIstanbulCoverage, rootDirectoryUrl);
+  } // no coverage found in execution (or zero file where executed)
+  else {
+    fileByFileCoverage = {};
+  } // now add coverage for file not covered
+
+
+  if (coverageIncludeMissing) {
+    const missingFileByFileCoverage = await getMissingFileByFileCoverage({
+      signal,
       rootDirectoryUrl,
-      urlGraph,
-      scenario: "dev",
-      runtimeCompat,
-      urlAnalysis,
-      htmlSupervisor,
-      nodeEsmResolution,
-      fileSystemMagicResolution,
-      transpilation,
-      clientAutoreload,
-      clientFileChangeCallbackList,
-      clientFilesPruneCallbackList
-    }), jsenvPluginExplorer({
-      groups: explorerGroups
-    }) // ...(toolbar ? [jsenvPluginToolbar(toolbar)] : []),
-    ]
-  });
-  const server = await startOmegaServer({
-    logLevel: omegaServerLogLevel,
-    keepProcessAlive,
-    listenAnyIp,
-    port,
-    protocol,
-    http2,
-    certificate,
-    privateKey,
-    rootDirectoryUrl,
-    urlGraph,
-    kitchen,
-    scenario: "dev"
-  });
-  startDevServerTask.done();
-  logger.info(``);
-  Object.keys(server.origins).forEach(key => {
-    logger.info(`- ${server.origins[key]}`);
-  });
-  logger.info(``);
-  server.addEffect(() => {
-    return () => {
-      kitchen.pluginController.callHooks("destroy", {});
+      coverageConfig,
+      fileByFileCoverage
+    });
+    Object.assign(fileByFileCoverage, normalizeFileByFileCoveragePaths(missingFileByFileCoverage, rootDirectoryUrl));
+  }
+
+  return fileByFileCoverage;
+};
+
+const getCoverageFromReport = async ({
+  signal,
+  report,
+  onMissing
+}) => {
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+
+  try {
+    let v8Coverage;
+    let fileByFileIstanbulCoverage; // collect v8 and istanbul coverage from executions
+
+    await Object.keys(report).reduce(async (previous, file) => {
+      operation.throwIfAborted();
+      await previous;
+      const executionResultForFile = report[file];
+      await Object.keys(executionResultForFile).reduce(async (previous, executionName) => {
+        operation.throwIfAborted();
+        await previous;
+        const executionResultForFileOnRuntime = executionResultForFile[executionName];
+        const {
+          coverageFileUrl
+        } = executionResultForFileOnRuntime;
+
+        if (!coverageFileUrl) {
+          onMissing({
+            executionName,
+            file,
+            executionResult: executionResultForFileOnRuntime
+          });
+          return;
+        }
+
+        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());
+    }, Promise.resolve());
+    return {
+      v8Coverage,
+      fileByFileIstanbulCoverage
     };
-  });
-  return {
-    origin: server.origin,
-    stop: () => {
-      stopWatchingClientFiles();
-      server.stop();
-    }
-  };
+  } finally {
+    await operation.end();
+  }
 };
 
+const isV8Coverage = coverage => Boolean(coverage.result);
+
 const run = async ({
   signal = new AbortController().signal,
   logger,
@@ -11540,7 +12346,7 @@ const injectors = {
     const htmlAst = parseHtmlString(urlInfo.content, {
       storeOriginalPositions: false
     });
-    injectScriptAsEarlyAsPossible(htmlAst, createHtmlNode({
+    injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
       "tagName": "script",
       "textContent": generateClientCodeForVersionMappings(versionMappings, {
         globalName: "window"
@@ -11668,15 +12474,12 @@ const resyncRessourceHints = async ({
       });
       const actions = [];
 
-      const visitLinkWithHref = (linkNode, hrefAttribute) => {
-        const href = hrefAttribute.value;
-
+      const visitLinkWithHref = (linkNode, href) => {
         if (!href || href.startsWith("data:")) {
           return;
         }
 
-        const relAttribute = getHtmlNodeAttributeByName(linkNode, "rel");
-        const rel = relAttribute ? relAttribute.value : undefined;
+        const rel = getHtmlNodeAttribute(linkNode, "rel");
         const isRessourceHint = ["preconnect", "dns-prefetch", "prefetch", "preload", "modulepreload"].includes(rel);
 
         if (!isRessourceHint) {
@@ -11720,22 +12523,20 @@ const resyncRessourceHints = async ({
         }
 
         actions.push(() => {
-          hrefAttribute.value = urlInfo.data.buildUrlSpecifier;
+          setHtmlNodeAttributes(linkNode, {
+            href: urlInfo.data.buildUrlSpecifier
+          });
         });
       };
 
-      visitHtmlAst(htmlAst, node => {
-        if (node.nodeName !== "link") {
-          return;
-        }
+      visitHtmlNodes(htmlAst, {
+        link: node => {
+          const href = getHtmlNodeAttribute(node, "href");
 
-        const hrefAttribute = getHtmlNodeAttributeByName(node, "href");
-
-        if (!hrefAttribute) {
-          return;
+          if (href !== undefined) {
+            visitLinkWithHref(node, href);
+          }
         }
-
-        visitLinkWithHref(node, hrefAttribute);
       });
 
       if (actions.length) {
@@ -12300,7 +13101,7 @@ build ${entryPointKeys.length} entry points`);
 
           if (reference.type === "sourcemap_comment") {
             // inherit parent build url
-            return generateSourcemapUrl(reference.parentUrl);
+            return generateSourcemapFileUrl(reference.parentUrl);
           } // files generated during the final graph:
           // - sourcemaps
           // const finalUrlInfo = finalGraph.getUrlInfo(url)
@@ -13026,6 +13827,7 @@ const startBuildServer = async ({
   ip,
   port = 9779,
   services = {},
+  keepProcessAlive = true,
   rootDirectoryUrl,
   buildDirectoryUrl,
   mainBuildFileUrl = "/index.html",
@@ -13036,9 +13838,9 @@ const startBuildServer = async ({
   buildServerMainFile = getCallerPosition().url,
   // force disable server autoreload when this code is executed:
   // - inside a forked child process
-  // - inside a worker thread
-  // (because node cluster won't work)
-  buildServerAutoreload = typeof process.send !== "function" && !parentPort && !process.env.VSCODE_INSPECTOR_OPTIONS,
+  // - debugged by vscode
+  // otherwise we get net:ERR_CONNECTION_REFUSED
+  buildServerAutoreload = typeof process.send !== "function" && !process.env.VSCODE_INSPECTOR_OPTIONS,
   cooldownBetweenFileEvents
 }) => {
   const logger = createLogger({
@@ -13046,19 +13848,26 @@ const startBuildServer = async ({
   });
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
   buildDirectoryUrl = assertAndNormalizeDirectoryUrl(buildDirectoryUrl);
-  const reloadableProcess = await initReloadableProcess({
-    signal,
-    handleSIGINT,
-    ...(buildServerAutoreload ? {
-      enabled: true,
-      logLevel: "info",
-      fileToRestart: buildServerMainFile
-    } : {
-      enabled: false
-    })
-  });
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+
+  if (handleSIGINT) {
+    operation.addAbortSource(abort => {
+      return raceProcessTeardownEvents({
+        SIGINT: true
+      }, abort);
+    });
+  }
+
+  if (port === 0) {
+    port = await findFreePort(port, {
+      signal: operation.signal
+    });
+  }
 
-  if (reloadableProcess.isPrimary) {
+  const reloadableWorker = createReloadableWorker(buildServerMainFile);
+
+  if (buildServerAutoreload && reloadableWorker.isPrimary) {
     const buildServerFileChangeCallback = ({
       relativeUrl,
       event
@@ -13067,7 +13876,7 @@ const startBuildServer = async ({
 
       if (buildServerAutoreload) {
         logger.info(`file ${event} ${url} -> restarting server...`);
-        reloadableProcess.reload();
+        reloadableWorker.reload();
       }
     };
 
@@ -13104,19 +13913,25 @@ const startBuildServer = async ({
         });
       }
     });
-    signal.addEventListener("abort", () => {
+    operation.addAbortCallback(() => {
       stopWatchingBuildServerFiles();
+      reloadableWorker.terminate();
     });
+    const worker = await reloadableWorker.load();
+
+    if (!keepProcessAlive) {
+      worker.unref();
+    }
+
     return {
       origin: `${protocol}://127.0.0.1:${port}`,
       stop: () => {
         stopWatchingBuildServerFiles();
-        reloadableProcess.stop();
+        reloadableWorker.terminate();
       }
     };
   }
 
-  signal = reloadableProcess.signal;
   const startBuildServerTask = createTaskLog("start build server", {
     disabled: !loggerToLevels(logger).info
   });
@@ -13365,7 +14180,7 @@ const globalInjectorOnHtml = async (urlInfo, globals) => {
     globals,
     isWebWorker: false
   });
-  injectScriptAsEarlyAsPossible(htmlAst, createHtmlNode({
+  injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
     "tagName": "script",
     "textContent": clientCode,
     "injected-by": "jsenv:inject_globals"