@jsenv/core 27.0.0-alpha.2 → 27.0.0-alpha.20

package/src/build/build.js

@@ -21,28 +21,30 @@ import { createTaskLog } from "@jsenv/utils/logs/task_log.js"
 import {
   injectQueryParams,
   setUrlFilename,
+  asUrlUntilPathname,
 } from "@jsenv/utils/urls/url_utils.js"
-import { createUrlVersionGenerator } from "@jsenv/utils/urls/url_version_generator.js"
+import { createVersionGenerator } from "@jsenv/utils/versioning/version_generator.js"
 import { generateSourcemapUrl } from "@jsenv/utils/sourcemap/sourcemap_utils.js"
 import {
   parseHtmlString,
   stringifyHtmlAst,
 } from "@jsenv/utils/html_ast/html_ast.js"
 
-import { defaultRuntimeSupport } from "../omega/runtime_support/default_runtime_support.js"
-import { jsenvPluginInline } from "../omega/core_plugins/inline/jsenv_plugin_inline.js"
+import { jsenvPluginInline } from "../plugins/inline/jsenv_plugin_inline.js"
+import { jsenvPluginAsJsClassic } from "../plugins/transpilation/as_js_classic/jsenv_plugin_as_js_classic.js"
 import { createUrlGraph } from "../omega/url_graph.js"
-import { getCorePlugins } from "../omega/core_plugins.js"
+import { getCorePlugins } from "../plugins/plugins.js"
 import { createKitchen } from "../omega/kitchen.js"
 import { loadUrlGraph } from "../omega/url_graph/url_graph_load.js"
 import { createUrlGraphSummary } from "../omega/url_graph/url_graph_report.js"
 import { sortUrlGraphByDependencies } from "../omega/url_graph/url_graph_sort.js"
+import { isWebWorkerEntryPointReference } from "../omega/web_workers.js"
 
+import { GRAPH } from "./graph_utils.js"
 import { createBuilUrlsGenerator } from "./build_urls_generator.js"
