@jsenv/core 28.1.1 → 28.2.0

package/src/build/build.js

@@ -1,15 +1,24 @@
 /*
- * Things hapenning here:
- * 1. load raw build files
- * 2. bundle files
- * 3. optimize files (minify mostly)
- * 4. urls versioning
+ * Build is split in 3 steps:
+ * 1. craft
+ * 2. shape
+ * 3. refine
+ *
+ * craft: prepare all the materials
+ *  - resolve, fetch and transform all source files into "rawGraph"
+ * shape: this step can drastically change url content and their relationships
+ *  - bundling
+ *  - optimizations (minification)
+ * refine: perform minor changes on the url contents
+ *  - cleaning html
+ *  - url versioning
+ *  - ressource hints
+ *  - injecting urls into service workers
  */
 
 import {
   injectQueryParams,
   setUrlFilename,
-  asUrlUntilPathname,
   normalizeUrl,
   asUrlWithoutSearch,
   ensurePathnameTrailingSlash,
@@ -21,13 +30,25 @@ import {
 import {
   assertAndNormalizeDirectoryUrl,
   ensureEmptyDirectory,
-  writeFile,
+  writeFileSync,
   registerDirectoryLifecycle,
 } from "@jsenv/filesystem"
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
-import { createLogger, loggerToLevels, createTaskLog } from "@jsenv/log"
-import { generateSourcemapFileUrl } from "@jsenv/sourcemap"
-import { parseHtmlString, stringifyHtmlAst } from "@jsenv/ast"
+import {
+  createLogger,
+  createTaskLog,
+  ANSI,
+  createDetailedMessage,
+} from "@jsenv/log"
+import { createMagicSource, generateSourcemapFileUrl } from "@jsenv/sourcemap"
+import {
+  parseHtmlString,
+  stringifyHtmlAst,
+  visitHtmlNodes,
+  getHtmlNodeAttribute,
+  setHtmlNodeAttributes,
+  removeHtmlNode,
+} from "@jsenv/ast"
 
 import { sortByDependencies } from "../omega/url_graph/sort_by_dependencies.js"
 import { createUrlGraph } from "../omega/url_graph.js"
@@ -36,16 +57,14 @@ import { jsenvPluginInline } from "../plugins/inline/jsenv_plugin_inline.js"
 import { jsenvPluginAsJsClassic } from "../plugins/transpilation/as_js_classic/jsenv_plugin_as_js_classic.js"
 import { getCorePlugins } from "../plugins/plugins.js"
 import { createKitchen } from "../omega/kitchen.js"
-import { loadUrlGraph } from "../omega/url_graph/url_graph_load.js"
+import { createUrlGraphLoader } from "../omega/url_graph/url_graph_loader.js"
 import { createUrlGraphSummary } from "../omega/url_graph/url_graph_report.js"
 import { isWebWorkerEntryPointReference } from "../omega/web_workers.js"
 
 import { GRAPH } from "./graph_utils.js"
 import { createBuilUrlsGenerator } from "./build_urls_generator.js"
-import { injectGlobalVersionMapping } from "./inject_global_version_mappings.js"
+import { injectVersionMappings } from "./inject_global_version_mappings.js"
 import { createVersionGenerator } from "./version_generator.js"
-import { injectServiceWorkerUrls } from "./inject_service_worker_urls.js"
-import { resyncResourceHints } from "./resync_resource_hints.js"
 
 // default runtimeCompat corresponds to
 // "we can keep <script type="module"> intact":
@@ -151,7 +170,6 @@ export const build = async ({
   const runBuild = async ({ signal, logLevel }) => {
     const logger = createLogger({ logLevel })
     const buildOperation = Abort.startOperation()
-    const infoLogsAreDisabled = !loggerToLevels(logger).info
     buildOperation.addAbortSignal(signal)
     const entryPointKeys = Object.keys(entryPoints)
     if (entryPointKeys.length === 1) {
@@ -164,29 +182,27 @@ build ${entryPointKeys.length} entry points`)
     const useExplicitJsClassicConversion = entryPointKeys.some((key) =>
       entryPoints[key].includes("?as_js_classic"),
     )
-
+    const rawRedirections = new Map()
+    const bundleRedirections = new Map()
+    const bundleInternalRedirections = new Map()
+    const finalRedirections = new Map()
+    const versioningRedirections = new Map()
+    const entryUrls = []
     const rawGraph = createUrlGraph()
-    const prebuildTask = createTaskLog("prebuild", {
-      disabled: infoLogsAreDisabled,
-    })
-    const prebuildRedirections = new Map()
     const rawGraphKitchen = createKitchen({
       signal,
-      logger,
+      logLevel,
       rootDirectoryUrl,
       urlGraph: rawGraph,
       scenarios: { build: true },
-      sourcemaps,
-      sourcemapsSourcesContent,
       runtimeCompat,
-      writeGeneratedFiles,
       plugins: [
         ...plugins,
         {
           appliesDuring: "build",
           fetchUrlContent: (urlInfo, context) => {
             if (context.reference.original) {
-              prebuildRedirections.set(
+              rawRedirections.set(
                 context.reference.original.url,
                 context.reference.url,
               )
@@ -211,326 +227,97 @@ build ${entryPointKeys.length} entry points`)
           transpilation: {
             ...transpilation,
             babelHelpersAsImport: !useExplicitJsClassicConversion,
-            jsModuleAsJsClassic: false,
+            jsClassicFallback: false,
           },
           minification,
           bundling,
         }),
       ],
+      sourcemaps,
+      sourcemapsSourcesContent,
+      writeGeneratedFiles,
+      outDirectoryUrl: new URL(`.jsenv/build/`, rootDirectoryUrl),
     })
-    const entryUrls = []
-    try {
-      await loadUrlGraph({
-        operation: buildOperation,
-        urlGraph: rawGraph,
-        kitchen: rawGraphKitchen,
-        writeGeneratedFiles,
-        outDirectoryUrl: new URL(`.jsenv/build/`, rootDirectoryUrl),
-        startLoading: (cookEntryFile) => {
-          Object.keys(entryPoints).forEach((key) => {
-            const [, entryUrlInfo] = cookEntryFile({
-              trace: {
-                message: `"${key}" in entryPoints parameter`,
-              },
-              type: "entry_point",
-              specifier: key,
-            })
-            entryUrls.push(entryUrlInfo.url)
-            entryUrlInfo.filename = entryPoints[key]
-            // entryUrlInfo.data.entryPointKey = key
-          })
-        },
-      })
-    } catch (e) {
-      prebuildTask.fail()
-      throw e
-    }
-    prebuildTask.done()
 
     const buildUrlsGenerator = createBuilUrlsGenerator({
       buildDirectoryUrl,
     })
