@jsenv/core 24.6.3 → 25.0.0-alpha.1

package/src/internal/building/rollup_plugin_jsenv.js

@@ -1,10 +1,9 @@
 import { extname } from "node:path"
 import MagicString from "magic-string"
-import { normalizeImportMap } from "@jsenv/importmap"
+import { composeTwoImportMaps, normalizeImportMap } from "@jsenv/importmap"
 import { isSpecifierForNodeCoreModule } from "@jsenv/importmap/src/isSpecifierForNodeCoreModule.js"
 import { createDetailedMessage, loggerToLogLevel } from "@jsenv/logger"
 import {
-  isFileSystemPath,
   fileSystemPathToUrl,
   resolveUrl,
   urlToRelativeUrl,
@@ -14,9 +13,13 @@ import {
   normalizeStructuredMetaMap,
   urlToMeta,
   urlToBasename,
+  urlToFilename,
+  readFile,
 } from "@jsenv/filesystem"
 import { UNICODE } from "@jsenv/log"
 
+import { convertJsonTextToJavascriptModule } from "@jsenv/core/src/internal/building/json_module.js"
+import { convertCssTextToJavascriptModule } from "@jsenv/core/src/internal/building/css_module.js"
 import { transformJs } from "@jsenv/core/src/internal/compiling/js-compilation-service/transformJs.js"
 import { createUrlConverter } from "@jsenv/core/src/internal/url_conversion.js"
 import { createUrlFetcher } from "@jsenv/core/src/internal/building/url_fetcher.js"
@@ -24,7 +27,9 @@ import { createUrlLoader } from "@jsenv/core/src/internal/building/url_loader.js
 import { stringifyUrlTrace } from "@jsenv/core/src/internal/building/url_trace.js"
 import { sortObjectByPathnames } from "@jsenv/core/src/internal/building/sortObjectByPathnames.js"
 import { jsenvHelpersDirectoryInfo } from "@jsenv/core/src/internal/jsenvInternalFiles.js"
-import { setUrlSearchParamsDescriptor } from "@jsenv/core/src/internal/url_utils.js"
+import { createImportResolverForNode } from "@jsenv/core/src/internal/import-resolution/import-resolver-node.js"
+import { createImportResolverForImportmap } from "@jsenv/core/src/internal/import-resolution/import-resolver-importmap.js"
+import { getDefaultImportmap } from "@jsenv/core/src/internal/import-resolution/importmap_default.js"
 
 import {
   formatBuildStartLog,
@@ -40,13 +45,9 @@ import {
   referenceToCodeForRollup,
 } from "./ressource_builder.js"
 
-import { computeBuildRelativeUrl } from "./url-versioning.js"
+import { createUrlVersioner } from "./url_versioning.js"
 import { visitImportReferences } from "./import_references.js"
 
-import { createImportResolverForNode } from "../import-resolution/import-resolver-node.js"
-import { createImportResolverForImportmap } from "../import-resolution/import-resolver-importmap.js"
-import { getDefaultImportMap } from "../import-resolution/importmap-default.js"
-import { injectSourcemapInRollupBuild } from "./rollup_build_sourcemap.js"
 import { createBuildStats } from "./build_stats.js"
 
 export const createRollupPlugins = async ({
@@ -54,7 +55,7 @@ export const createRollupPlugins = async ({
   logger,
 
   projectDirectoryUrl,
-  entryPointMap,
+  entryPoints,
   compileServerOrigin,
   compileDirectoryRelativeUrl,
   buildDirectoryUrl,
@@ -69,6 +70,8 @@ export const createRollupPlugins = async ({
   workers,
   serviceWorkers,
   serviceWorkerFinalizer,
+  classicWorkers,
+  classicServiceWorkers,
 
   format,
   systemJsUrl,
@@ -77,7 +80,6 @@ export const createRollupPlugins = async ({
   importAssertionsSupport,
 
   urlVersioning,
-  urlVersionningForEntryPoints,
   lineBreakNormalization,
   jsConcatenation,
   cssConcatenation,
@@ -101,14 +103,27 @@ export const createRollupPlugins = async ({
     lastErrorMessage = error.message
   }
 
-  const workerUrls = Object.keys(workers).map((key) =>
-    resolveUrl(key, projectDirectoryUrl),
+  const extension = extname(entryPoints[Object.keys(entryPoints)[0]])
+  const outputExtension = extension === ".html" ? ".js" : extension
+
+  const entryPointUrls = {}
+  Object.keys(entryPoints).forEach((key) => {
+    const url = resolveUrl(key, projectDirectoryUrl)
+    entryPointUrls[url] = entryPoints[key]
+  })
+  const workerUrls = workers.map((worker) =>
+    resolveUrl(worker, projectDirectoryUrl),
+  )
+  const serviceWorkerUrls = serviceWorkers.map((serviceWorker) =>
+    resolveUrl(serviceWorker, projectDirectoryUrl),
+  )
+  const classicWorkerUrls = classicWorkers.map((classicWorker) =>
+    resolveUrl(classicWorker, projectDirectoryUrl),
   )
-  const serviceWorkerUrls = Object.keys(serviceWorkers).map((key) =>
-    resolveUrl(key, projectDirectoryUrl),
+  const classicServiceWorkerUrls = classicServiceWorkers.map(
+    (classicServiceWorker) =>
+      resolveUrl(classicServiceWorker, projectDirectoryUrl),
   )
-  const isWorkerUrl = (url) => workerUrls.includes(url)
-  const isServiceWorkerUrl = (url) => serviceWorkerUrls.includes(url)
 
   let ressourceBuilder
   let importResolver
@@ -132,6 +147,12 @@ export const createRollupPlugins = async ({
     urlMappings,
   })
 
+  const urlVersioner = createUrlVersioner({
+    entryPointUrls,
+    asOriginalUrl,
+    lineBreakNormalization,
+  })
+
   const urlFetcher = createUrlFetcher({
     asOriginalUrl,
     asProjectUrl,
@@ -142,13 +163,11 @@ export const createRollupPlugins = async ({
     },
   })
 
+  const urlCustomLoaders = {}
   const urlLoader = createUrlLoader({
-    projectDirectoryUrl,
-    buildDirectoryUrl,
-    babelPluginMap,
+    urlCustomLoaders,
     allowJson: acceptsJsonContentType({ node, format }),
     urlImporterMap,
-    inlineModuleScripts,
     jsConcatenation,
 
     asServerUrl,
@@ -163,41 +182,33 @@ export const createRollupPlugins = async ({
     projectDirectoryUrl,
   )
 
-  // map fileName (build relative urls without hash) to build relative url
+  // map build relative urls without hash (called "ressourceName") to real build relative urls
   let buildManifest = {}
-  const buildRelativeUrlToFileName = (buildRelativeUrl) => {
-    const fileName = Object.keys(buildManifest).find(
-      (key) => buildManifest[key] === buildRelativeUrl,
-    )
-    return fileName
-  }
-  const buildRelativeUrlsUsedInJs = []
-  const markBuildRelativeUrlAsUsedByJs = (buildRelativeUrl) => {
-    buildRelativeUrlsUsedInJs.push(buildRelativeUrl)
-    buildManifest[rollupFileNameWithoutHash(buildRelativeUrl)] =
-      buildRelativeUrl
-  }
+
+  const ressourcesReferencedByJs = []
   const createImportMapForFilesUsedInJs = () => {
     const topLevelMappings = {}
-    buildRelativeUrlsUsedInJs
-      .sort(comparePathnames)
-      .forEach((buildRelativeUrl) => {
-        const fileName = buildRelativeUrlToFileName(buildRelativeUrl)
-        if (fileName !== buildRelativeUrl) {
-          topLevelMappings[`./${fileName}`] = `./${buildRelativeUrl}`
-        }
-      })
+    ressourcesReferencedByJs.sort(comparePathnames).forEach((ressourceName) => {
+      const buildRelativeUrl = buildManifest[ressourceName]
+      if (
+        ressourceName &&
+        buildRelativeUrl &&
+        ressourceName !== buildRelativeUrl
+      ) {
+        topLevelMappings[`./${ressourceName}`] = `./${buildRelativeUrl}`
+      }
+    })
     return {
       imports: topLevelMappings,
     }
   }
 
-  let buildMappings = {}
   // an object where keys are build relative urls
   // and values rollup chunk or asset
   // we need this because we sometimes tell rollup
   // that a file.fileName is something while it's not really this
   // because of remapping
+  let buildMappings = {}
   let rollupBuild
 
   const EMPTY_CHUNK_URL = resolveUrl("__empty__", projectDirectoryUrl)
@@ -240,9 +251,10 @@ export const createRollupPlugins = async ({
   let minifyHtml
 
   const rollupPlugins = []
-  // rollup add async/await that might be unsupported by the runtime
+  // When format is systemjs, rollup add async/await
+  // that might be unsupported by the runtime.
   // in that case we have to transform the rollup output
-  if (babelPluginMap["transform-async-to-promises"]) {
+  if (babelPluginMap["transform-async-to-promises"] && format === "systemjs") {
     rollupPlugins.push({
       name: "jsenv_fix_async_await",
       async renderChunk(code, chunk) {
@@ -257,12 +269,11 @@ export const createRollupPlugins = async ({
             "transform-async-to-promises":
               babelPluginMap["transform-async-to-promises"],
           },
+          // pass undefined when format is "systemjs" to avoid
+          // re-wrapping the code in systemjs format
+          moduleOutFormat: undefined,
           babelHelpersInjectionAsImport: false,
           transformGenerator: false,
-          moduleOutFormat:
-            // pass undefined when format is "systemjs" to avoid
-            // re-wrapping the code in systemjs format
-            format === "systemjs" ? undefined : format,
         })
         code = result.code
         map = result.map
@@ -313,6 +324,7 @@ export const createRollupPlugins = async ({
             : resolveUrl(chunk.fileName, buildDirectoryUrl),
           code,
           map,
+          module: format === "esmodule",
           ...(format === "global" ? { toplevel: false } : { toplevel: true }),
         })
 
@@ -329,9 +341,9 @@ export const createRollupPlugins = async ({
     name: "jsenv",
 
     async buildStart() {
-      logger.info(formatBuildStartLog({ entryPointMap }))
+      logger.info(formatBuildStartLog({ entryPoints }))
 
-      const entryPointsPrepared = await prepareEntryPoints(entryPointMap, {
+      const entryPointsPrepared = await prepareEntryPoints(entryPoints, {
         logger,
         projectDirectoryUrl,
         buildDirectoryUrl,
@@ -360,7 +372,7 @@ export const createRollupPlugins = async ({
       if (typeof useImportMapToMaximizeCacheReuse === "undefined") {
         useImportMapToMaximizeCacheReuse =
           htmlEntryPointCount > 0 &&
-          // node has no importmap concept, le'ts use the versionned url in that case
+          // node has no importmap concept, let's use the versionned url in that case
           !node
       }
 
@@ -442,9 +454,21 @@ export const createRollupPlugins = async ({
             )
             importMapUrl = htmlCompiledUrl
             fetchImportMap = () => {
-              const importMapRaw = JSON.parse(importMapInfoFromHtml.text)
-              const importMap = normalizeImportMap(importMapRaw, importMapUrl)
-              return importMap
+              const importmapFileUrl = asProjectUrl(importMapUrl)
+              const jsenvImportmap = getDefaultImportmap(importmapFileUrl, {
+                projectDirectoryUrl,
+                compileDirectoryUrl,
+              })
+              const htmlImportmap = JSON.parse(importMapInfoFromHtml.text)
+              const importmap = composeTwoImportMaps(
+                jsenvImportmap,
+                htmlImportmap,
+              )
+              const importmapNormalized = normalizeImportMap(
+                importmap,
+                importMapUrl,
+              )
+              return importmapNormalized
             }
           }
         } else if (importMapFileRelativeUrl) {
@@ -459,7 +483,7 @@ export const createRollupPlugins = async ({
             )
           }
         } else {
-          // there is no importmap, its' fine it's not mandatory to use one
+          // there is no importmap, it's fine, it's not mandatory
           fetchImportMap = () => {
             const firstEntryPoint = htmlEntryPoints[0] || entryPointsPrepared[0]
             const { entryProjectRelativeUrl } = firstEntryPoint
@@ -467,16 +491,19 @@ export const createRollupPlugins = async ({
               entryProjectRelativeUrl,
               compileDirectoryUrl,
             )
-            const defaultImportMap = getDefaultImportMap({
-              importMapFileUrl: entryCompileUrl,
+            const jsenvImportmap = getDefaultImportmap(entryCompileUrl, {
               projectDirectoryUrl,
-              compileDirectoryRelativeUrl,
+              compileDirectoryUrl,
             })
             const entryCompileServerUrl = resolveUrl(
               entryProjectRelativeUrl,
               compileDirectoryServerUrl,
             )
-            return normalizeImportMap(defaultImportMap, entryCompileServerUrl)
+            const importmapNormalized = normalizeImportMap(
+              jsenvImportmap,
+              entryCompileServerUrl,
+            )
+            return importmapNormalized
           }
         }
 
@@ -603,13 +630,27 @@ export const createRollupPlugins = async ({
             }
 
             const originalUrl = asOriginalUrl(projectUrl)
-            if (isWorkerUrl(originalUrl)) {
+            if (workerUrls.includes(originalUrl)) {
               return {
                 isWorker: true,
+                isJsModule: true,
                 url: ressourceUrl,
               }
             }
-            if (isServiceWorkerUrl(originalUrl)) {
+            if (serviceWorkerUrls.includes(originalUrl)) {
+              return {
+                isServiceWorker: true,
+                isJsModule: true,
+                url: ressourceUrl,
+              }
+            }
+            if (classicWorkerUrls.includes(originalUrl)) {
+              return {
+                isWorker: true,
+                url: ressourceUrl,
+              }
+            }
+            if (classicServiceWorkerUrls.includes(originalUrl)) {
               return {
                 isServiceWorker: true,
                 url: ressourceUrl,
@@ -618,34 +659,79 @@ export const createRollupPlugins = async ({
 
             return ressourceUrl
           },
-          emitChunk,
-          emitAsset,
-          setAssetSource,
           onJsModule: ({ ressource, jsModuleUrl, jsModuleIsInline }) => {
-            if (jsModuleIsInline) {
-              inlineModuleScripts[jsModuleUrl] = ressource
+            // we want to emit chunk only when ressource is referenced by something else than rollup
+            if (
+              jsConcatenation &&
+              ressource.references.every((ref) => ref.fromRollup)
+            ) {
+              return null
             }
 
-            urlImporterMap[jsModuleUrl] = {
-              url: resolveUrl(
+            if (ressource.isEntryPoint) {
+            } else {
+              const importerUrl = resolveUrl(
                 entryPointsPrepared[0].entryProjectRelativeUrl,
                 compileDirectoryServerUrl,
-              ),
-              line: undefined,
-              column: undefined,
+              )
+              urlImporterMap[jsModuleUrl] = {
+                url: importerUrl,
+                line: undefined,
+                column: undefined,
+              }
+              jsModulesFromEntry[asRollupUrl(jsModuleUrl)] = true
+              if (jsModuleIsInline) {
+                inlineModuleScripts[jsModuleUrl] = ressource
+                urlCustomLoaders[jsModuleUrl] = async () => {
+                  const transformResult = await transformJs({
+                    code: String(
+                      inlineModuleScripts[jsModuleUrl].bufferBeforeBuild,
+                    ),
+                    url: asOriginalUrl(jsModuleUrl), // transformJs expect a file:// url
+                    projectDirectoryUrl,
+                    babelPluginMap,
+                    // moduleOutFormat: format // we are compiling for rollup output must be "esmodule"
+                    // we compile for rollup, let top level await untouched
+                    // it will be converted, if needed, during "renderChunk" hook
+                    topLevelAwait: "ignore",
+                  })
+                  let code = transformResult.code
+                  let map = transformResult.map
+                  return {
+                    code,
+                    map,
+                  }
+                }
+              }
             }
-            jsModulesFromEntry[asRollupUrl(jsModuleUrl)] = true
-            const name = urlToBasename(jsModuleUrl)
+
+            const fileName = ressource.relativeUrl
             const rollupReferenceId = emitChunk({
-              id: asRollupUrl(jsModuleUrl),
-              name,
+              id: jsModuleUrl,
+              name: urlToBasename(jsModuleUrl),
             })
             return {
-              name,
               rollupReferenceId,
+              fileName,
             }
           },
-          lineBreakNormalization,
+          onAsset: ({ ressource }) => {
+            const fileName = ressource.relativeUrl
+            const rollupReferenceId = emitAsset({
+              fileName,
+            })
+            return {
+              rollupReferenceId,
+              fileName,
+            }
+          },
+          onAssetSourceUpdated: ({ ressource }) => {
+            setAssetSource(
+              ressource.rollupReferenceId,
+              ressource.bufferAfterBuild,
+            )
+          },
+          urlVersioner,
         },
       )
 
@@ -654,16 +740,15 @@ export const createRollupPlugins = async ({
           async ({
             entryContentType,
             entryProjectRelativeUrl,
-            entryBuildRelativeUrl,
             entryBuffer,
           }) => {
             if (entryContentType === "application/javascript") {
-              emitChunk({
-                id: ensureRelativeUrlNotation(entryProjectRelativeUrl),
-                name: urlToBasename(`file:///${entryBuildRelativeUrl}`),
-                ...(urlVersionningForEntryPoints
-                  ? {}
-                  : { fileName: entryBuildRelativeUrl }),
+              await ressourceBuilder.createReferenceForEntryPoint({
+                entryContentType,
+                entryUrl: resolveUrl(
+                  entryProjectRelativeUrl,
+                  compileDirectoryServerUrl,
+                ),
               })
               return
             }
@@ -684,8 +769,6 @@ export const createRollupPlugins = async ({
               entryContentType,
               entryUrl,
               entryBuffer,
-              entryBuildRelativeUrl,
-              urlVersionningForEntryPoints,
             })
           },
         ),
@@ -699,15 +782,20 @@ export const createRollupPlugins = async ({
       }
     },
 
-    async resolveId(specifier, importer, { custom }) {
+    async resolveId(specifier, importer, { custom = {} } = {}) {
+      if (specifier === EMPTY_CHUNK_URL) {
+        return specifier
+      }
+
+      let importerUrl
       if (importer === undefined) {
         if (specifier.endsWith(".html")) {
-          importer = compileServerOrigin
+          importerUrl = compileServerOrigin
         } else {
-          importer = compileDirectoryServerUrl
+          importerUrl = compileDirectoryServerUrl
         }
       } else {
-        importer = asServerUrl(importer)
+        importerUrl = asServerUrl(importer)
       }
 
       const { importAssertionInfo } = custom
@@ -732,25 +820,23 @@ export const createRollupPlugins = async ({
       }
 
       if (inlineModuleScripts.hasOwnProperty(specifier)) {
-        return specifier
+        return asRollupUrl(specifier)
       }
 
-      if (isFileSystemPath(importer)) {
-        importer = fileSystemPathToUrl(importer)
-      }
-
-      const importUrl = await importResolver.resolveImport(specifier, importer)
-
+      const importUrl = await importResolver.resolveImport(
+        specifier,
+        importerUrl,
+      )
       const existingImporter = urlImporterMap[importUrl]
       if (!existingImporter) {
         urlImporterMap[importUrl] = importAssertionInfo
           ? {
-              url: importer,
+              url: importerUrl,
               column: importAssertionInfo.column,
               line: importAssertionInfo.line,
             }
           : {
-              url: importer,
+              url: importerUrl,
               // rollup do not expose a way to know line and column for the static or dynamic import
               // referencing that file
               column: undefined,
@@ -782,34 +868,29 @@ export const createRollupPlugins = async ({
     },
 
     resolveFileUrl: ({ referenceId, fileName }) => {
-      const ressourceFound = ressourceBuilder.findRessource((ressource) => {
-        return ressource.rollupReferenceId === referenceId
-      })
-      const buildRelativeUrl = ressourceFound
-        ? ressourceFound.buildRelativeUrl
-        : fileName
-
+      ressourcesReferencedByJs.push(fileName)
+      const getBuildRelativeUrl = () => {
+        const ressource = ressourceBuilder.findRessource((ressource) => {
+          return ressource.rollupReferenceId === referenceId
+        })
+        ressource.fileName = fileName
+        const buildRelativeUrl = ressource.buildRelativeUrl
+        return buildRelativeUrl
+      }
       if (format === "esmodule") {
         if (!node && useImportMapToMaximizeCacheReuse && urlVersioning) {
-          const buildRelativeUrlWithoutVersion =
-            buildRelativeUrlToFileName(buildRelativeUrl)
-          return `window.__resolveImportUrl__("./${buildRelativeUrlWithoutVersion}", import.meta.url)`
+          return `window.__resolveImportUrl__("./${fileName}", import.meta.url)`
         }
-        return `new URL("${buildRelativeUrl}", import.meta.url)`
+        return `new URL("${getBuildRelativeUrl()}", import.meta.url)`
       }
       if (format === "systemjs") {
-        if (useImportMapToMaximizeCacheReuse && urlVersioning) {
-          const buildRelativeUrlWithoutVersion =
-            buildRelativeUrlToFileName(buildRelativeUrl)
-          return `new URL(System.resolve("./${buildRelativeUrlWithoutVersion}", module.meta.url))`
-        }
-        return `new URL(System.resolve("./${buildRelativeUrl}", module.meta.url))`
+        return `new URL(System.resolve("./${fileName}", module.meta.url))`
       }
       if (format === "global") {
-        return `new URL("${buildRelativeUrl}", document.currentScript && document.currentScript.src || document.baseURI)`
+        return `new URL("${getBuildRelativeUrl()}", document.currentScript && document.currentScript.src || document.baseURI)`
       }
       if (format === "commonjs") {
-        return `new URL("${buildRelativeUrl}", "file:///" + __filename.replace(/\\/g, "/"))`
+        return `new URL("${getBuildRelativeUrl()}", "file:///" + __filename.replace(/\\/g, "/"))`
       }
       return null
     },
@@ -830,11 +911,10 @@ export const createRollupPlugins = async ({
         return urlLoader.loadUrl(rollupUrl, {
           signal,
           logger,
-          ressourceBuilder,
         })
       })
 
-      url = loadResult.url
+      if (loadResult.url) url = loadResult.url
       const code = loadResult.code
       const map = loadResult.map
 
@@ -846,6 +926,7 @@ export const createRollupPlugins = async ({
         originalUrl,
         jsenvHelpersDirectoryInfo.url,
       )
+      // const isEntryPoint = entryPointUrls[originalUrl]
 
       const importer = urlImporterMap[url]
       // Inform ressource builder that this js module exists
@@ -855,18 +936,12 @@ export const createRollupPlugins = async ({
       // For import assertions, the imported ressource (css,json,...)
       // is arelady converted to a js module
       ressourceBuilder.createReferenceFoundByRollup({
-        // we don't want to emit a js chunk for every js file found
-        // (However we want if the file is preload/prefetch by something else)
-        // so we tell asset builder not to emit a chunk for this js reference
-        // otherwise rollup would never concat module together
-        referenceShouldNotEmitChunk: jsConcatenation,
         contentTypeExpected: "application/javascript",
         referenceLabel: "static or dynamic import",
         referenceUrl: importer.url,
         referenceColumn: importer.column,
         referenceLine: importer.line,
         ressourceSpecifier: url,
-
         isJsenvHelperFile,
         contentType: "application/javascript",
         bufferBeforeBuild: Buffer.from(code),
@@ -896,18 +971,30 @@ export const createRollupPlugins = async ({
         onReferenceWithImportMetaUrlPattern: async ({ importNode }) => {
           const specifier = importNode.arguments[0].value
           const { line, column } = importNode.loc.start
-          const reference =
-            await ressourceBuilder.createReferenceFoundInJsModule({
-              referenceLabel: "URL + import.meta.url",
-              jsUrl: url,
-              jsLine: line,
-              jsColumn: column,
-              ressourceSpecifier: specifier,
-            })
+
+          const { id } = normalizeRollupResolveReturnValue(
+            await this.resolve(specifier, url),
+          )
+          const ressourceUrl = asServerUrl(id)
+          const originalUrl = asOriginalUrl(ressourceUrl)
+          const isJsModule = Boolean(
+            workerUrls[originalUrl] || serviceWorkerUrls[originalUrl],
+          )
+          const reference = ressourceBuilder.createReferenceFoundInJsModule({
+            referenceLabel: "URL + import.meta.url",
+            jsUrl: url,
+            jsLine: line,
+            jsColumn: column,
+            ressourceSpecifier: ressourceUrl,
+            isJsModule,
+          })
           if (!reference) {
             return
           }
-          markBuildRelativeUrlAsUsedByJs(reference.ressource.buildRelativeUrl)
+          if (!reference.ressource.isJsModule) {
+            // so that ressource.buildRelativeUrl is known during "resolveFileUrl" hook`
+            await reference.ressource.getReadyPromise()
+          }
           mutations.push((magicString) => {
             magicString.overwrite(
               importNode.start,
@@ -924,7 +1011,6 @@ export const createRollupPlugins = async ({
           const { source } = importNode
           const importSpecifier = source.value
           const { line, column } = importNode.loc.start
-
           // "type" is dynamic on dynamic import such as
           // import("./data.json", {
           //   assert: {
@@ -952,9 +1038,7 @@ export const createRollupPlugins = async ({
               type: typePropertyValue.value,
             }
           }
-
           const { type } = assertions
-
           // "specifier" is dynamic on dynamic import such as
           // import(true ? "./a.json" : "b.json", {
           //   assert: {
@@ -978,9 +1062,7 @@ export const createRollupPlugins = async ({
               ),
             )
           }
-
           // There is no strategy for css import assertion on Node.js
-          // and that's normal
           if (type === "css" && node) {
             throw new Error(
               createDetailedMessage(
@@ -1006,29 +1088,31 @@ export const createRollupPlugins = async ({
               },
             }),
           )
-
-          const ressourceUrl = asServerUrl(id)
-          if (external) {
-            if (importAssertionSupportedByRuntime) {
-              const reference =
-                await ressourceBuilder.createReferenceFoundInJsModule({
-                  referenceLabel: "import assertion",
-                  isImportAssertion: true,
-                  jsUrl: url,
-                  jsLine: line,
-                  jsColumn: column,
-                  ressourceSpecifier: ressourceUrl,
-                })
-              // reference can be null for cross origin urls
-              if (!reference) {
-                return
-              }
-              markBuildRelativeUrlAsUsedByJs(
-                reference.ressource.buildRelativeUrl,
-              )
-              return
-            }
-
+          // remove import
+          let ressourceUrl = asServerUrl(id)
+          // lod the asset without ?import_type in it
+          ressourceUrl = ressourceUrl.replace(`?import_type=${type}`, "")
+          const fileReference = ressourceBuilder.createReferenceFoundInJsModule(
+            {
+              referenceLabel: `${type} import assertion`,
+              // If all references to a ressource are only import assertions
+              // the file referenced do not need to be written on filesystem
+              // as it was converted to a js file
+              // We pass "isImportAssertion: true" for this purpose
+              isImportAssertion: true,
+              jsUrl: url,
+              jsLine: line,
+              jsColumn: column,
+              ressourceSpecifier: ressourceUrl,
+              contentTypeExpected:
+                type === "css" ? "text/css" : "application/json",
+            },
+          )
+          // reference can be null for cross origin urls
+          if (!fileReference) {
+            return
+          }
+          if (external && !importAssertionSupportedByRuntime) {
             throw new Error(
               createDetailedMessage(
                 `import assertion ressource cannot be external when runtime do not support import assertions`,
@@ -1041,16 +1125,64 @@ export const createRollupPlugins = async ({
             )
           }
 
-          // we want to convert the import assertions into a js module
-          // to do that we append ?import_type to the url
-          // In theory this is not needed anymore:
-          // This is already done by the compile server
-          const ressourceUrlAsJsModule = setUrlSearchParamsDescriptor(
+          // await fileReference.ressource.getReadyPromise()
+          // once the file is ready, we know its buildRelativeUrl
+          // we can update either to the fileName or buildRelativeUrl
+          // should be use the rollup reference id?
+          const ressourceUrlAsJsModule = resolveUrl(
+            `${urlToBasename(
+              ressourceUrl,
+            )}${outputExtension}?import_type=${type}`,
             ressourceUrl,
-            {
-              import_type: type,
-            },
           )
+          const jsUrl = url
+          urlCustomLoaders[ressourceUrlAsJsModule] = async () => {
+            let code
+            let map
+
+            if (type === "json") {
+              await fileReference.ressource.getReadyPromise()
+              code = String(fileReference.ressource.bufferAfterBuild)
+              const jsModuleConversionResult =
+                await convertJsonTextToJavascriptModule({
+                  code,
+                  map,
+                })
+              code = jsModuleConversionResult.code
+              map = jsModuleConversionResult.map
+            } else if (type === "css") {
+              await fileReference.ressource.getReadyPromise()
+              const cssBuildUrl = resolveUrl(
+                fileReference.ressource.buildRelativeUrl,
+                buildDirectoryUrl,
+              )
+              const jsBuildUrl = resolveUrl(
+                urlToFilename(jsUrl),
+                buildDirectoryUrl,
+              )
+              code = String(fileReference.ressource.bufferAfterBuild)
+              const sourcemapReference =
+                fileReference.ressource.dependencies.find((dependency) => {
+                  return dependency.ressource.isSourcemap
+                })
+              if (sourcemapReference) {
+                // because css is ready, it's sourcemap is also ready
+                // we can read directly sourcemapReference.ressource.bufferAfterBuild
+                map = JSON.parse(sourcemapReference.ressource.bufferAfterBuild)
+              }
+              const jsModuleConversionResult =
+                await convertCssTextToJavascriptModule({
+                  cssUrl: cssBuildUrl,
+                  jsUrl: jsBuildUrl,
+                  code,
+                  map,
+                })
+              code = jsModuleConversionResult.code
+              map = jsModuleConversionResult.map
+            }
+
+            return { code, map }
+          }
 
           mutations.push((magicString) => {
             magicString.overwrite(
@@ -1078,9 +1210,6 @@ export const createRollupPlugins = async ({
 
     // resolveImportMeta: () => {}
     outputOptions: (outputOptions) => {
-      const extension = extname(entryPointMap[Object.keys(entryPointMap)[0]])
-      const outputExtension = extension === ".html" ? ".js" : extension
-
       outputOptions.paths = (id) => {
         const mapping = importPaths[id]
         if (mapping) {
@@ -1093,19 +1222,31 @@ export const createRollupPlugins = async ({
         }
         return id
       }
+      // outputOptions.assetFileNames = () => {
+      //   return `assets/[name]_[hash][extname]`
+      // }
       outputOptions.entryFileNames = () => {
-        if (urlVersionningForEntryPoints) {
-          return `[name]-[hash]${outputExtension}`
+        if (useImportMapToMaximizeCacheReuse) {
+          return `[name]${outputExtension}`
         }
-        return `[name]${outputExtension}`
+        return entryPoints
       }
-      outputOptions.chunkFileNames = () => {
+      outputOptions.chunkFileNames = (chunkInfo) => {
         // const originalUrl = asOriginalUrl(chunkInfo.facadeModuleId)
         // const basename = urlToBasename(originalUrl)
         if (useImportMapToMaximizeCacheReuse) {
           return `[name]${outputExtension}`
         }
-        return `[name]-[hash]${outputExtension}`
+        if (chunkInfo.isEntry) {
+          const originalUrl = asOriginalUrl(chunkInfo.facadeModuleId)
+          const entryPointPattern = entryPointUrls[originalUrl]
+          if (entryPointPattern) {
+            return entryPointPattern
+          }
+        }
+        return urlVersioning
+          ? `[name]_[hash]${outputExtension}`
+          : `[name]${outputExtension}`
       }
 
       // rollup does not expects to have http dependency in the mix: fix them
@@ -1137,190 +1278,204 @@ export const createRollupPlugins = async ({
       return outputOptions
     },
 
+    async renderChunk(code, chunk) {
+      const { facadeModuleId } = chunk
+      if (!facadeModuleId) {
+        // happens for inline module scripts for instance
+        return null
+      }
+
+      const url = asOriginalUrl(facadeModuleId)
+      if (workerUrls.includes(url) || serviceWorkerUrls.includes(url)) {
+        const magicString = new MagicString(code)
+        const systemjsCode = await readFile(
+          new URL("../runtime/s.js", import.meta.url),
+        )
+        magicString.prepend(systemjsCode)
+        code = magicString.toString()
+        const map = magicString.generateMap({ hires: true })
+        return {
+          code,
+          map,
+        }
+      }
+
+      return null
+    },
+
     async generateBundle(outputOptions, rollupResult) {
-      const jsChunks = {}
+      // it's important to do this to emit late asset
+      rollupEmitFile = (...args) => this.emitFile(...args)
+      rollupSetAssetSource = (...args) => this.setAssetSource(...args)
       // To keep in mind: rollupResult object can be mutated by late asset emission
       // however late chunk (js module) emission is not possible
       // as rollup rightfully prevent late js emission
       Object.keys(rollupResult).forEach((fileName) => {
-        const file = rollupResult[fileName]
-
+        const rollupFileInfo = rollupResult[fileName]
         // there is 3 types of file: "placeholder", "asset", "chunk"
-        if (file.type === "asset") {
-          return
-        }
-
-        if (file.type === "chunk") {
-          const { facadeModuleId } = file
+        if (rollupFileInfo.type === "chunk") {
+          const { facadeModuleId } = rollupFileInfo
           if (facadeModuleId === EMPTY_CHUNK_URL) {
+            delete rollupResult[fileName]
             return
           }
-          const fileCopy = { ...file }
           if (facadeModuleId) {
-            fileCopy.url = asServerUrl(facadeModuleId)
+            rollupFileInfo.url = asServerUrl(facadeModuleId)
           } else {
-            const sourcePath = file.map.sources[file.map.sources.length - 1]
-            const fileBuildUrl = resolveUrl(file.fileName, buildDirectoryUrl)
+            const sourcePath =
+              rollupFileInfo.map.sources[rollupFileInfo.map.sources.length - 1]
+            const fileBuildUrl = resolveUrl(fileName, buildDirectoryUrl)
             const originalProjectUrl = resolveUrl(sourcePath, fileBuildUrl)
-            fileCopy.url = asCompiledServerUrl(originalProjectUrl, {
+            rollupFileInfo.url = asCompiledServerUrl(originalProjectUrl, {
               projectDirectoryUrl,
               compileServerOrigin,
               compileDirectoryRelativeUrl,
             })
           }
-          jsChunks[fileName] = fileCopy
-        }
-      })
 
-      const jsModuleBuild = {}
-      Object.keys(jsChunks).forEach((fileName) => {
-        const file = jsChunks[fileName]
-        let buildRelativeUrl
-        const canBeVersioned =
-          asRollupUrl(file.url) in jsModulesFromEntry ||
-          urlVersionningForEntryPoints ||
-          !file.isEntry
-
-        if (file.url in inlineModuleScripts && format === "systemjs") {
-          const code = file.code
-          const systemRegisterIndex = code.indexOf("System.register([")
-          const magicString = new MagicString(code)
-          magicString.overwrite(
-            systemRegisterIndex,
-            systemRegisterIndex + "System.register([".length,
-            `System.register("${fileName}", [`,
-          )
-          file.code = magicString.toString()
-        }
-
-        if (urlVersioning) {
-          if (canBeVersioned && useImportMapToMaximizeCacheReuse) {
-            buildRelativeUrl = computeBuildRelativeUrl(
-              resolveUrl(fileName, buildDirectoryUrl),
-              file.code,
-              {
-                pattern: `[name]-[hash][extname]`,
-                lineBreakNormalization,
-                contentType: "application/javascript",
-              },
+          if (
+            rollupFileInfo.url in inlineModuleScripts &&
+            format === "systemjs"
+          ) {
+            const code = rollupFileInfo.code
+            const systemRegisterIndex = code.indexOf("System.register([")
+            const magicString = new MagicString(code)
+            magicString.overwrite(
+              systemRegisterIndex,
+              systemRegisterIndex + "System.register([".length,
+              `System.register("${fileName}", [`,
             )
-          } else {
-            buildRelativeUrl = fileName
+            rollupFileInfo.code = magicString.toString()
           }
-        } else {
-          buildRelativeUrl = fileName
-          fileName = rollupFileNameWithoutHash(fileName)
-        }
 
-        const originalProjectUrl = asOriginalUrl(file.url)
-        const originalProjectRelativeUrl = urlToRelativeUrl(
-          originalProjectUrl,
-          projectDirectoryUrl,
-        )
-        const jsRessource = ressourceBuilder.findRessource(
-          (ressource) => ressource.url === file.url,
-        )
-        if (jsRessource && jsRessource.isInline) {
-          if (format === "systemjs") {
-            markBuildRelativeUrlAsUsedByJs(buildRelativeUrl)
+          const jsRessource = ressourceBuilder.findRessource((ressource) => {
+            return ressource.url === rollupFileInfo.url
+          })
+          if (
+            isReferencedByJs({
+              rollupFileInfo,
+              jsConcatenation,
+              jsRessource,
+            })
+          ) {
+            ressourcesReferencedByJs.push(fileName)
           }
-          buildInlineFileContents[buildRelativeUrl] = file.code
-        } else {
-          markBuildRelativeUrlAsUsedByJs(buildRelativeUrl)
-          buildMappings[originalProjectRelativeUrl] = buildRelativeUrl
         }
-
-        jsModuleBuild[buildRelativeUrl] = file
       })
 
-      // it's important to do this to emit late asset
-      rollupEmitFile = (...args) => this.emitFile(...args)
-      rollupSetAssetSource = (...args) => this.setAssetSource(...args)
-
       // malheureusement rollup ne permet pas de savoir lorsqu'un chunk
       // a fini d'etre résolu (parsing des imports statiques et dynamiques recursivement)
       // donc lorsque le build se termine on va indiquer
       // aux assets faisant référence a ces chunk js qu'ils sont terminés
       // et donc les assets peuvent connaitre le nom du chunk
       // et mettre a jour leur dépendance vers ce fichier js
-      ressourceBuilder.rollupBuildEnd({ jsModuleBuild, buildManifest })
+      const { jsRessources } = ressourceBuilder.rollupBuildEnd({
+        rollupResult,
+        useImportMapToMaximizeCacheReuse,
+      })
+      Object.keys(jsRessources).forEach((ressourceUrl) => {
+        const jsRessource = jsRessources[ressourceUrl]
+        if (jsRessource.isInline) {
+          buildInlineFileContents[jsRessource.buildRelativeUrl] =
+            jsRessource.bufferAfterBuild
+          // if (format === "systemjs") {
+          //   ressourcesReferencedByJs.push(jsRessource.fileName)
+          // }
+        } else {
+          const originalProjectUrl = asOriginalUrl(ressourceUrl)
+          const originalProjectRelativeUrl = urlToRelativeUrl(
+            originalProjectUrl,
+            projectDirectoryUrl,
+          )
+          buildMappings[originalProjectRelativeUrl] =
+            jsRessource.buildRelativeUrl
+        }
+        buildManifest[jsRessource.fileName] = jsRessource.buildRelativeUrl
+      })
+      // wait for asset build relative urls
+      // to ensure the importmap will contain remappings for them
+      // (not sure this is required anymore)
+      await Promise.all(
+        ressourcesReferencedByJs.map(async (ressourceName) => {
+          const ressource = ressourceBuilder.findRessource((ressource) => {
+            return ressource.relativeUrl === ressourceName
+          })
+          if (ressource && !ressource.isJsModule) {
+            await ressource.getReadyPromise()
+            buildManifest[ressourceName] = ressource.buildRelativeUrl
+          }
+        }),
+      )
       // wait html files to be emitted
       await ressourceBuilder.getAllEntryPointsEmittedPromise()
       onBundleEnd()
 
+      const jsModuleBuild = {}
       const assetBuild = {}
-      Object.keys(rollupResult).forEach((rollupFileId) => {
-        const file = rollupResult[rollupFileId]
-        if (file.type !== "asset") {
-          return
-        }
-
-        const { facadeModuleId } = file
-        if (facadeModuleId === EMPTY_CHUNK_URL) {
-          return
-        }
-
-        const assetRessource = ressourceBuilder.findRessource(
-          (ressource) => ressource.relativeUrl === rollupFileId,
-        )
-        if (!assetRessource) {
-          const buildRelativeUrl = rollupFileId
-          const fileName = rollupFileNameWithoutHash(buildRelativeUrl)
-          assetBuild[buildRelativeUrl] = file
-          buildManifest[fileName] = buildRelativeUrl
-          // the asset does not exists in the project it was generated during building
-          // happens for sourcemap
-          return
-        }
-
-        // ignore potential useless assets which happens when:
-        // - sourcemap re-emitted
-        // - importmap re-emitted to have buildRelativeUrlMap
-        if (assetRessource.shouldBeIgnored) {
-          return
-        }
+      Object.keys(rollupResult).forEach((fileName) => {
+        const rollupFileInfo = rollupResult[fileName]
 
-        // Ignore file only referenced by import assertions
-        // - if file is referenced by import assertion and html or import meta url
-        //   then source file is duplicated. If concatenation is disabled
-        //   and import assertions are supported, the file is still converted to js module
-        const isReferencedOnlyByImportAssertions =
-          assetRessource.references.every((reference) => {
-            return reference.isImportAssertion
+        if (rollupFileInfo.type === "chunk") {
+          const jsRessource = ressourceBuilder.findRessource((ressource) => {
+            return ressource.url === rollupFileInfo.url
           })
-        if (isReferencedOnlyByImportAssertions) {
+          jsModuleBuild[jsRessource.buildRelativeUrl] = rollupFileInfo
           return
         }
 
-        const buildRelativeUrl = assetRessource.buildRelativeUrl
-        const fileName = rollupFileNameWithoutHash(buildRelativeUrl)
-        if (assetRessource.isInline) {
-          buildInlineFileContents[buildRelativeUrl] = file.source
-        } else {
-          const originalProjectUrl = asOriginalUrl(assetRessource.url)
-          const originalProjectRelativeUrl = urlToRelativeUrl(
-            originalProjectUrl,
-            projectDirectoryUrl,
+        if (rollupFileInfo.type === "asset") {
+          const assetRessource = ressourceBuilder.findRessource(
+            (ressource) =>
+              // happens for import.meta.url pattern
+              ressource.fileName === fileName ||
+              // happens for sourcemap
+              ressource.relativeUrl === fileName,
           )
+          // ignore potential useless assets which happens when:
+          // - sourcemap re-emitted
+          // - importmap re-emitted to have buildRelativeUrlMap
+          if (assetRessource.shouldBeIgnored) {
+            return
+          }
+          // Ignore file only referenced by import assertions
+          // - if file is referenced by import assertion and html or import meta url
+          //   then source file is duplicated. If concatenation is disabled
+          //   and import assertions are supported, the file is still converted to js module
+          const isReferencedOnlyByImportAssertions =
+            assetRessource.references.every((reference) => {
+              return reference.isImportAssertion
+            })
+          if (isReferencedOnlyByImportAssertions) {
+            return
+          }
+          const buildRelativeUrl = assetRessource.buildRelativeUrl
+          if (assetRessource.isInline) {
+            buildInlineFileContents[buildRelativeUrl] = rollupFileInfo.source
+            return
+          }
           // in case sourcemap is mutated, we must not trust rollup but the asset builder source instead
-          file.source = assetRessource.bufferAfterBuild
-
-          assetBuild[buildRelativeUrl] = file
-          buildMappings[originalProjectRelativeUrl] = buildRelativeUrl
-          buildManifest[fileName] = buildRelativeUrl
+          rollupFileInfo.source = assetRessource.bufferAfterBuild
+          assetBuild[buildRelativeUrl] = rollupFileInfo
+          buildManifest[assetRessource.fileName] = buildRelativeUrl
+          if (assetRessource.bufferBeforeBuild) {
+            const originalProjectUrl = asOriginalUrl(assetRessource.url)
+            const originalProjectRelativeUrl = urlToRelativeUrl(
+              originalProjectUrl,
+              projectDirectoryUrl,
+            )
+            buildMappings[originalProjectRelativeUrl] = buildRelativeUrl
+          }
+          return
         }
       })
-
       rollupBuild = {
         ...jsModuleBuild,
         ...assetBuild,
       }
-      rollupBuild = injectSourcemapInRollupBuild(rollupBuild, {
-        buildDirectoryUrl,
-      })
-
-      // update rollupBuild, buildInlineFilesContents, buildManifest and buildMappings
-      // in case some ressources where inlined by ressourceBuilder.rollupBuildEnd
+      rollupBuild = sortObjectByPathnames(rollupBuild)
+      // fill "buildFileContents", "buildInlineFilesContents"
+      // and update "buildManifest" and "buildMappings" in case some ressource where inlined
+      // by ressourceBuilder.rollupBuildEnd
       Object.keys(rollupBuild).forEach((buildRelativeUrl) => {
         const rollupFileInfo = rollupBuild[buildRelativeUrl]
         const ressource = ressourceBuilder.findRessource((ressource) => {
@@ -1332,46 +1487,46 @@ export const createRollupPlugins = async ({
           }
           return false
         })
-        if (ressource && ressource.isInline) {
-          const fileName = buildRelativeUrlToFileName(buildRelativeUrl)
-          if (fileName) {
-            delete buildManifest[fileName]
+        if (ressource.isInline) {
+          delete buildManifest[ressource.fileName]
+          if (ressource.isJsModule) {
+            delete jsModuleBuild[buildRelativeUrl]
+          } else {
+            delete assetBuild[buildRelativeUrl]
           }
           const originalProjectUrl = asOriginalUrl(ressource.url)
-          delete buildMappings[
-            urlToRelativeUrl(originalProjectUrl, projectDirectoryUrl)
-          ]
-          buildInlineFileContents[buildRelativeUrl] = rollupFileInfo.code
-          delete rollupBuild[buildRelativeUrl]
+          const originalRelativeUrl = urlToRelativeUrl(
+            originalProjectUrl,
+            projectDirectoryUrl,
+          )
+          delete buildMappings[originalRelativeUrl]
+          buildInlineFileContents[ressource.buildRelativeUrl] =
+            ressource.bufferAfterBuild
+        } else {
+          buildFileContents[ressource.buildRelativeUrl] =
+            ressource.bufferAfterBuild
         }
       })
 
-      await finalizeServiceWorkers({
-        serviceWorkers,
-        serviceWorkerFinalizer,
+      await visitServiceWorkers({
         projectDirectoryUrl,
-        buildDirectoryUrl,
-        rollupBuild,
+        serviceWorkerUrls,
+        classicServiceWorkerUrls,
+        serviceWorkerFinalizer,
         buildMappings,
         buildManifest,
+        buildFileContents,
         lineBreakNormalization,
-        minify,
       })
 
-      rollupBuild = sortObjectByPathnames(rollupBuild)
       buildManifest = sortObjectByPathnames(buildManifest)
       buildMappings = sortObjectByPathnames(buildMappings)
-      Object.keys(rollupBuild).forEach((buildRelativeUrl) => {
-        const { type, source, code } = rollupBuild[buildRelativeUrl]
-        buildFileContents[buildRelativeUrl] = type === "asset" ? source : code
-      })
       const buildDuration = Date.now() - buildStartMs
       buildStats = createBuildStats({
         buildFileContents,
         ressourceBuilder,
         buildDuration,
       })
-
       logger.info(
         formatBuildDoneInfo({
           buildStats,
@@ -1400,7 +1555,7 @@ export const createRollupPlugins = async ({
   return {
     rollupPlugins,
     getLastErrorMessage: () => lastErrorMessage,
-    getResult: () => {
+    getResult: async () => {
       return {
         rollupBuild,
         urlResponseBodyMap: urlLoader.getUrlResponseBodyMap(),
@@ -1419,7 +1574,7 @@ export const createRollupPlugins = async ({
 }
 
 const prepareEntryPoints = async (
-  entryPointMap,
+  entryPoints,
   {
     logger,
     projectDirectoryUrl,
@@ -1428,7 +1583,7 @@ const prepareEntryPoints = async (
     urlFetcher,
   },
 ) => {
-  const entryFileRelativeUrls = Object.keys(entryPointMap)
+  const entryFileRelativeUrls = Object.keys(entryPoints)
   const entryPointsPrepared = []
   await entryFileRelativeUrls.reduce(async (previous, entryFileRelativeUrl) => {
     await previous
@@ -1438,10 +1593,9 @@ const prepareEntryPoints = async (
       projectDirectoryUrl,
     )
     const entryBuildUrl = resolveUrl(
-      entryPointMap[entryFileRelativeUrl],
+      entryPoints[entryFileRelativeUrl],
       buildDirectoryUrl,
     )
-
     const entryProjectRelativeUrl = urlToRelativeUrl(
       entryProjectUrl,
       projectDirectoryUrl,
@@ -1450,20 +1604,16 @@ const prepareEntryPoints = async (
       entryBuildUrl,
       buildDirectoryUrl,
     )
-
     logger.debug(`${UNICODE.INFO} load entry point ${entryProjectRelativeUrl}`)
-
     const entryServerUrl = resolveUrl(
       entryProjectRelativeUrl,
       compileServerOrigin,
     )
-
     const entryResponse = await urlFetcher.fetchUrl(entryServerUrl, {
-      urlTrace: `entryPointMap`,
+      urlTrace: `entryPoints`,
     })
     const entryContentType = entryResponse.headers["content-type"]
     const isHtml = entryContentType === "text/html"
-
     entryPointsPrepared.push({
       entryContentType:
         entryContentType === "text/javascript"
@@ -1511,20 +1661,6 @@ const normalizeRollupResolveReturnValue = (resolveReturnValue) => {
   return resolveReturnValue
 }
 
-const rollupFileNameWithoutHash = (fileName) => {
-  return fileName.replace(/-[a-z0-9]{8,}(\..*?)?$/, (_, afterHash = "") => {
-    return afterHash
-  })
-}
-
-// otherwise importmap handle it as a bare import
-const ensureRelativeUrlNotation = (relativeUrl) => {
-  if (relativeUrl.startsWith("../")) {
-    return relativeUrl
-  }
-  return `./${relativeUrl}`
-}
-
 const externalImportUrlPatternsToExternalUrlPredicate = (
   externalImportUrlPatterns,
   projectDirectoryUrl,
@@ -1560,32 +1696,61 @@ const acceptsJsonContentType = ({ node, format }) => {
   return false
 }
 
-const finalizeServiceWorkers = async ({
-  serviceWorkers,
+const isReferencedByJs = ({ rollupFileInfo, jsConcatenation, jsRessource }) => {
+  if (rollupFileInfo.isDynamicEntry) {
+    return true
+  }
+  if (!jsConcatenation && rollupFileInfo.isEntry) {
+    return true
+  }
+  if (
+    jsRessource &&
+    jsRessource.references.some((ref) => ref.isRessourceHint)
+  ) {
+    return true
+  }
+  return false
+}
+
+const visitServiceWorkers = async ({
+  projectDirectoryUrl,
+  serviceWorkerUrls,
+  classicServiceWorkerUrls,
   serviceWorkerFinalizer,
   buildMappings,
   buildManifest,
-  rollupBuild,
+  buildFileContents,
   lineBreakNormalization,
 }) => {
+  const allServiceWorkerUrls = [
+    ...serviceWorkerUrls,
+    ...classicServiceWorkerUrls,
+  ]
+
   await Promise.all(
-    Object.keys(serviceWorkers).map(async (projectRelativeUrl) => {
-      const projectUrl = resolveUrl(projectRelativeUrl, "file://")
-      projectRelativeUrl = urlToRelativeUrl(projectUrl, "file://")
-      const serviceWorkerBuildRelativeUrl = buildMappings[projectRelativeUrl]
+    allServiceWorkerUrls.map(async (serviceWorkerUrl) => {
+      const serviceWorkerRelativeUrl = urlToRelativeUrl(
+        serviceWorkerUrl,
+        projectDirectoryUrl,
+      )
+      const serviceWorkerBuildRelativeUrl =
+        buildMappings[serviceWorkerRelativeUrl]
       if (!serviceWorkerBuildRelativeUrl) {
         throw new Error(
-          `"${projectRelativeUrl}" service worker file missing in the build`,
+          `"${serviceWorkerRelativeUrl}" service worker file missing in the build`,
         )
       }
-      const buildFileContent = rollupBuild[serviceWorkerBuildRelativeUrl].source
-      rollupBuild[serviceWorkerBuildRelativeUrl].source =
-        serviceWorkerFinalizer(buildFileContent, {
+
+      if (serviceWorkerFinalizer) {
+        let code = buildFileContents[serviceWorkerBuildRelativeUrl]
+        code = await serviceWorkerFinalizer(code, {
           serviceWorkerBuildRelativeUrl,
           buildManifest,
-          rollupBuild,
+          buildFileContents,
           lineBreakNormalization,
         })
+        buildFileContents[serviceWorkerBuildRelativeUrl] = code
+      }
     }),
   )
 }