-import { injectVersionMappings } from "./inject_version_mappings.js"
-import { jsenvPluginBundleJsModule } from "./plugins/bundle_js_module/jsenv_plugin_bundle_js_module.js"
-import { jsenvPluginMinifyJs } from "./plugins/minify_js/jsenv_plugin_minify_js.js"
-import { jsenvPluginMinifyHtml } from "./plugins/minify_html/jsenv_plugin_minify_html.js"
+import { injectGlobalVersionMapping } from "./inject_global_version_mappings.js"
+import { injectServiceWorkerUrls } from "./inject_service_worker_urls.js"
+import { resyncRessourceHints } from "./resync_ressource_hints.js"
 
 export const build = async ({
   signal = new AbortController().signal,
@@ -54,37 +56,40 @@ export const build = async ({
   // that will just pass different options to build project
   // and this function will be agnostic about "preview" concept
   isPreview = false,
+
   plugins = [],
-  htmlSupervisor,
+  sourcemaps = isPreview ? "file" : false,
   nodeEsmResolution,
   fileSystemMagicResolution,
-  babel,
-  runtimeSupport = defaultRuntimeSupport,
-  sourcemaps = isPreview ? "file" : false,
-
+  injectedGlobals,
+  runtimeCompat,
+  transpilation = {},
   bundling = true,
-  minify = true,
-  versioning = "filename", //  "filename", "search_param", "none"
+  minification = true,
+  versioning = true,
+  versioningMethod = "search_param", // "filename", "search_param"
   lineBreakNormalization = process.platform === "win32",
 
   writeOnFileSystem = true,
   buildDirectoryClean = true,
   baseUrl = "/",
+  assetManifest = true,
+  assetManifestFileRelativeUrl = "asset-manifest.json",
 }) => {
   const logger = createLogger({ logLevel })
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
   buildDirectoryUrl = assertAndNormalizeDirectoryUrl(buildDirectoryUrl)
   assertEntryPoints({ entryPoints })
-  if (!["filename", "search_param", "none"].includes(versioning)) {
+  if (!["filename", "search_param"].includes(versioningMethod)) {
     throw new Error(
-      `Unexpected "versioning": must be "filename", "search_param" or "none"; got ${versioning}`,
+      `Unexpected "versioningMethod": must be "filename", "search_param"; got ${versioning}`,
     )
   }
 
   const entryPointKeys = Object.keys(entryPoints)
   if (entryPointKeys.length === 1) {
     logger.info(`
-build ${entryPointKeys[0]}`)
+build "${entryPointKeys[0]}"`)
   } else {
     logger.info(`
 build ${entryPointKeys.length} entry points`)
@@ -97,6 +102,9 @@ build ${entryPointKeys.length} entry points`)
     logger,
     rootDirectoryUrl,
     urlGraph: rawGraph,
+    scenario: "build",
+    sourcemaps,
+    runtimeCompat,
     plugins: [
       ...plugins,
       {
@@ -108,33 +116,34 @@ build ${entryPointKeys.length} entry points`)
         },
       },
       ...getCorePlugins({
-        htmlSupervisor,
         nodeEsmResolution,
         fileSystemMagicResolution,
-        babel,
+        injectedGlobals,
+        transpilation: {
+          ...transpilation,
+          jsModuleAsJsClassic: false,
+        },
+        minification,
+        bundling,
       }),
-      jsenvPluginBundleJsModule(),
-      ...(minify ? [jsenvPluginMinifyJs(), jsenvPluginMinifyHtml()] : []),
     ],
-    scenario: "build",
-    sourcemaps,
   })
-  const loadEntryFiles = (cookEntryFile) => {
-    Object.keys(entryPoints).forEach((key) => {
-      cookEntryFile({
-        trace: `"${key}" in entryPoints parameter`,
-        type: "entry_point",
-        specifier: key,
-      })
-    })
-  }
+  const entryUrls = []
   try {
     await loadUrlGraph({
       urlGraph: rawGraph,
       kitchen: rawGraphKitchen,
       outDirectoryUrl: new URL(`.jsenv/build/`, rootDirectoryUrl),
-      runtimeSupport,
-      startLoading: loadEntryFiles,
+      startLoading: (cookEntryFile) => {
+        Object.keys(entryPoints).forEach((key) => {
+          const [, entryUrlInfo] = cookEntryFile({
+            trace: `"${key}" in entryPoints parameter`,
+            type: "entry_point",
+            specifier: key,
+          })
+          entryUrls.push(entryUrlInfo.url)
+        })
+      },
     })
   } catch (e) {
     prebuildTask.fail()
@@ -147,44 +156,50 @@ build ${entryPointKeys.length} entry points`)
 ${Object.keys(rawGraph.urlInfos).join("\n")}`,
   )
 
+  const buildUrlsGenerator = createBuilUrlsGenerator({
+    buildDirectoryUrl,
+  })
+  const rawUrls = {}
+  const buildUrls = {}
+  const rawUrlRedirections = {}
   const bundleUrlInfos = {}
-  if (bundling) {
-    const bundlers = {}
-    rawGraphKitchen.pluginController.plugins.forEach((plugin) => {
-      const bundle = plugin.bundle
-      if (!bundle) {
+  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
       }
-      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 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)
+      const bundlerForThatType = bundlers[type]
+      if (bundlerForThatType) {
+        // first plugin to define a bundle hook wins
         return
       }
-    }
-    Object.keys(rawGraph.urlInfos).forEach((rawUrl) => {
-      const rawUrlInfo = rawGraph.getUrlInfo(rawUrl)
-      if (!rawUrlInfo.data.isEntryPoint) {
-        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.data.isEntryPoint) {
       addToBundlerIfAny(rawUrlInfo)
       if (rawUrlInfo.type === "html") {
         rawUrlInfo.dependencies.forEach((dependencyUrl) => {
@@ -194,7 +209,8 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
               // bundle inline script type module deps
               dependencyUrlInfo.references.forEach((inlineScriptRef) => {
                 if (inlineScriptRef.type === "js_import_export") {
-                  addToBundlerIfAny(rawGraph.getUrlInfo(inlineScriptRef.url))
+                  const inlineUrlInfo = rawGraph.getUrlInfo(inlineScriptRef.url)
+                  addToBundlerIfAny(inlineUrlInfo)
                 }
               })
             }
@@ -205,231 +221,308 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
         })
         return
       }
-    })
-    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(logger, `bundle "${type}"`)
-      try {
-        const bundlerGeneratedUrlInfos =
-          await rawGraphKitchen.pluginController.callAsyncHook(
-            {
-              plugin: bundler.plugin,
-              hookName: "bundle",
-              value: bundler.bundleFunction,
-            },
-            urlInfosToBundle,
-            {
-              signal,
-              logger,
-              rootDirectoryUrl,
-              buildDirectoryUrl,
-              urlGraph: rawGraph,
-              runtimeSupport,
-              sourcemaps,
-            },
-          )
-        Object.keys(bundlerGeneratedUrlInfos).forEach((url) => {
-          const bundleUrlInfo = bundlerGeneratedUrlInfos[url]
-          const rawUrlInfo = rawGraph.getUrlInfo(url)
-          bundleUrlInfos[url] = {
-            type,
-            ...bundleUrlInfo,
-            data: {
-              ...(rawUrlInfo ? rawUrlInfo.data : {}),
-              ...bundleUrlInfo.data,
-              fromBundle: true,
-            },
-          }
+    }
+    // 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(logger, `bundle "${type}"`)
+    try {
+      const bundlerGeneratedUrlInfos =
+        await rawGraphKitchen.pluginController.callAsyncHook(
+          {
+            plugin: bundler.plugin,
+            hookName: "bundle",
+            value: bundler.bundleFunction,
+          },
+          urlInfosToBundle,
+          {
+            ...rawGraphKitchen.baseContext,
+            buildDirectoryUrl,
+          },
+        )
+      Object.keys(bundlerGeneratedUrlInfos).forEach((url) => {
+        const rawUrlInfo = rawGraph.getUrlInfo(url)
+        const bundlerGeneratedUrlInfo = bundlerGeneratedUrlInfos[url]
+        const bundleUrlInfo = {
+          type,
+          subtype: rawUrlInfo ? rawUrlInfo.subtype : undefined,
+          filename: rawUrlInfo ? rawUrlInfo.filename : undefined,
+          ...bundlerGeneratedUrlInfo,
+          data: {
+            ...(rawUrlInfo ? rawUrlInfo.data : {}),
+            ...bundlerGeneratedUrlInfo.data,
+            fromBundle: true,
+          },
+        }
+        const buildUrl = buildUrlsGenerator.generate(url, {
+          urlInfo: bundleUrlInfo,
         })
-      } catch (e) {
-        bundleTask.fail()
-        throw e
-      }
-      bundleTask.done()
-    }, Promise.resolve())
-  }
+        rawUrlRedirections[url] = buildUrl
+        rawUrls[buildUrl] = url
+        bundleUrlInfos[buildUrl] = bundleUrlInfo
+      })
+    } catch (e) {
+      bundleTask.fail()
+      throw e
+    }
+    bundleTask.done()
+  }, Promise.resolve())
 
-  const buildUrlsGenerator = createBuilUrlsGenerator({
-    buildDirectoryUrl,
-  })
-  const rawUrls = {}
-  const buildUrls = {}
+  const buildUrlRedirections = {}
   const finalGraph = createUrlGraph()
-  const optimizeHooks = rawGraphKitchen.pluginController.addHook("optimize")
+  const optimizeUrlContentHooks =
+    rawGraphKitchen.pluginController.addHook("optimizeUrlContent")
   const finalGraphKitchen = createKitchen({
     logger,
     rootDirectoryUrl,
     urlGraph: finalGraph,
-    // 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.
-    // - It could be "fixed" by taking into account sourcemap and consider sourcemap sources
-    //   as the original content.
-    //   - But it would not work when sourcemap are not generated
-    //   - would be a bit slower
-    // - So instead of reading the inline content directly, we search into raw graph
-    //   to get "originalContent" and "sourcemap"
-    loadInlineUrlInfos: (finalUrlInfo) => {
-      const rawUrl = finalUrlInfo.data.rawUrl
-      const bundleUrlInfo = bundleUrlInfos[rawUrl]
-      const urlInfo = bundleUrlInfo || finalUrlInfo
-      const rawUrlInfo = rawGraph.getUrlInfo(rawUrl)
-      return {
-        originalContent: rawUrlInfo ? rawUrlInfo.originalContent : undefined,
-        sourcemap: bundleUrlInfo
-          ? bundleUrlInfo.sourcemap
-          : rawUrlInfo
-          ? rawUrlInfo.sourcemap
-          : undefined,
-        contentType: urlInfo.contentType,
-        content: urlInfo.content,
-      }
-    },
+    scenario: "build",
+    sourcemaps,
+    runtimeCompat,
     plugins: [
-      jsenvPluginInline(),
+      jsenvPluginAsJsClassic({
+        systemJsInjection: true,
+      }),
+      jsenvPluginInline({
+        fetchInlineUrls: false,
+      }),
       {
         name: "jsenv:postbuild",
         appliesDuring: { build: true },
-        resolve: (reference) => {
-          if (reference.specifier[0] === "/") {
-            const url = new URL(reference.specifier.slice(1), rootDirectoryUrl)
-              .href
-            return url
+        resolveUrl: (reference) => {
+          if (reference.specifier[0] === "#") {
+            reference.external = true
           }
-          const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl)
-          if (parentUrlInfo && parentUrlInfo.data.fromBundle) {
-            // code generated by rollup contains specifier relative
-            // to the generated file.
-            // This file does not exists yet we must resolve against the raw url, not the build url
-            const parentRawUrl = parentUrlInfo.data.rawUrl
-            const rawUrl = new URL(reference.specifier, parentRawUrl).href
-            return rawUrl
+          let url =
+            reference.specifier[0] === "/"
+              ? new URL(reference.specifier.slice(1), buildDirectoryUrl).href
+              : new URL(reference.specifier, reference.parentUrl).href
+          const parentIsFromBundle = Boolean(
+            bundleUrlInfos[reference.parentUrl],
+          )
+          // urls inside css bundled by parcel
+          // contains url relative to the bundle file (which is considered inside build directory)
+          // if the file is not itself a bundle file it must be resolved against
+          // the original css url
+          if (
+            parentIsFromBundle &&
+            !bundleUrlInfos[url] &&
+            urlIsInsideOf(url, buildDirectoryUrl)
+          ) {
+            const parentRawUrl = rawUrls[reference.parentUrl]
+            url = new URL(reference.specifier, parentRawUrl).href
           }
-          return new URL(reference.specifier, reference.parentUrl).href
+          const urlRedirected = rawUrlRedirections[url]
+          return urlRedirected || url
         },
-        normalize: (reference) => {
+        normalizeUrl: (reference) => {
           if (!reference.url.startsWith("file:")) {
             return null
           }
           // already a build url
           const rawUrl = rawUrls[reference.url]
           if (rawUrl) {
-            reference.data.rawUrl = rawUrl
             return reference.url
           }
-          const bundleUrlInfo = bundleUrlInfos[reference.url]
           // from rollup or postcss
+          const bundleUrlInfo = bundleUrlInfos[reference.url]
           if (bundleUrlInfo) {
-            const buildUrl = buildUrlsGenerator.generate(
-              reference.url,
-              bundleUrlInfo,
-            )
-            reference.data.rawUrl = reference.url
-            rawUrls[buildUrl] = reference.url
-            return buildUrl
+            return reference.url
           }
-          const rawUrlInfo = rawGraph.getUrlInfo(reference.url)
-          // files from root directory but not given to rollup nor postcss
-          if (rawUrlInfo) {
-            const buildUrl = buildUrlsGenerator.generate(
+          // 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) {
+            // 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(reference.url, {
+              urlInfo: {
+                data: {
+                  ...reference.data,
+                  isWebWorkerEntryPoint:
+                    isWebWorkerEntryPointReference(reference),
+                },
+                type: reference.expectedType,
+                subtype: reference.expectedSubtype,
+                filename: reference.filename,
+              },
+            })
+            const originalUrl = reference.original.url
+            const originalBuildUrl = urlIsInsideOf(
               reference.url,
-              rawUrlInfo,
+              buildDirectoryUrl,
             )
-            reference.data.rawUrl = reference.url
+              ? originalUrl
+              : Object.keys(rawUrls).find((key) => rawUrls[key] === originalUrl)
+            buildUrlRedirections[originalBuildUrl] = buildUrl
             rawUrls[buildUrl] = reference.url
             return buildUrl
           }
           if (reference.isInline) {
-            const rawUrl = Object.keys(rawGraph.urlInfos).find((url) => {
-              const rawUrlInfo = rawGraph.urlInfos[url]
+            const rawUrlInfo = GRAPH.find(rawGraph, (rawUrlInfo) => {
               if (!rawUrlInfo.isInline) {
                 return false
               }
               if (rawUrlInfo.content === reference.content) {
                 return true
               }
+              if (rawUrlInfo.originalContent === reference.content) {
+                return true
+              }
               return false
             })
-            if (!rawUrl) {
-              throw new Error(`cannot find raw url`)
-            }
-            const rawUrlInfo = rawGraph.getUrlInfo(rawUrl)
             const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl)
-            const buildUrl = buildUrlsGenerator.generate(
-              reference.url,
-              rawUrlInfo,
+            if (!rawUrlInfo) {
+              // generated during final graph
+              // (happens for JSON.parse injected for import assertions for instance)
+              // throw new Error(`cannot find raw url for "${reference.url}"`)
+              return reference.url
+            }
+            const buildUrl = buildUrlsGenerator.generate(reference.url, {
+              urlInfo: rawUrlInfo,
               parentUrlInfo,
-            )
+            })
+            rawUrls[buildUrl] = rawUrlInfo.url
+            return buildUrl
+          }
+          // from "js_module_as_js_classic":
+          //   - to inject "s.js"
+          if (reference.injected) {
+            const buildUrl = buildUrlsGenerator.generate(reference.url, {
+              urlInfo: {
+                data: {},
+                type: "js_classic",
+              },
+            })
             rawUrls[buildUrl] = reference.url
-            reference.data.rawUrl = rawUrl
+            return buildUrl
+          }
+          const rawUrlInfo = rawGraph.getUrlInfo(reference.url)
+          // files from root directory but not given to rollup nor postcss
+          if (rawUrlInfo) {
+            const buildUrl = buildUrlsGenerator.generate(reference.url, {
+              urlInfo: rawUrlInfo,
+            })
+            rawUrls[buildUrl] = rawUrlInfo.url
             return buildUrl
           }
           if (reference.type === "sourcemap_comment") {
             // inherit parent build url
             return generateSourcemapUrl(reference.parentUrl)
           }
-          // files generated during the final graph (sourcemaps)
+          // files generated during the final graph:
+          // - sourcemaps
           // const finalUrlInfo = finalGraph.getUrlInfo(url)
           const buildUrl = buildUrlsGenerator.generate(reference.url, {
-            data: {},
-            type: "asset",
+            urlInfo: {
+              data: {},
+              type: "asset",
+            },
           })
           return buildUrl
         },
-        formatReferencedUrl: (reference) => {
-          if (!reference.url.startsWith("file:")) {
+        formatUrl: (reference) => {
+          if (!reference.generatedUrl.startsWith("file:")) {
             return null
           }
-          if (!urlIsInsideOf(reference.url, buildDirectoryUrl)) {
+          if (!urlIsInsideOf(reference.generatedUrl, buildDirectoryUrl)) {
             throw new Error(
               `urls should be inside build directory at this stage, found "${reference.url}"`,
             )
           }
+          // remove eventual search params and hash
+          const urlUntilPathname = asUrlUntilPathname(reference.generatedUrl)
           // if a file is in the same directory we could prefer the relative notation
-          // but to keep things simple let's keep the notation relative to baseUrl for now
+          // but to keep things simple let's keep the "absolutely relative" to baseUrl for now
           const specifier = `${baseUrl}${urlToRelativeUrl(
-            reference.url,
+            urlUntilPathname,
             buildDirectoryUrl,
           )}`
-          buildUrls[specifier] = reference.url
+          buildUrls[specifier] = reference.generatedUrl
           return specifier
         },
-        load: (finalUrlInfo) => {
-          const rawUrl = finalUrlInfo.data.rawUrl
-          const bundleUrlInfo = bundleUrlInfos[rawUrl]
-          const urlInfo = bundleUrlInfo || rawGraph.getUrlInfo(rawUrl)
-          return {
-            data: bundleUrlInfo ? bundleUrlInfo.data : undefined,
-            originalContent: urlInfo.originalContent,
-            contentType: urlInfo.contentType,
-            content: urlInfo.content,
-            sourcemap: urlInfo.sourcemap,
+        fetchUrlContent: async (finalUrlInfo, context) => {
+          if (!finalUrlInfo.url.startsWith("file:")) {
+            return { external: true }
           }
-        },
-        transform: {
-          html: (urlInfo) => {
-            const htmlAst = parseHtmlString(urlInfo.content, {
-              storeOriginalPositions: false,
-            })
-            return {
-              content: stringifyHtmlAst(htmlAst, {
-                removeOriginalPositionAttributes: true,
-              }),
+          const fromBundleOrRawGraph = (url) => {
+            const bundleUrlInfo = bundleUrlInfos[url]
+            if (bundleUrlInfo) {
+              return bundleUrlInfo
             }
-          },
+            const rawUrl = rawUrls[url] || url
+            const rawUrlInfo = rawGraph.getUrlInfo(rawUrl)
+            if (!rawUrlInfo) {
+              const originalBuildUrl = buildUrlRedirections[url]
+              if (originalBuildUrl) {
+                return fromBundleOrRawGraph(originalBuildUrl)
+              }
+              throw new Error(`Cannot find 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.
+              // - It could be "fixed" by taking into account sourcemap and consider sourcemap sources
+              //   as the original content.
+              //   - But it would not work when sourcemap are not generated
+              //   - would be a bit slower
+              // - So instead of reading the inline content directly, we search into raw graph
+              //   to get "originalContent" and "sourcemap"
+              finalUrlInfo.type = rawUrlInfo.type
+              finalUrlInfo.subtype = rawUrlInfo.subtype
+              return rawUrlInfo
+            }
+            return rawUrlInfo
+          }
+          // reference injected during "postbuild":
+          // - happens for "as_js_classic" injecting "s.js"
+          if (context.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,
+              injected: true,
+            })
+            await rawGraphKitchen.cook({
+              reference: ref,
+              urlInfo: rawUrlInfo,
+            })
+            return rawUrlInfo
+          }
+          // reference updated during "postbuild":
+          // - happens for "as_js_classic"
+          if (context.reference.original) {
+            return fromBundleOrRawGraph(context.reference.original.url)
+          }
+          return fromBundleOrRawGraph(finalUrlInfo.url)
         },
       },
       {
         name: "jsenv:optimize",
         appliesDuring: { build: true },
-        transform: async (urlInfo, context) => {
-          if (optimizeHooks.length) {
+        finalizeUrlContent: async (urlInfo, context) => {
+          if (optimizeUrlContentHooks.length) {
             await rawGraphKitchen.pluginController.callAsyncHooks(
-              "optimize",
+              "optimizeUrlContent",
               urlInfo,
               context,
               async (optimizeReturnValue) => {
@@ -443,17 +536,24 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
         },
       },
     ],
-    scenario: "build",
-    sourcemaps,
   })
   const buildTask = createTaskLog(logger, "build")
+  const postBuildEntryUrls = []
   try {
     await loadUrlGraph({
       urlGraph: finalGraph,
       kitchen: finalGraphKitchen,
       outDirectoryUrl: new URL(".jsenv/postbuild/", rootDirectoryUrl),
-      runtimeSupport,
-      startLoading: loadEntryFiles,
+      startLoading: (cookEntryFile) => {
+        entryUrls.forEach((entryUrl) => {
+          const [, postBuildEntryUrlInfo] = cookEntryFile({
+            trace: `entryPoint`,
+            type: "entry_point",
+            specifier: entryUrl,
+          })
+          postBuildEntryUrls.push(postBuildEntryUrlInfo.url)
+        })
+      },
     })
   } catch (e) {
     buildTask.fail()
@@ -465,7 +565,7 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
     `graph urls pre-versioning:
 ${Object.keys(finalGraph.urlInfos).join("\n")}`,
   )
-  if (versioning !== "none") {
+  if (versioning) {
     const versioningTask = createTaskLog(logger, "inject version in urls")
     try {
       const urlsSorted = sortUrlGraphByDependencies(finalGraph)
@@ -477,23 +577,57 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
         if (urlInfo.type === "sourcemap") {
           return
         }
+        // ignore:
+        // - inline files:
+        //   they are already taken into account in the file where they appear
+        // - external files
+        //   we don't know their content
+        // - unused files without reference
+        //   File updated such as style.css -> style.css.js or file.js->file.es5.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
         }
-        const urlVersionGenerator = createUrlVersionGenerator()
-        urlVersionGenerator.augmentWithContent({
-          content: urlInfo.content,
+        if (urlInfo.external) {
+          return
+        }
+        if (!urlInfo.data.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 (data:) or remote (http://, https://)
+          if (!dependencyUrl.startsWith("file:")) {
+            return
+          }
           const dependencyUrlInfo = finalGraph.getUrlInfo(dependencyUrl)
-          if (dependencyUrlInfo.isInline) {
+          if (
             // this content is part of the file, no need to take into account twice
+            dependencyUrlInfo.isInline ||
+            // this dependency content is not known
+            dependencyUrlInfo.external
+          ) {
             return
           }
           if (dependencyUrlInfo.data.version) {
-            urlVersionGenerator.augmentWithDependencyVersion(
+            versionGenerator.augmentWithDependencyVersion(
               dependencyUrlInfo.data.version,
             )
           } else {
@@ -501,18 +635,19 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
             // it means there is a circular dependency between this file
             // and it's dependency
             // in that case we'll use the dependency content
-            urlVersionGenerator.augmentWithContent({
+            versionGenerator.augmentWithContent({
               content: dependencyUrlInfo.content,
               contentType: dependencyUrlInfo.contentType,
               lineBreakNormalization,
             })
           }
         })
-        urlInfo.data.version = urlVersionGenerator.generate()
+        urlInfo.data.version = versionGenerator.generate()
+
         urlInfo.data.versionedUrl = injectVersionIntoBuildUrl({
           buildUrl: urlInfo.url,
           version: urlInfo.data.version,
-          versioning,
+          versioningMethod,
         })
       })
       const versionMappings = {}
@@ -521,41 +656,37 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
         logger,
         rootDirectoryUrl: buildDirectoryUrl,
         urlGraph: finalGraph,
-        loadInlineUrlInfos: (versionedUrlInfo) => {
-          const rawUrlInfo = rawGraph.getUrlInfo(versionedUrlInfo.data.rawUrl)
-          const finalUrlInfo = finalGraph.getUrlInfo(versionedUrlInfo.url)
-          return {
-            originalContent: rawUrlInfo
-              ? rawUrlInfo.originalContent
-              : undefined,
-            sourcemap: finalUrlInfo ? finalUrlInfo.sourcemap : undefined,
-            contentType: versionedUrlInfo.contentType,
-            content: versionedUrlInfo.content,
-          }
-        },
+        scenario: "build",
+        sourcemaps,
+        runtimeCompat,
         plugins: [
           jsenvPluginInline({
+            fetchInlineUrls: false,
+            analyzeConvertedScripts: true, // to be able to version their urls
             allowEscapeForVersioning: true,
           }),
           {
             name: "jsenv:versioning",
             appliesDuring: { build: true },
-            resolve: ({ parentUrl, specifier }) => {
-              const buildUrl = buildUrls[specifier]
+            resolveUrl: (reference) => {
+              if (reference.specifier[0] === "#") {
+                reference.external = true
+              }
+              const buildUrl = buildUrls[reference.specifier]
               if (buildUrl) {
                 return buildUrl
               }
-              const url = new URL(specifier, parentUrl).href
+              const url = new URL(reference.specifier, reference.parentUrl).href
               return url
             },
-            formatReferencedUrl: (reference) => {
+            formatUrl: (reference) => {
               if (reference.isInline) {
                 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 (referencedUrlInfo.data.isEntryPoint) {
+              if (!canUseVersionedUrl(referencedUrlInfo)) {
                 return reference.specifier
               }
               // data:* urls and so on
@@ -575,6 +706,8 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
                 buildDirectoryUrl,
               )}`
               versionMappings[reference.specifier] = versionedSpecifier
+              buildUrls[versionedSpecifier] = versionedUrl
+
               const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl)
               if (parentUrlInfo.jsQuote) {
                 // the url is inline inside js quotes
@@ -585,7 +718,7 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
                   )})+${parentUrlInfo.jsQuote}`
               }
               if (
-                reference.type === "js_import_meta_url_pattern" ||
+                reference.type === "js_url_specifier" ||
                 reference.subtype === "import_dynamic"
               ) {
                 usedVersionMappings.push(reference.specifier)
@@ -593,48 +726,52 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
               }
               return versionedSpecifier
             },
-            load: ({ url }) => {
-              const urlInfo = finalGraph.getUrlInfo(url)
-              return {
-                originalContent: urlInfo.originalContent,
-                contentType: urlInfo.contentType,
-                content: urlInfo.content,
-                sourcemap: urlInfo.sourcemap,
+            fetchUrlContent: (versionedUrlInfo) => {
+              if (!versionedUrlInfo.url.startsWith("file:")) {
+                return { external: true }
+              }
+              if (versionedUrlInfo.isInline) {
+                const rawUrlInfo = rawGraph.getUrlInfo(
+                  rawUrls[versionedUrlInfo.url],
+                )
+                const finalUrlInfo = finalGraph.getUrlInfo(versionedUrlInfo.url)
+                return {
+                  originalContent: rawUrlInfo
+                    ? rawUrlInfo.originalContent
+                    : undefined,
+                  sourcemap: finalUrlInfo ? finalUrlInfo.sourcemap : undefined,
+                  contentType: versionedUrlInfo.contentType,
+                  content: versionedUrlInfo.content,
+                }
               }
+              return versionedUrlInfo
             },
           },
         ],
-        scenario: "build",
-        sourcemaps,
-      })
-      // arrange state before reloading all files
-      Object.keys(finalGraph.urlInfos).forEach((url) => {
-        const urlInfo = finalGraph.urlInfos[url]
-        urlInfo.data.promise = null
       })
       await loadUrlGraph({
         urlGraph: finalGraph,
         kitchen: versioningKitchen,
-        runtimeSupport,
-        startLoading: loadEntryFiles,
+        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 Promise.all(
-          Object.keys(finalGraph.urlInfos).map(async (buildUrl) => {
-            const buildUrlInfo = finalGraph.getUrlInfo(buildUrl)
-            if (!buildUrlInfo.data.isEntryPoint) {
-              return
-            }
-            await injectVersionMappings(buildUrlInfo, {
-              kitchen: finalGraphKitchen,
-              versionMappings: versionMappingsNeeded,
-            })
-          }),
-        )
+        await injectGlobalVersionMapping({
+          finalGraphKitchen,
+          finalGraph,
+          versionMappings: versionMappingsNeeded,
+        })
       }
     } catch (e) {
       versioningTask.fail()
@@ -643,39 +780,91 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
     versioningTask.done()
   }
 
-  const buildFileContents = {}
-  const buildInlineFileContents = {}
-  const buildManifest = {}
-  Object.keys(finalGraph.urlInfos).forEach((url) => {
-    if (!url.startsWith("file:")) {
+  GRAPH.forEach(finalGraph, (urlInfo) => {
+    if (!urlInfo.url.startsWith("file:")) {
       return
     }
-    const buildUrlInfo = finalGraph.getUrlInfo(url)
-    const versionedUrl = buildUrlInfo.data.versionedUrl
-    const useVersionedUrl = versionedUrl && !buildUrlInfo.data.isEntryPoint
-    const buildUrl = useVersionedUrl ? versionedUrl : buildUrlInfo.url
-    if (!urlIsInsideOf(buildUrl, buildDirectoryUrl)) {
-      throw new Error(`build url outside build directory`)
+    if (urlInfo.external) {
+      return
     }
-    const buildRelativeUrl = urlToRelativeUrl(buildUrl, buildDirectoryUrl)
-    if (buildUrlInfo.isInline) {
-      buildInlineFileContents[buildRelativeUrl] = buildUrlInfo.content
-    } else {
-      buildFileContents[buildRelativeUrl] = buildUrlInfo.content
+    if (urlInfo.type === "html") {
+      const htmlAst = parseHtmlString(urlInfo.content, {
+        storeOriginalPositions: false,
+      })
+      urlInfo.content = stringifyHtmlAst(htmlAst, {
+        removeOriginalPositionAttributes: true,
+      })
     }
-    if (useVersionedUrl) {
-      const buildRelativeUrlWithoutVersioning = urlToRelativeUrl(
-        buildUrlInfo.url,
-        buildDirectoryUrl,
-      )
-      buildManifest[buildRelativeUrlWithoutVersioning] = buildRelativeUrl
+    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 resyncRessourceHints({
+    finalGraphKitchen,
+    finalGraph,
+    rawUrls,
+    buildUrls,
+    buildUrlRedirections,
+  })
+  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.data.isEntryPoint &&
+      urlInfo.type !== "sourcemap" &&
+      urlInfo.dependents.size === 0
+    ) {
+      cleanupActions.push(() => {
+        delete finalGraph.urlInfos[urlInfo.url]
+      })
     }
   })
+  cleanupActions.forEach((cleanupAction) => cleanupAction())
+  await injectServiceWorkerUrls({
+    finalGraphKitchen,
+    finalGraph,
+    lineBreakNormalization,
+  })
+
   logger.debug(
     `graph urls post-versioning:
 ${Object.keys(finalGraph.urlInfos).join("\n")}`,
   )
 
+  const buildManifest = {}
+  const buildFileContents = {}
+  const buildInlineContents = {}
+  GRAPH.forEach(finalGraph, (urlInfo) => {
+    if (urlInfo.external) {
+      return
+    }
+    if (urlInfo.url.startsWith("data:")) {
+      return
+    }
+    const buildRelativeUrl = urlToRelativeUrl(
+      urlInfo.data.buildUrl,
+      buildDirectoryUrl,
+    )
+    if (urlInfo.isInline) {
+      buildInlineContents[buildRelativeUrl] = urlInfo.content
+    } else {
+      buildFileContents[buildRelativeUrl] = urlInfo.content
+    }
+    const buildRelativeUrlWithoutVersioning = urlToRelativeUrl(
+      urlInfo.url,
+      buildDirectoryUrl,
+    )
+    buildManifest[buildRelativeUrlWithoutVersioning] = buildRelativeUrl
+  })
   if (writeOnFileSystem) {
     if (buildDirectoryClean) {
       await ensureEmptyDirectory(buildDirectoryUrl)
@@ -689,17 +878,23 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
         )
       }),
     )
+    if (versioning && assetManifest && Object.keys(buildManifest).length) {
+      await writeFile(
+        new URL(assetManifestFileRelativeUrl, buildDirectoryUrl),
+        JSON.stringify(buildManifest, null, "  "),
+      )
+    }
   }
   logger.info(createUrlGraphSummary(finalGraph, { title: "build files" }))
   return {
     buildFileContents,
-    buildInlineFileContents,
+    buildInlineContents,
     buildManifest,
   }
 }
 
-const injectVersionIntoBuildUrl = ({ buildUrl, version, versioning }) => {
-  if (versioning === "search_param") {
+const injectVersionIntoBuildUrl = ({ buildUrl, version, versioningMethod }) => {
+  if (versioningMethod === "search_param") {
     return injectQueryParams(buildUrl, {
       v: version,
     })
@@ -735,3 +930,16 @@ const assertEntryPoints = ({ entryPoints }) => {
     }
   })
 }
+
+const canUseVersionedUrl = (urlInfo) => {
+  if (urlInfo.data.isEntryPoint) {
+    return false
+  }
+  if (urlInfo.type === "webmanifest") {
+    return false
+  }
+  if (urlInfo.subtype === "service_worker") {
+    return !urlInfo.data.isWebWorkerEntryPoint
+  }
+  return true
+}