-    const rawUrls = {}
-    const bundleRedirections = {}
-    const buildUrls = {}
-    const bundleUrlInfos = {}
-    const bundlers = {}
-    rawGraphKitchen.pluginController.plugins.forEach((plugin) => {
-      const bundle = plugin.bundle
-      if (!bundle) {
-        return
-      }
-      if (typeof bundle !== "object") {
-        throw new Error(
-          `bundle must be an object, found "${bundle}" on plugin named "${plugin.name}"`,
-        )
-      }
-      Object.keys(bundle).forEach((type) => {
-        const bundleFunction = bundle[type]
-        if (!bundleFunction) {
-          return
-        }
-        const bundlerForThatType = bundlers[type]
-        if (bundlerForThatType) {
-          // first plugin to define a bundle hook wins
-          return
-        }
-        bundlers[type] = {
-          plugin,
-          bundleFunction: bundle[type],
-          urlInfos: [],
-        }
-      })
-    })
-    const addToBundlerIfAny = (rawUrlInfo) => {
-      const bundler = bundlers[rawUrlInfo.type]
-      if (bundler) {
-        bundler.urlInfos.push(rawUrlInfo)
-        return
+    const buildToRawUrls = {}
+    // rename "buildDirectoryRedirections"?
+    const associateBuildUrlAndRawUrl = (buildUrl, rawUrl, reason) => {
+      if (urlIsInsideOf(rawUrl, buildDirectoryUrl)) {
+        throw new Error(`raw url must be inside rawGraph, got ${rawUrl}`)
       }
+      logger.debug(`build url generated (${reason})
+${ANSI.color(rawUrl, ANSI.GREY)} ->
+${ANSI.color(buildUrl, ANSI.MAGENTA)}
+`)
+      buildToRawUrls[buildUrl] = rawUrl
     }
-    GRAPH.forEach(rawGraph, (rawUrlInfo) => {
-      if (rawUrlInfo.isEntryPoint) {
-        addToBundlerIfAny(rawUrlInfo)
-        if (rawUrlInfo.type === "html") {
-          rawUrlInfo.dependencies.forEach((dependencyUrl) => {
-            const dependencyUrlInfo = rawGraph.getUrlInfo(dependencyUrl)
-            if (dependencyUrlInfo.isInline) {
-              if (dependencyUrlInfo.type === "js_module") {
-                // bundle inline script type module deps
-                dependencyUrlInfo.references.forEach((inlineScriptRef) => {
-                  if (inlineScriptRef.type === "js_import_export") {
-                    const inlineUrlInfo = rawGraph.getUrlInfo(
-                      inlineScriptRef.url,
-                    )
-                    addToBundlerIfAny(inlineUrlInfo)
-                  }
-                })
-              }
-              // inline content cannot be bundled
-              return
-            }
-            addToBundlerIfAny(dependencyUrlInfo)
-          })
-          rawUrlInfo.references.forEach((reference) => {
-            if (
-              reference.isResourceHint &&
-              reference.expectedType === "js_module"
-            ) {
-              const referencedUrlInfo = rawGraph.getUrlInfo(reference.url)
-              if (
-                referencedUrlInfo &&
-                // something else than the resource hint is using this url
-                referencedUrlInfo.dependents.size > 0
-              ) {
-                addToBundlerIfAny(referencedUrlInfo)
-              }
-            }
-          })
-          return
-        }
-      }
-      // File referenced with new URL('./file.js', import.meta.url)
-      // are entry points that can be bundled
-      // For instance we will bundle service worker/workers detected like this
-      if (rawUrlInfo.type === "js_module") {
-        rawUrlInfo.references.forEach((reference) => {
-          if (reference.type === "js_url_specifier") {
-            const urlInfo = rawGraph.getUrlInfo(reference.url)
-            addToBundlerIfAny(urlInfo)
-          }
-        })
-      }
-    })
-    const bundleInternalRedirections = {}
-    await Object.keys(bundlers).reduce(async (previous, type) => {
-      await previous
-      const bundler = bundlers[type]
-      const urlInfosToBundle = bundler.urlInfos
-      if (urlInfosToBundle.length === 0) {
-        return
-      }
-      const bundleTask = createTaskLog(`bundle "${type}"`, {
-        disabled: infoLogsAreDisabled,
-      })
-      try {
-        const bundlerGeneratedUrlInfos =
-          await rawGraphKitchen.pluginController.callAsyncHook(
-            {
-              plugin: bundler.plugin,
-              hookName: "bundle",
-              value: bundler.bundleFunction,
-            },
-            urlInfosToBundle,
-            {
-              ...rawGraphKitchen.kitchenContext,
-              buildDirectoryUrl,
-            },
-          )
-        Object.keys(bundlerGeneratedUrlInfos).forEach((url) => {
-          const rawUrlInfo = rawGraph.getUrlInfo(url)
-          const bundlerGeneratedUrlInfo = bundlerGeneratedUrlInfos[url]
-          const bundleUrlInfo = {
-            type,
-            subtype: rawUrlInfo ? rawUrlInfo.subtype : undefined,
-            isEntryPoint: rawUrlInfo ? rawUrlInfo.isEntryPoint : undefined,
-            filename: rawUrlInfo ? rawUrlInfo.filename : undefined,
-            originalUrl: rawUrlInfo ? rawUrlInfo.originalUrl : undefined,
-            originalContent: rawUrlInfo
-              ? rawUrlInfo.originalContent
-              : undefined,
-            ...bundlerGeneratedUrlInfo,
-            data: {
-              ...(rawUrlInfo ? rawUrlInfo.data : {}),
-              ...bundlerGeneratedUrlInfo.data,
-              fromBundle: true,
-            },
-          }
-          const buildUrl = buildUrlsGenerator.generate(url, {
-            urlInfo: bundleUrlInfo,
-          })
-          bundleRedirections[url] = buildUrl
-          rawUrls[buildUrl] = url
-          bundleUrlInfos[buildUrl] = bundleUrlInfo
-          if (buildUrl.includes("?")) {
-            bundleUrlInfos[asUrlWithoutSearch(buildUrl)] = bundleUrlInfo
-          }
-          if (bundlerGeneratedUrlInfo.data.bundleRelativeUrl) {
-            const urlForBundler = new URL(
-              bundlerGeneratedUrlInfo.data.bundleRelativeUrl,
-              buildDirectoryUrl,
-            ).href
-            if (urlForBundler !== buildUrl) {
-              bundleInternalRedirections[urlForBundler] = buildUrl
-            }
-          }
-        })
-      } catch (e) {
-        bundleTask.fail()
-        throw e
-      }
-      bundleTask.done()
-    }, Promise.resolve())
-
+    const buildUrls = new Map()
+    const bundleUrlInfos = {}
+    const bundlers = {}
+    const finalGraph = createUrlGraph()
     const urlAnalysisPlugin = jsenvPluginUrlAnalysis({
       rootDirectoryUrl,
       ...urlAnalysis,
     })
-    const postBuildRedirections = {}
-    const finalGraph = createUrlGraph()
     const finalGraphKitchen = createKitchen({
-      logger,
+      logLevel,
       rootDirectoryUrl,
       urlGraph: finalGraph,
       scenarios: { build: true },
-      sourcemaps,
-      sourcemapsSourcesContent,
-      sourcemapsRelativeSources: !versioning,
       runtimeCompat,
-      writeGeneratedFiles,
       plugins: [
         urlAnalysisPlugin,
-        jsenvPluginAsJsClassic({ systemJsInjection: true }),
-        jsenvPluginInline({ fetchInlineUrls: false }),
+        jsenvPluginAsJsClassic({
+          jsClassicLibrary: false,
+          jsClassicFallback: true,
+          systemJsInjection: true,
+        }),
+        jsenvPluginInline({
+          fetchInlineUrls: false,
+        }),
         {
-          name: "jsenv:postbuild",
+          name: "jsenv:build",
           appliesDuring: "build",
           resolveUrl: (reference) => {
-            const performInternalRedirections = (url) => {
-              const prebuildRedirection = prebuildRedirections.get(url)
-              if (prebuildRedirection) {
-                logger.debug(
-                  `\nprebuild redirection\n${url} ->\n${prebuildRedirection}\n`,
-                )
-                url = prebuildRedirection
-              }
-              const bundleRedirection = bundleRedirections[url]
-              if (bundleRedirection) {
-                logger.debug(
-                  `\nbundler redirection\n${url} ->\n${bundleRedirection}\n`,
-                )
-                url = bundleRedirection
+            const getUrl = () => {
+              if (reference.type === "filesystem") {
+                const parentRawUrl = buildToRawUrls[reference.parentUrl]
+                const baseUrl = ensurePathnameTrailingSlash(parentRawUrl)
+                return new URL(reference.specifier, baseUrl).href
               }
-              const bundleInternalRedirection = bundleInternalRedirections[url]
-              if (bundleInternalRedirection) {
-                logger.debug(
-                  `\nbundler internal redirection\n${url} ->\n${bundleInternalRedirection}\n`,
-                )
-                url = bundleInternalRedirection
+              if (reference.specifier[0] === "/") {
+                return new URL(reference.specifier.slice(1), buildDirectoryUrl)
+                  .href
               }
-              return url
-            }
-
-            if (reference.type === "filesystem") {
-              const parentRawUrl = rawUrls[reference.parentUrl]
-              const baseUrl = ensurePathnameTrailingSlash(parentRawUrl)
-              return performInternalRedirections(
-                new URL(reference.specifier, baseUrl).href,
-              )
-            }
-            if (reference.specifier[0] === "/") {
-              return performInternalRedirections(
-                new URL(reference.specifier.slice(1), buildDirectoryUrl).href,
-              )
-            }
-            return performInternalRedirections(
-              new URL(
+              return new URL(
                 reference.specifier,
                 reference.baseUrl || reference.parentUrl,
-              ).href,
-            )
+              ).href
+            }
+            let url = getUrl()
+            //  url = rawRedirections.get(url) || url
+            url = bundleRedirections.get(url) || url
+            url = bundleInternalRedirections.get(url) || url
+            return url
           },
           // redirecting urls into the build directory
           redirectUrl: (reference) => {
             if (!reference.url.startsWith("file:")) {
               return null
             }
+            // referenced by resource hint
+            // -> keep it untouched, it will be handled by "resync_resource_hints"
+            if (reference.isResourceHint) {
+              return reference.original ? reference.original.url : null
+            }
             // already a build url
-            const rawUrl = rawUrls[reference.url]
+            const rawUrl = buildToRawUrls[reference.url]
             if (rawUrl) {
               return reference.url
             }
-            // from "js_module_as_js_classic":
-            //   - injecting "?as_js_classic" for the first time
-            //   - injecting "?as_js_classic" because the parentUrl has it
-            if (reference.original) {
-              const referenceOriginalUrl = reference.original.url
-              let originalBuildUrl
-              if (urlIsInsideOf(referenceOriginalUrl, buildDirectoryUrl)) {
-                originalBuildUrl = referenceOriginalUrl
-              } else {
-                originalBuildUrl = Object.keys(rawUrls).find(
-                  (key) => rawUrls[key] === referenceOriginalUrl,
-                )
-              }
-              let rawUrl
-              if (urlIsInsideOf(reference.url, buildDirectoryUrl)) {
-                const originalBuildUrl =
-                  postBuildRedirections[referenceOriginalUrl]
-                rawUrl = originalBuildUrl
-                  ? rawUrls[originalBuildUrl]
-                  : reference.url
-              } else {
-                rawUrl = reference.url
-              }
-              // the url info do not exists yet (it will be created after this "normalize" hook)
-              // And the content will be generated when url is cooked by url graph loader.
-              // Here we just want to reserve an url for that file
-              const buildUrl = buildUrlsGenerator.generate(rawUrl, {
-                urlInfo: {
-                  data: reference.data,
-                  isEntryPoint:
-                    reference.isEntryPoint ||
-                    isWebWorkerEntryPointReference(reference),
-                  type: reference.expectedType,
-                  subtype: reference.expectedSubtype,
-                  filename: reference.filename,
-                },
-              })
-              postBuildRedirections[originalBuildUrl] = buildUrl
-              rawUrls[buildUrl] = rawUrl
-              return buildUrl
-            }
             if (reference.isInline) {
               const rawUrlInfo = GRAPH.find(rawGraph, (rawUrlInfo) => {
                 if (!rawUrlInfo.isInline) {
@@ -555,7 +342,51 @@ build ${entryPointKeys.length} entry points`)
                 urlInfo: rawUrlInfo,
                 parentUrlInfo,
               })
-              rawUrls[buildUrl] = rawUrlInfo.url
+              associateBuildUrlAndRawUrl(
+                buildUrl,
+                rawUrlInfo.url,
+                "inline content",
+              )
+              return buildUrl
+            }
+            // from "js_module_as_js_classic":
+            //   - injecting "?as_js_classic" for the first time
+            //   - injecting "?as_js_classic" because the parentUrl has it
+            if (reference.original) {
+              const urlBeforeRedirect = reference.original.url
+              const urlAfterRedirect = reference.url
+              const isEntryPoint =
+                reference.isEntryPoint ||
+                isWebWorkerEntryPointReference(reference)
+              // the url info do not exists yet (it will be created after this "redirectUrl" hook)
+              // And the content will be generated when url is cooked by url graph loader.
+              // Here we just want to reserve an url for that file
+              const urlInfo = {
+                data: reference.data,
+                isEntryPoint,
+                type: reference.expectedType,
+                subtype: reference.expectedSubtype,
+                filename: reference.filename,
+              }
+              if (urlIsInsideOf(urlBeforeRedirect, buildDirectoryUrl)) {
+                // the redirection happened on a build url, happens due to:
+                // 1. bundling
+                const buildUrl = buildUrlsGenerator.generate(urlAfterRedirect, {
+                  urlInfo,
+                })
+                finalRedirections.set(urlBeforeRedirect, buildUrl)
+                return buildUrl
+              }
+              const rawUrl = urlAfterRedirect
+              const buildUrl = buildUrlsGenerator.generate(rawUrl, {
+                urlInfo,
+              })
+              finalRedirections.set(urlBeforeRedirect, buildUrl)
+              associateBuildUrlAndRawUrl(
+                buildUrl,
+                rawUrl,
+                "redirected during postbuild",
+              )
               return buildUrl
             }
             // from "js_module_as_js_classic":
@@ -567,20 +398,34 @@ build ${entryPointKeys.length} entry points`)
                   type: "js_classic",
                 },
               })
-              rawUrls[buildUrl] = reference.url
+              associateBuildUrlAndRawUrl(
+                buildUrl,
+                reference.url,
+                "injected during postbuild",
+              )
+              finalRedirections.set(buildUrl, buildUrl)
               return buildUrl
             }
             const rawUrlInfo = rawGraph.getUrlInfo(reference.url)
             const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl)
             // files from root directory but not given to rollup nor postcss
             if (rawUrlInfo) {
-              const buildUrl = buildUrlsGenerator.generate(reference.url, {
-                urlInfo: rawUrlInfo,
-                parentUrlInfo,
-              })
-              rawUrls[buildUrl] = rawUrlInfo.url
+              const referencedUrlObject = new URL(reference.url)
+              referencedUrlObject.searchParams.delete("as_js_classic_library")
+              const buildUrl = buildUrlsGenerator.generate(
+                referencedUrlObject.href,
+                {
+                  urlInfo: rawUrlInfo,
+                  parentUrlInfo,
+                },
+              )
+              associateBuildUrlAndRawUrl(buildUrl, rawUrlInfo.url, "raw file")
               if (buildUrl.includes("?")) {
-                rawUrls[asUrlWithoutSearch(buildUrl)] = rawUrlInfo.url
+                associateBuildUrlAndRawUrl(
+                  asUrlWithoutSearch(buildUrl),
+                  rawUrlInfo.url,
+                  "raw file",
+                )
               }
               return buildUrl
             }
@@ -606,21 +451,26 @@ build ${entryPointKeys.length} entry points`)
               }
               return null
             }
+            if (reference.isResourceHint) {
+              return null
+            }
             if (!urlIsInsideOf(reference.generatedUrl, buildDirectoryUrl)) {
               throw new Error(
                 `urls should be inside build directory at this stage, found "${reference.url}"`,
               )
             }
-            if (reference.isResourceHint) {
-              // return the raw url, we will resync at the end
-              return rawUrls[reference.url]
-            }
-            // remove eventual search params and hash
-            const urlUntilPathname = asUrlUntilPathname(reference.generatedUrl)
+            const generatedUrlObject = new URL(reference.generatedUrl)
+            generatedUrlObject.searchParams.delete("as_js_classic")
+            generatedUrlObject.searchParams.delete("as_js_classic_library")
+            generatedUrlObject.searchParams.delete("as_json_module")
+            generatedUrlObject.searchParams.delete("as_css_module")
+            generatedUrlObject.searchParams.delete("as_text_module")
+            generatedUrlObject.hash = ""
+            const generatedUrl = generatedUrlObject.href
             let specifier
             if (baseUrl === "./") {
               const relativeUrl = urlToRelativeUrl(
-                urlUntilPathname,
+                generatedUrl,
                 reference.parentUrl === rootDirectoryUrl
                   ? buildDirectoryUrl
                   : reference.parentUrl,
@@ -632,26 +482,32 @@ build ${entryPointKeys.length} entry points`)
               // if a file is in the same directory we could prefer the relative notation
               // but to keep things simple let's keep the "absolutely relative" to baseUrl for now
               specifier = `${baseUrl}${urlToRelativeUrl(
-                urlUntilPathname,
+                generatedUrl,
                 buildDirectoryUrl,
               )}`
             }
-            buildUrls[specifier] = reference.generatedUrl
+            buildUrls.set(specifier, reference.generatedUrl)
             return specifier
           },
           fetchUrlContent: async (finalUrlInfo, context) => {
             const fromBundleOrRawGraph = (url) => {
               const bundleUrlInfo = bundleUrlInfos[url]
               if (bundleUrlInfo) {
-                logger.debug(`fetching from bundle ${url}`)
+                // logger.debug(`fetching from bundle ${url}`)
                 return bundleUrlInfo
               }
-              const rawUrl = rawUrls[url] || url
+              const rawUrl = buildToRawUrls[url] || url
               const rawUrlInfo = rawGraph.getUrlInfo(rawUrl)
               if (!rawUrlInfo) {
-                throw new Error(`Cannot find url`)
+                throw new Error(
+                  createDetailedMessage(`Cannot find url`, {
+                    url,
+                    "raw urls": Object.values(buildToRawUrls),
+                    "build urls": Object.keys(buildToRawUrls),
+                  }),
+                )
               }
-              logger.debug(`fetching from raw graph ${url}`)
+              // logger.debug(`fetching from raw graph ${url}`)
               if (rawUrlInfo.isInline) {
                 // Inline content, such as <script> inside html, is transformed during the previous phase.
                 // If we read the inline content it would be considered as the original content.
@@ -667,24 +523,28 @@ build ${entryPointKeys.length} entry points`)
               }
               return rawUrlInfo
             }
+            const { reference } = context
             // reference injected during "postbuild":
             // - happens for "as_js_classic" injecting "s.js"
-            if (context.reference.injected) {
+            if (reference.injected) {
               const [ref, rawUrlInfo] = rawGraphKitchen.injectReference({
-                type: context.reference.type,
-                expectedType: context.reference.expectedType,
-                expectedSubtype: context.reference.expectedSubtype,
-                parentUrl: rawUrls[context.reference.parentUrl],
-                specifier: context.reference.specifier,
+                type: reference.type,
+                expectedType: reference.expectedType,
+                expectedSubtype: reference.expectedSubtype,
+                parentUrl: buildToRawUrls[reference.parentUrl],
+                specifier: reference.specifier,
                 injected: true,
               })
               await rawGraphKitchen.cook(rawUrlInfo, { reference: ref })
               return rawUrlInfo
             }
+            if (reference.isInline) {
+              return fromBundleOrRawGraph(reference.url)
+            }
             // reference updated during "postbuild":
             // - happens for "as_js_classic"
-            if (context.reference.original) {
-              return fromBundleOrRawGraph(context.reference.original.url)
+            if (reference.original) {
+              return fromBundleOrRawGraph(reference.original.url)
             }
             return fromBundleOrRawGraph(finalUrlInfo.url)
           },
@@ -707,115 +567,750 @@ build ${entryPointKeys.length} entry points`)
           },
         },
       ],
+      sourcemaps,
+      sourcemapsSourcesContent,
+      sourcemapsRelativeSources: !versioning,
+      writeGeneratedFiles,
+      outDirectoryUrl: new URL(".jsenv/postbuild/", rootDirectoryUrl),
     })
-    const buildTask = createTaskLog("build", { disabled: infoLogsAreDisabled })
-    const postBuildEntryUrls = []
-    try {
-      await loadUrlGraph({
-        operation: buildOperation,
-        urlGraph: finalGraph,
-        kitchen: finalGraphKitchen,
-        outDirectoryUrl: new URL(".jsenv/postbuild/", rootDirectoryUrl),
-        writeGeneratedFiles,
-        skipResourceHint: true,
-        startLoading: (cookEntryFile) => {
-          entryUrls.forEach((entryUrl) => {
-            const [, postBuildEntryUrlInfo] = cookEntryFile({
-              trace: { message: `entryPoint` },
+    const finalEntryUrls = []
+
+    craft: {
+      const loadTask = createTaskLog("load", {
+        disabled: logger.levels.debug || !logger.levels.info,
+      })
+      try {
+        if (writeGeneratedFiles) {
+          await ensureEmptyDirectory(new URL(`.jsenv/build/`, rootDirectoryUrl))
+        }
+        const rawUrlGraphLoader = createUrlGraphLoader(
+          rawGraphKitchen.kitchenContext,
+        )
+        Object.keys(entryPoints).forEach((key) => {
+          const [entryReference, entryUrlInfo] =
+            rawGraphKitchen.kitchenContext.prepareEntryPoint({
+              trace: { message: `"${key}" in entryPoints parameter` },
+              parentUrl: rootDirectoryUrl,
               type: "entry_point",
-              specifier: entryUrl,
+              specifier: key,
             })
-            postBuildEntryUrls.push(postBuildEntryUrlInfo.url)
-          })
-        },
-      })
-    } catch (e) {
-      buildTask.fail()
-      throw e
+          entryUrls.push(entryUrlInfo.url)
+          entryUrlInfo.filename = entryPoints[key]
+          rawUrlGraphLoader.load(entryUrlInfo, { reference: entryReference })
+        })
+        await rawUrlGraphLoader.getAllLoadDonePromise(buildOperation)
+      } catch (e) {
+        loadTask.fail()
+        throw e
+      }
+      loadTask.done()
     }
-    buildTask.done()
 
-    logger.debug(
-      `graph urls pre-versioning:
-${Array.from(finalGraph.urlInfoMap.keys()).join("\n")}`,
-    )
-    if (versioning) {
-      await applyUrlVersioning({
-        buildOperation,
-        logger,
-        infoLogsAreDisabled,
-        buildDirectoryUrl,
-        rawUrls,
-        buildUrls,
-        baseUrl,
-        postBuildEntryUrls,
-        sourcemaps,
-        sourcemapsSourcesContent,
-        runtimeCompat,
-        writeGeneratedFiles,
-        rawGraph,
-        urlAnalysisPlugin,
-        finalGraph,
-        finalGraphKitchen,
-        lineBreakNormalization,
-        versioningMethod,
-      })
-    }
-    GRAPH.forEach(finalGraph, (urlInfo) => {
-      if (!urlInfo.shouldHandle) {
-        return
+    shape: {
+      bundle: {
+        rawGraphKitchen.pluginController.plugins.forEach((plugin) => {
+          const bundle = plugin.bundle
+          if (!bundle) {
+            return
+          }
+          if (typeof bundle !== "object") {
+            throw new Error(
+              `bundle must be an object, found "${bundle}" on plugin named "${plugin.name}"`,
+            )
+          }
+          Object.keys(bundle).forEach((type) => {
+            const bundleFunction = bundle[type]
+            if (!bundleFunction) {
+              return
+            }
+            const bundlerForThatType = bundlers[type]
+            if (bundlerForThatType) {
+              // first plugin to define a bundle hook wins
+              return
+            }
+            bundlers[type] = {
+              plugin,
+              bundleFunction: bundle[type],
+              urlInfos: [],
+            }
+          })
+        })
+        const addToBundlerIfAny = (rawUrlInfo) => {
+          const bundler = bundlers[rawUrlInfo.type]
+          if (bundler) {
+            bundler.urlInfos.push(rawUrlInfo)
+            return
+          }
+        }
+        GRAPH.forEach(rawGraph, (rawUrlInfo) => {
+          if (rawUrlInfo.isEntryPoint) {
+            addToBundlerIfAny(rawUrlInfo)
+            if (rawUrlInfo.type === "html") {
+              rawUrlInfo.dependencies.forEach((dependencyUrl) => {
+                const dependencyUrlInfo = rawGraph.getUrlInfo(dependencyUrl)
+                if (dependencyUrlInfo.isInline) {
+                  if (dependencyUrlInfo.type === "js_module") {
+                    // bundle inline script type module deps
+                    dependencyUrlInfo.references.forEach((inlineScriptRef) => {
+                      if (inlineScriptRef.type === "js_import_export") {
+                        const inlineUrlInfo = rawGraph.getUrlInfo(
+                          inlineScriptRef.url,
+                        )
+                        addToBundlerIfAny(inlineUrlInfo)
+                      }
+                    })
+                  }
+                  // inline content cannot be bundled
+                  return
+                }
+                addToBundlerIfAny(dependencyUrlInfo)
+              })
+              rawUrlInfo.references.forEach((reference) => {
+                if (
+                  reference.isResourceHint &&
+                  reference.expectedType === "js_module"
+                ) {
+                  const referencedUrlInfo = rawGraph.getUrlInfo(reference.url)
+                  if (
+                    referencedUrlInfo &&
+                    // something else than the resource hint is using this url
+                    referencedUrlInfo.dependents.size > 0
+                  ) {
+                    addToBundlerIfAny(referencedUrlInfo)
+                  }
+                }
+              })
+              return
+            }
+          }
+          // File referenced with new URL('./file.js', import.meta.url)
+          // are entry points that can be bundled
+          // For instance we will bundle service worker/workers detected like this
+          if (rawUrlInfo.type === "js_module") {
+            rawUrlInfo.references.forEach((reference) => {
+              if (reference.type === "js_url_specifier") {
+                const urlInfo = rawGraph.getUrlInfo(reference.url)
+                addToBundlerIfAny(urlInfo)
+              }
+            })
+          }
+        })
+        await Object.keys(bundlers).reduce(async (previous, type) => {
+          await previous
+          const bundler = bundlers[type]
+          const urlInfosToBundle = bundler.urlInfos
+          if (urlInfosToBundle.length === 0) {
+            return
+          }
+          const bundleTask = createTaskLog(`bundle "${type}"`, {
+            disabled: logger.levels.debug || !logger.levels.info,
+          })
+          try {
+            const bundlerGeneratedUrlInfos =
+              await rawGraphKitchen.pluginController.callAsyncHook(
+                {
+                  plugin: bundler.plugin,
+                  hookName: "bundle",
+                  value: bundler.bundleFunction,
+                },
+                urlInfosToBundle,
+                {
+                  ...rawGraphKitchen.kitchenContext,
+                  buildDirectoryUrl,
+                },
+              )
+            Object.keys(bundlerGeneratedUrlInfos).forEach((url) => {
+              const rawUrlInfo = rawGraph.getUrlInfo(url)
+              const bundlerGeneratedUrlInfo = bundlerGeneratedUrlInfos[url]
+              const bundleUrlInfo = {
+                type,
+                subtype: rawUrlInfo ? rawUrlInfo.subtype : undefined,
+                isEntryPoint: rawUrlInfo ? rawUrlInfo.isEntryPoint : undefined,
+                filename: rawUrlInfo ? rawUrlInfo.filename : undefined,
+                originalUrl: rawUrlInfo ? rawUrlInfo.originalUrl : undefined,
+                originalContent: rawUrlInfo
+                  ? rawUrlInfo.originalContent
+                  : undefined,
+                ...bundlerGeneratedUrlInfo,
+                data: {
+                  ...(rawUrlInfo ? rawUrlInfo.data : {}),
+                  ...bundlerGeneratedUrlInfo.data,
+                  fromBundle: true,
+                },
+              }
+              if (bundlerGeneratedUrlInfo.sourceUrls) {
+                bundlerGeneratedUrlInfo.sourceUrls.forEach((sourceUrl) => {
+                  const rawUrlInfo = rawGraph.getUrlInfo(sourceUrl)
+                  if (rawUrlInfo) {
+                    rawUrlInfo.data.bundled = true
+                  }
+                })
+              }
+              const buildUrl = buildUrlsGenerator.generate(url, {
+                urlInfo: bundleUrlInfo,
+              })
+              bundleRedirections.set(url, buildUrl)
+              if (urlIsInsideOf(url, buildDirectoryUrl)) {
+                // chunk generated by rollup to share code
+              } else {
+                associateBuildUrlAndRawUrl(buildUrl, url, "bundle")
+              }
+              bundleUrlInfos[buildUrl] = bundleUrlInfo
+              if (buildUrl.includes("?")) {
+                bundleUrlInfos[asUrlWithoutSearch(buildUrl)] = bundleUrlInfo
+              }
+              if (bundlerGeneratedUrlInfo.data.bundleRelativeUrl) {
+                const urlForBundler = new URL(
+                  bundlerGeneratedUrlInfo.data.bundleRelativeUrl,
+                  buildDirectoryUrl,
+                ).href
+                if (urlForBundler !== buildUrl) {
+                  bundleInternalRedirections.set(urlForBundler, buildUrl)
+                }
+              }
+            })
+          } catch (e) {
+            bundleTask.fail()
+            throw e
+          }
+          bundleTask.done()
+        }, Promise.resolve())
       }
-      if (!urlInfo.url.startsWith("file:")) {
-        return
+      reload_in_build_directory: {
+        const buildTask = createTaskLog("build", {
+          disabled: logger.levels.debug || !logger.levels.info,
+        })
+        try {
+          if (writeGeneratedFiles) {
+            await ensureEmptyDirectory(
+              new URL(`.jsenv/postbuild/`, rootDirectoryUrl),
+            )
+          }
+          const finalUrlGraphLoader = createUrlGraphLoader(
+            finalGraphKitchen.kitchenContext,
+          )
+          entryUrls.forEach((entryUrl) => {
+            const [finalEntryReference, finalEntryUrlInfo] =
+              finalGraphKitchen.kitchenContext.prepareEntryPoint({
+                trace: { message: `entryPoint` },
+                parentUrl: rootDirectoryUrl,
+                type: "entry_point",
+                specifier: entryUrl,
+              })
+            finalEntryUrls.push(finalEntryUrlInfo.url)
+            finalUrlGraphLoader.load(finalEntryUrlInfo, {
+              reference: finalEntryReference,
+            })
+          })
+          await finalUrlGraphLoader.getAllLoadDonePromise(buildOperation)
+        } catch (e) {
+          buildTask.fail()
+          throw e
+        }
+        buildTask.done()
+      }
+    }
+
+    refine: {
+      inject_version_in_urls: {
+        if (!versioning) {
+          break inject_version_in_urls
+        }
+        const versioningTask = createTaskLog("inject version in urls", {
+          disabled: logger.levels.debug || !logger.levels.info,
+        })
+        try {
+          const urlsSorted = sortByDependencies(finalGraph.toObject())
+          urlsSorted.forEach((url) => {
+            if (url.startsWith("data:")) {
+              return
+            }
+            const urlInfo = finalGraph.getUrlInfo(url)
+            if (urlInfo.type === "sourcemap") {
+              return
+            }
+            // ignore:
+            // - inline files:
+            //   they are already taken into account in the file where they appear
+            // - ignored files:
+            //   we don't know their content
+            // - unused files without reference
+            //   File updated such as style.css -> style.css.js or file.js->file.nomodule.js
+            //   Are used at some point just to be discarded later because they need to be converted
+            //   There is no need to version them and we could not because the file have been ignored
+            //   so their content is unknown
+            if (urlInfo.isInline) {
+              return
+            }
+            if (!urlInfo.shouldHandle) {
+              return
+            }
+            if (!urlInfo.isEntryPoint && urlInfo.dependents.size === 0) {
+              return
+            }
+            const urlContent =
+              urlInfo.type === "html"
+                ? stringifyHtmlAst(
+                    parseHtmlString(urlInfo.content, {
+                      storeOriginalPositions: false,
+                    }),
+                    { cleanupJsenvAttributes: true },
+                  )
+                : urlInfo.content
+            const versionGenerator = createVersionGenerator()
+            versionGenerator.augmentWithContent({
+              content: urlContent,
+              contentType: urlInfo.contentType,
+              lineBreakNormalization,
+            })
+            urlInfo.dependencies.forEach((dependencyUrl) => {
+              // this dependency is inline
+              if (dependencyUrl.startsWith("data:")) {
+                return
+              }
+              const dependencyUrlInfo = finalGraph.getUrlInfo(dependencyUrl)
+              if (
+                // this content is part of the file, no need to take into account twice
+                dependencyUrlInfo.isInline ||
+                // this dependency content is not known
+                !dependencyUrlInfo.shouldHandle
+              ) {
+                return
+              }
+              if (dependencyUrlInfo.data.version) {
+                versionGenerator.augmentWithDependencyVersion(
+                  dependencyUrlInfo.data.version,
+                )
+              } else {
+                // because all dependencies are know, if the dependency has no version
+                // it means there is a circular dependency between this file
+                // and it's dependency
+                // in that case we'll use the dependency content
+                versionGenerator.augmentWithContent({
+                  content: dependencyUrlInfo.content,
+                  contentType: dependencyUrlInfo.contentType,
+                  lineBreakNormalization,
+                })
+              }
+            })
+            urlInfo.data.version = versionGenerator.generate()
+
+            const buildUrlObject = new URL(urlInfo.url)
+            // remove ?as_js_classic as
+            // this information is already hold into ".nomodule"
+            buildUrlObject.searchParams.delete("as_js_classic")
+            buildUrlObject.searchParams.delete("as_js_classic_library")
+            buildUrlObject.searchParams.delete("as_json_module")
+            buildUrlObject.searchParams.delete("as_css_module")
+            buildUrlObject.searchParams.delete("as_text_module")
+            const buildUrl = buildUrlObject.href
+            finalRedirections.set(urlInfo.url, buildUrl)
+            urlInfo.data.versionedUrl = normalizeUrl(
+              injectVersionIntoBuildUrl({
+                buildUrl,
+                version: urlInfo.data.version,
+                versioningMethod,
+              }),
+            )
+          })
+          const versionMappings = {}
+          const usedVersionMappings = new Set()
+          const versioningKitchen = createKitchen({
+            logLevel: logger.level,
+            rootDirectoryUrl: buildDirectoryUrl,
+            urlGraph: finalGraph,
+            scenarios: { build: true },
+            runtimeCompat,
+            plugins: [
+              urlAnalysisPlugin,
+              jsenvPluginInline({
+                fetchInlineUrls: false,
+                analyzeConvertedScripts: true, // to be able to version their urls
+                allowEscapeForVersioning: true,
+              }),
+              {
+                name: "jsenv:versioning",
+                appliesDuring: "build",
+                resolveUrl: (reference) => {
+                  const buildUrl = buildUrls.get(reference.specifier)
+                  if (buildUrl) {
+                    return buildUrl
+                  }
+                  const urlObject = new URL(
+                    reference.specifier,
+                    reference.baseUrl || reference.parentUrl,
+                  )
+                  const url = urlObject.href
+                  // during versioning we revisit the deps
+                  // but the code used to enforce trailing slash on directories
+                  // is not applied because "jsenv:file_url_resolution" is not used
+                  // so here we search if the url with a trailing slash exists
+                  if (
+                    reference.type === "filesystem" &&
+                    !urlObject.pathname.endsWith("/")
+                  ) {
+                    const urlWithTrailingSlash = `${url}/`
+                    const specifier = findKey(buildUrls, urlWithTrailingSlash)
+                    if (specifier) {
+                      return urlWithTrailingSlash
+                    }
+                  }
+                  return url
+                },
+                formatUrl: (reference) => {
+                  if (!reference.shouldHandle) {
+                    if (reference.generatedUrl.startsWith("ignore:")) {
+                      return reference.generatedUrl.slice("ignore:".length)
+                    }
+                    return null
+                  }
+                  if (reference.isInline || reference.url.startsWith("data:")) {
+                    return null
+                  }
+                  if (reference.isResourceHint) {
+                    return null
+                  }
+                  // specifier comes from "normalize" hook done a bit earlier in this file
+                  // we want to get back their build url to access their infos
+                  const referencedUrlInfo = finalGraph.getUrlInfo(reference.url)
+                  if (!canUseVersionedUrl(referencedUrlInfo)) {
+                    return reference.specifier
+                  }
+                  if (!referencedUrlInfo.shouldHandle) {
+                    return null
+                  }
+                  const versionedUrl = referencedUrlInfo.data.versionedUrl
+                  if (!versionedUrl) {
+                    // happens for sourcemap
+                    return `${baseUrl}${urlToRelativeUrl(
+                      referencedUrlInfo.url,
+                      buildDirectoryUrl,
+                    )}`
+                  }
+                  const versionedSpecifier = `${baseUrl}${urlToRelativeUrl(
+                    versionedUrl,
+                    buildDirectoryUrl,
+                  )}`
+                  versionMappings[reference.specifier] = versionedSpecifier
+                  versioningRedirections.set(reference.url, versionedUrl)
+                  buildUrls.set(versionedSpecifier, versionedUrl)
+
+                  const parentUrlInfo = finalGraph.getUrlInfo(
+                    reference.parentUrl,
+                  )
+                  if (parentUrlInfo.jsQuote) {
+                    // the url is inline inside js quotes
+                    usedVersionMappings.add(reference.specifier)
+                    return () =>
+                      `${parentUrlInfo.jsQuote}+__v__(${JSON.stringify(
+                        reference.specifier,
+                      )})+${parentUrlInfo.jsQuote}`
+                  }
+                  if (
+                    reference.type === "js_url_specifier" ||
+                    reference.subtype === "import_dynamic"
+                  ) {
+                    usedVersionMappings.add(reference.specifier)
+                    return () => `__v__(${JSON.stringify(reference.specifier)})`
+                  }
+                  return versionedSpecifier
+                },
+                fetchUrlContent: (versionedUrlInfo) => {
+                  if (versionedUrlInfo.isInline) {
+                    const rawUrlInfo = rawGraph.getUrlInfo(
+                      buildToRawUrls[versionedUrlInfo.url],
+                    )
+                    const finalUrlInfo = finalGraph.getUrlInfo(
+                      versionedUrlInfo.url,
+                    )
+                    return {
+                      content: versionedUrlInfo.content,
+                      contentType: versionedUrlInfo.contentType,
+                      originalContent: rawUrlInfo
+                        ? rawUrlInfo.originalContent
+                        : undefined,
+                      sourcemap: finalUrlInfo
+                        ? finalUrlInfo.sourcemap
+                        : undefined,
+                    }
+                  }
+                  return versionedUrlInfo
+                },
+              },
+            ],
+            sourcemaps,
+            sourcemapsSourcesContent,
+            sourcemapsRelativeSources: true,
+            writeGeneratedFiles,
+            outDirectoryUrl: new URL(
+              ".jsenv/postbuild/",
+              finalGraphKitchen.rootDirectoryUrl,
+            ),
+          })
+          const versioningUrlGraphLoader = createUrlGraphLoader(
+            versioningKitchen.kitchenContext,
+          )
+          finalEntryUrls.forEach((finalEntryUrl) => {
+            const [finalEntryReference, finalEntryUrlInfo] =
+              finalGraphKitchen.kitchenContext.prepareEntryPoint({
+                trace: { message: `entryPoint` },
+                parentUrl: buildDirectoryUrl,
+                type: "entry_point",
+                specifier: finalEntryUrl,
+              })
+            versioningUrlGraphLoader.load(finalEntryUrlInfo, {
+              reference: finalEntryReference,
+            })
+          })
+          await versioningUrlGraphLoader.getAllLoadDonePromise(buildOperation)
+          if (usedVersionMappings.size) {
+            const versionMappingsNeeded = {}
+            usedVersionMappings.forEach((specifier) => {
+              versionMappingsNeeded[specifier] = versionMappings[specifier]
+            })
+            const actions = []
+            GRAPH.forEach(finalGraph, (urlInfo) => {
+              if (urlInfo.isEntryPoint) {
+                actions.push(async () => {
+                  await injectVersionMappings({
+                    urlInfo,
+                    kitchen: finalGraphKitchen,
+                    versionMappings: versionMappingsNeeded,
+                  })
+                })
+              }
+            })
+            await Promise.all(actions.map((action) => action()))
+          }
+        } catch (e) {
+          versioningTask.fail()
+          throw e
+        }
+        versioningTask.done()
       }
-      if (urlInfo.type === "html") {
-        const htmlAst = parseHtmlString(urlInfo.content, {
-          storeOriginalPositions: false,
+      cleanup_jsenv_attributes_from_html: {
+        GRAPH.forEach(finalGraph, (urlInfo) => {
+          if (!urlInfo.shouldHandle) {
+            return
+          }
+          if (!urlInfo.url.startsWith("file:")) {
+            return
+          }
+          if (urlInfo.type === "html") {
+            const htmlAst = parseHtmlString(urlInfo.content, {
+              storeOriginalPositions: false,
+            })
+            urlInfo.content = stringifyHtmlAst(htmlAst, {
+              cleanupJsenvAttributes: true,
+            })
+          }
         })
-        urlInfo.content = stringifyHtmlAst(htmlAst, {
-          removeOriginalPositionAttributes: true,
+      }
+      /*
+       * Update <link rel="preload"> and friends after build (once we know everything)
+       * - Used to remove resource hint targeting an url that is no longer used:
+       *   - Happens because of import assertions transpilation (file is inlined into JS)
+       */
+      resync_resource_hints: {
+        const actions = []
+        GRAPH.forEach(finalGraph, (urlInfo) => {
+          if (urlInfo.type !== "html") {
+            return
+          }
+          actions.push(async () => {
+            const htmlAst = parseHtmlString(urlInfo.content, {
+              storeOriginalPositions: false,
+            })
+            const mutations = []
+            visitHtmlNodes(htmlAst, {
+              link: (node) => {
+                const href = getHtmlNodeAttribute(node, "href")
+                if (href === undefined || href.startsWith("data:")) {
+                  return
+                }
+                const rel = getHtmlNodeAttribute(node, "rel")
+                const isResourceHint = [
+                  "preconnect",
+                  "dns-prefetch",
+                  "prefetch",
+                  "preload",
+                  "modulepreload",
+                ].includes(rel)
+                if (!isResourceHint) {
+                  return
+                }
+                const onBuildUrl = (buildUrl) => {
+                  const buildUrlInfo = buildUrl
+                    ? finalGraph.getUrlInfo(buildUrl)
+                    : null
+                  if (!buildUrlInfo) {
+                    logger.warn(
+                      `remove resource hint because cannot find "${href}" in the graph`,
+                    )
+                    mutations.push(() => {
+                      removeHtmlNode(node)
+                    })
+                    return
+                  }
+                  if (buildUrlInfo.dependents.size === 0) {
+                    logger.info(
+                      `remove resource hint because "${href}" not used anymore`,
+                    )
+                    mutations.push(() => {
+                      removeHtmlNode(node)
+                    })
+                    return
+                  }
+                  const buildUrlFormatted =
+                    versioningRedirections.get(buildUrlInfo.url) ||
+                    buildUrlInfo.url
+                  const buildSpecifierBeforeRedirect = findKey(
+                    buildUrls,
+                    buildUrlFormatted,
+                  )
+                  mutations.push(() => {
+                    setHtmlNodeAttributes(node, {
+                      href: buildSpecifierBeforeRedirect,
+                      crossorigin: undefined,
+                    })
+                  })
+                }
+                if (href.startsWith("file:")) {
+                  let url = href
+                  url = rawRedirections.get(url) || url
+                  const rawUrlInfo = rawGraph.getUrlInfo(url)
+                  if (rawUrlInfo && rawUrlInfo.data.bundled) {
+                    logger.info(
+                      `remove resource hint on "${href}" because it was bundled`,
+                    )
+                    mutations.push(() => {
+                      removeHtmlNode(node)
+                    })
+                  } else {
+                    url = bundleRedirections.get(url) || url
+                    url = bundleInternalRedirections.get(url) || url
+                    url = finalRedirections.get(url) || url
+                    onBuildUrl(url)
+                  }
+                } else {
+                  onBuildUrl(null)
+                }
+              },
+            })
+            if (mutations.length > 0) {
+              mutations.forEach((mutation) => mutation())
+              await finalGraphKitchen.urlInfoTransformer.applyFinalTransformations(
+                urlInfo,
+                {
+                  content: stringifyHtmlAst(htmlAst),
+                },
+              )
+            }
+          })
         })
+        await Promise.all(
+          actions.map((resourceHintAction) => resourceHintAction()),
+        )
+        buildOperation.throwIfAborted()
       }
-      const version = urlInfo.data.version
-      const useVersionedUrl = version && canUseVersionedUrl(urlInfo, finalGraph)
-      const buildUrl = useVersionedUrl ? urlInfo.data.versionedUrl : urlInfo.url
-      const buildUrlSpecifier = Object.keys(buildUrls).find(
-        (key) => buildUrls[key] === buildUrl,
-      )
-      urlInfo.data.buildUrl = buildUrl
-      urlInfo.data.buildUrlIsVersioned = useVersionedUrl
-      urlInfo.data.buildUrlSpecifier = buildUrlSpecifier
-    })
-    await resyncResourceHints({
-      logger,
-      finalGraphKitchen,
-      finalGraph,
-      rawUrls,
-      postBuildRedirections,
-    })
-    buildOperation.throwIfAborted()
-    const cleanupActions = []
-    GRAPH.forEach(finalGraph, (urlInfo) => {
-      // nothing uses this url anymore
-      // - versioning update inline content
-      // - file converted for import assertion of js_classic conversion
-      if (
-        !urlInfo.isEntryPoint &&
-        urlInfo.type !== "sourcemap" &&
-        urlInfo.dependents.size === 0
-      ) {
-        cleanupActions.push(() => {
-          finalGraph.deleteUrlInfo(urlInfo.url)
+      delete_unused_urls: {
+        const actions = []
+        GRAPH.forEach(finalGraph, (urlInfo) => {
+          // nothing uses this url anymore
+          // - versioning update inline content
+          // - file converted for import assertion or js_classic conversion
+          if (
+            !urlInfo.isEntryPoint &&
+            urlInfo.type !== "sourcemap" &&
+            urlInfo.dependents.size === 0 &&
+            !urlInfo.injected // injected during postbuild
+          ) {
+            actions.push(() => {
+              finalGraph.deleteUrlInfo(urlInfo.url)
+            })
+          }
         })
+        actions.forEach((action) => action())
       }
-    })
-    cleanupActions.forEach((cleanupAction) => cleanupAction())
-    await injectServiceWorkerUrls({
-      finalGraphKitchen,
-      finalGraph,
-      lineBreakNormalization,
-    })
-    buildOperation.throwIfAborted()
+      inject_urls_in_service_workers: {
+        const serviceWorkerEntryUrlInfos = GRAPH.filter(
+          finalGraph,
+          (finalUrlInfo) => {
+            return (
+              finalUrlInfo.subtype === "service_worker" &&
+              finalUrlInfo.isEntryPoint
+            )
+          },
+        )
+        if (serviceWorkerEntryUrlInfos.length > 0) {
+          const serviceWorkerUrls = {}
+          GRAPH.forEach(finalGraph, (urlInfo) => {
+            if (urlInfo.isInline || !urlInfo.shouldHandle) {
+              return
+            }
+            if (!urlInfo.url.startsWith("file:")) {
+              return
+            }
+            const versionedUrl = urlInfo.data.versionedUrl
+            if (!versionedUrl) {
+              // when url is not versioned we compute a "version" for that url anyway
+              // so that service worker source still changes and navigator
+              // detect there is a change
+              const versionGenerator = createVersionGenerator()
+              versionGenerator.augmentWithContent({
+                content: urlInfo.content,
+                contentType: urlInfo.contentType,
+                lineBreakNormalization,
+              })
+              const version = versionGenerator.generate()
+              urlInfo.data.version = version
+              const specifier = findKey(buildUrls, urlInfo.url)
+              serviceWorkerUrls[specifier] = { versioned: false, version }
+              return
+            }
+            if (!canUseVersionedUrl(urlInfo)) {
+              const specifier = findKey(buildUrls, urlInfo.url)
+              serviceWorkerUrls[specifier] = {
+                versioned: false,
+                version: urlInfo.data.version,
+              }
+              return
+            }
+            const versionedSpecifier = findKey(buildUrls, versionedUrl)
+            serviceWorkerUrls[versionedSpecifier] = { versioned: true }
+          })
+          serviceWorkerEntryUrlInfos.forEach((serviceWorkerEntryUrlInfo) => {
+            const magicSource = createMagicSource(
+              serviceWorkerEntryUrlInfo.content,
+            )
+            const urlsWithoutSelf = {
+              ...serviceWorkerUrls,
+            }
+            const serviceWorkerSpecifier = findKey(
+              buildUrls,
+              serviceWorkerEntryUrlInfo.url,
+            )
+            delete urlsWithoutSelf[serviceWorkerSpecifier]
+            magicSource.prepend(
+              `\nself.serviceWorkerUrls = ${JSON.stringify(
+                urlsWithoutSelf,
+                null,
+                "  ",
+              )};\n`,
+            )
+            const { content, sourcemap } = magicSource.toContentAndSourcemap()
+            finalGraphKitchen.urlInfoTransformer.applyFinalTransformations(
+              serviceWorkerEntryUrlInfo,
+              {
+                content,
+                sourcemap,
+              },
+            )
+          })
+        }
+        buildOperation.throwIfAborted()
+      }
+    }
 
     const buildManifest = {}
     const buildFileContents = {}
@@ -830,19 +1325,32 @@ ${Array.from(finalGraph.urlInfoMap.keys()).join("\n")}`,
       if (urlInfo.type === "directory") {
         return
       }
-      const buildRelativeUrl = urlToRelativeUrl(
-        urlInfo.data.buildUrl,
-        buildDirectoryUrl,
-      )
       if (urlInfo.isInline) {
-        buildInlineContents[buildRelativeUrl] = urlInfo.content
-      } else {
-        buildFileContents[buildRelativeUrl] = urlInfo.content
-        const buildRelativeUrlWithoutVersioning = urlToRelativeUrl(
+        const buildRelativeUrl = urlToRelativeUrl(
           urlInfo.url,
           buildDirectoryUrl,
         )
-        buildManifest[buildRelativeUrlWithoutVersioning] = buildRelativeUrl
+        buildInlineContents[buildRelativeUrl] = urlInfo.content
+      } else {
+        const versionedUrl = urlInfo.data.versionedUrl
+        if (versionedUrl && canUseVersionedUrl(urlInfo)) {
+          const buildRelativeUrl = urlToRelativeUrl(
+            urlInfo.url,
+            buildDirectoryUrl,
+          )
+          const versionedBuildRelativeUrl = urlToRelativeUrl(
+            versionedUrl,
+            buildDirectoryUrl,
+          )
+          buildFileContents[versionedBuildRelativeUrl] = urlInfo.content
+          buildManifest[buildRelativeUrl] = versionedBuildRelativeUrl
+        } else {
+          const buildRelativeUrl = urlToRelativeUrl(
+            urlInfo.url,
+            buildDirectoryUrl,
+          )
+          buildFileContents[buildRelativeUrl] = urlInfo.content
+        }
       }
     })
     if (writeOnFileSystem) {
@@ -850,16 +1358,14 @@ ${Array.from(finalGraph.urlInfoMap.keys()).join("\n")}`,
         await ensureEmptyDirectory(buildDirectoryUrl)
       }
       const buildRelativeUrls = Object.keys(buildFileContents)
-      await Promise.all(
-        buildRelativeUrls.map(async (buildRelativeUrl) => {
-          await writeFile(
-            new URL(buildRelativeUrl, buildDirectoryUrl),
-            buildFileContents[buildRelativeUrl],
-          )
-        }),
-      )
+      buildRelativeUrls.forEach((buildRelativeUrl) => {
+        writeFileSync(
+          new URL(buildRelativeUrl, buildDirectoryUrl),
+          buildFileContents[buildRelativeUrl],
+        )
+      })
       if (versioning && assetManifest && Object.keys(buildManifest).length) {
-        await writeFile(
+        writeFileSync(
           new URL(assetManifestFileRelativeUrl, buildDirectoryUrl),
           JSON.stringify(buildManifest, null, "  "),
         )
@@ -948,271 +1454,13 @@ ${Array.from(finalGraph.urlInfoMap.keys()).join("\n")}`,
   return stopWatchingClientFiles
 }
 
-const applyUrlVersioning = async ({
-  buildOperation,
-  logger,
-  infoLogsAreDisabled,
-  buildDirectoryUrl,
-  rawUrls,
-  buildUrls,
-  baseUrl,
-  postBuildEntryUrls,
-  sourcemaps,
-  sourcemapsSourcesContent,
-  runtimeCompat,
-  writeGeneratedFiles,
-  rawGraph,
-  urlAnalysisPlugin,
-  finalGraph,
-  finalGraphKitchen,
-  lineBreakNormalization,
-  versioningMethod,
-}) => {
-  const versioningTask = createTaskLog("inject version in urls", {
-    disabled: infoLogsAreDisabled,
-  })
-  try {
-    const urlsSorted = sortByDependencies(finalGraph.toObject())
-    urlsSorted.forEach((url) => {
-      if (url.startsWith("data:")) {
-        return
-      }
-      const urlInfo = finalGraph.getUrlInfo(url)
-      if (urlInfo.type === "sourcemap") {
-        return
-      }
-      // ignore:
-      // - inline files:
-      //   they are already taken into account in the file where they appear
-      // - ignored files:
-      //   we don't know their content
-      // - unused files without reference
-      //   File updated such as style.css -> style.css.js or file.js->file.nomodule.js
-      //   Are used at some point just to be discarded later because they need to be converted
-      //   There is no need to version them and we could not because the file have been ignored
-      //   so their content is unknown
-      if (urlInfo.isInline) {
-        return
-      }
-      if (!urlInfo.shouldHandle) {
-        return
-      }
-      if (!urlInfo.isEntryPoint && urlInfo.dependents.size === 0) {
-        return
-      }
-
-      const urlContent =
-        urlInfo.type === "html"
-          ? stringifyHtmlAst(
-              parseHtmlString(urlInfo.content, {
-                storeOriginalPositions: false,
-              }),
-              { removeOriginalPositionAttributes: true },
-            )
-          : urlInfo.content
-      const versionGenerator = createVersionGenerator()
-      versionGenerator.augmentWithContent({
-        content: urlContent,
-        contentType: urlInfo.contentType,
-        lineBreakNormalization,
-      })
-      urlInfo.dependencies.forEach((dependencyUrl) => {
-        // this dependency is inline
-        if (dependencyUrl.startsWith("data:")) {
-          return
-        }
-        const dependencyUrlInfo = finalGraph.getUrlInfo(dependencyUrl)
-        if (
-          // this content is part of the file, no need to take into account twice
-          dependencyUrlInfo.isInline ||
-          // this dependency content is not known
-          !dependencyUrlInfo.shouldHandle
-        ) {
-          return
-        }
-        if (dependencyUrlInfo.data.version) {
-          versionGenerator.augmentWithDependencyVersion(
-            dependencyUrlInfo.data.version,
-          )
-        } else {
-          // because all dependencies are know, if the dependency has no version
-          // it means there is a circular dependency between this file
-          // and it's dependency
-          // in that case we'll use the dependency content
-          versionGenerator.augmentWithContent({
-            content: dependencyUrlInfo.content,
-            contentType: dependencyUrlInfo.contentType,
-            lineBreakNormalization,
-          })
-        }
-      })
-      urlInfo.data.version = versionGenerator.generate()
-
-      urlInfo.data.versionedUrl = normalizeUrl(
-        injectVersionIntoBuildUrl({
-          buildUrl: urlInfo.url,
-          version: urlInfo.data.version,
-          versioningMethod,
-        }),
-      )
-    })
-    const versionMappings = {}
-    const usedVersionMappings = []
-    const versioningKitchen = createKitchen({
-      logger,
-      rootDirectoryUrl: buildDirectoryUrl,
-      urlGraph: finalGraph,
-      scenarios: { build: true },
-      sourcemaps,
-      sourcemapsSourcesContent,
-      sourcemapsRelativeSources: true,
-      runtimeCompat,
-      writeGeneratedFiles,
-      plugins: [
-        urlAnalysisPlugin,
-        jsenvPluginInline({
-          fetchInlineUrls: false,
-          analyzeConvertedScripts: true, // to be able to version their urls
-          allowEscapeForVersioning: true,
-        }),
-        {
-          name: "jsenv:versioning",
-          appliesDuring: "build",
-          resolveUrl: (reference) => {
-            const buildUrl = buildUrls[reference.specifier]
-            if (buildUrl) {
-              return buildUrl
-            }
-            const urlObject = new URL(
-              reference.specifier,
-              reference.baseUrl || reference.parentUrl,
-            )
-            const url = urlObject.href
-            // during versioning we revisit the deps
-            // but the code used to enforce trailing slash on directories
-            // is not applied because "jsenv:file_url_resolution" is not used
-            // so here we search if the url with a trailing slash exists
-            if (
-              reference.type === "filesystem" &&
-              !urlObject.pathname.endsWith("/")
-            ) {
-              const urlWithTrailingSlash = `${url}/`
-              const specifier = Object.keys(buildUrls).find(
-                (key) => buildUrls[key] === urlWithTrailingSlash,
-              )
-              if (specifier) {
-                return urlWithTrailingSlash
-              }
-            }
-            return url
-          },
-          formatUrl: (reference) => {
-            if (!reference.shouldHandle) {
-              if (reference.generatedUrl.startsWith("ignore:")) {
-                return reference.generatedUrl.slice("ignore:".length)
-              }
-              return null
-            }
-            if (reference.isInline || reference.url.startsWith("data:")) {
-              return null
-            }
-            if (reference.isResourceHint) {
-              return null
-            }
-            // specifier comes from "normalize" hook done a bit earlier in this file
-            // we want to get back their build url to access their infos
-            const referencedUrlInfo = finalGraph.getUrlInfo(reference.url)
-            if (!canUseVersionedUrl(referencedUrlInfo)) {
-              return reference.specifier
-            }
-            if (!referencedUrlInfo.shouldHandle) {
-              return null
-            }
-            const versionedUrl = referencedUrlInfo.data.versionedUrl
-            if (!versionedUrl) {
-              // happens for sourcemap
-              return `${baseUrl}${urlToRelativeUrl(
-                referencedUrlInfo.url,
-                buildDirectoryUrl,
-              )}`
-            }
-            const versionedSpecifier = `${baseUrl}${urlToRelativeUrl(
-              versionedUrl,
-              buildDirectoryUrl,
-            )}`
-            versionMappings[reference.specifier] = versionedSpecifier
-            buildUrls[versionedSpecifier] = versionedUrl
-
-            const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl)
-            if (parentUrlInfo.jsQuote) {
-              // the url is inline inside js quotes
-              usedVersionMappings.push(reference.specifier)
-              return () =>
-                `${parentUrlInfo.jsQuote}+__v__(${JSON.stringify(
-                  reference.specifier,
-                )})+${parentUrlInfo.jsQuote}`
-            }
-            if (
-              reference.type === "js_url_specifier" ||
-              reference.subtype === "import_dynamic"
-            ) {
-              usedVersionMappings.push(reference.specifier)
-              return () => `__v__(${JSON.stringify(reference.specifier)})`
-            }
-            return versionedSpecifier
-          },
-          fetchUrlContent: (versionedUrlInfo) => {
-            if (versionedUrlInfo.isInline) {
-              const rawUrlInfo = rawGraph.getUrlInfo(
-                rawUrls[versionedUrlInfo.url],
-              )
-              const finalUrlInfo = finalGraph.getUrlInfo(versionedUrlInfo.url)
-              return {
-                content: versionedUrlInfo.content,
-                contentType: versionedUrlInfo.contentType,
-                originalContent: rawUrlInfo
-                  ? rawUrlInfo.originalContent
-                  : undefined,
-                sourcemap: finalUrlInfo ? finalUrlInfo.sourcemap : undefined,
-              }
-            }
-            return versionedUrlInfo
-          },
-        },
-      ],
-    })
-    await loadUrlGraph({
-      operation: buildOperation,
-      urlGraph: finalGraph,
-      kitchen: versioningKitchen,
-      skipResourceHint: true,
-      writeGeneratedFiles,
-      startLoading: (cookEntryFile) => {
-        postBuildEntryUrls.forEach((postBuildEntryUrl) => {
-          cookEntryFile({
-            trace: `entryPoint`,
-            type: "entry_point",
-            specifier: postBuildEntryUrl,
-          })
-        })
-      },
-    })
-    if (usedVersionMappings.length) {
-      const versionMappingsNeeded = {}
-      usedVersionMappings.forEach((specifier) => {
-        versionMappingsNeeded[specifier] = versionMappings[specifier]
-      })
-      await injectGlobalVersionMapping({
-        finalGraphKitchen,
-        finalGraph,
-        versionMappings: versionMappingsNeeded,
-      })
+const findKey = (map, value) => {
+  for (const [keyCandidate, valueCandidate] of map) {
+    if (valueCandidate === value) {
+      return keyCandidate
     }
-  } catch (e) {
-    versioningTask.fail()
-    throw e
   }
-  versioningTask.done()
+  return undefined
 }
 
 const injectVersionIntoBuildUrl = ({ buildUrl, version, versioningMethod }) => {