@jsenv/core 25.0.0-alpha.0 → 25.0.0-alpha.4

package/src/internal/building/rollup_plugin_jsenv.js

@@ -1,6 +1,6 @@
 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 {
@@ -14,6 +14,7 @@ import {
   urlToMeta,
   urlToBasename,
   urlToFilename,
+  readFile,
 } from "@jsenv/filesystem"
 import { UNICODE } from "@jsenv/log"
 
@@ -26,6 +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 { 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,
@@ -44,9 +48,6 @@ import {
 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 { createBuildStats } from "./build_stats.js"
 
 export const createRollupPlugins = async ({
@@ -110,26 +111,19 @@ export const createRollupPlugins = async ({
     const url = resolveUrl(key, projectDirectoryUrl)
     entryPointUrls[url] = entryPoints[key]
   })
-  const workerUrls = {}
-  Object.keys(workers).forEach((key) => {
-    const url = resolveUrl(key, projectDirectoryUrl)
-    workerUrls[url] = workers[key]
-  })
-  const serviceWorkerUrls = {}
-  Object.keys(serviceWorkers).forEach((key) => {
-    const url = resolveUrl(key, projectDirectoryUrl)
-    serviceWorkerUrls[url] = serviceWorkers[key]
-  })
-  const classicWorkerUrls = {}
-  Object.keys(classicWorkers).forEach((key) => {
-    const url = resolveUrl(key, projectDirectoryUrl)
-    classicWorkerUrls[url] = classicWorkers[key]
-  })
-  const classicServiceWorkerUrls = {}
-  Object.keys(classicServiceWorkers).forEach((key) => {
-    const url = resolveUrl(key, projectDirectoryUrl)
-    classicServiceWorkerUrls[url] = classicServiceWorkers[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 classicServiceWorkerUrls = classicServiceWorkers.map(
+    (classicServiceWorker) =>
+      resolveUrl(classicServiceWorker, projectDirectoryUrl),
+  )
 
   let ressourceBuilder
   let importResolver
@@ -155,10 +149,6 @@ export const createRollupPlugins = async ({
 
   const urlVersioner = createUrlVersioner({
     entryPointUrls,
-    workerUrls,
-    classicWorkerUrls,
-    serviceWorkerUrls,
-    classicServiceWorkerUrls,
     asOriginalUrl,
     lineBreakNormalization,
   })
@@ -192,14 +182,16 @@ export const createRollupPlugins = async ({
     projectDirectoryUrl,
   )
 
-  // map build relative urls without hash (called "ressourceName") to real build relative urls
-  let buildManifest = {}
+  // Object mapping project relative urls to build relative urls
+  let buildMappings = {}
+  // Object mapping ressource names to build relative urls
+  let ressourceMappings = {}
 
   const ressourcesReferencedByJs = []
   const createImportMapForFilesUsedInJs = () => {
     const topLevelMappings = {}
     ressourcesReferencedByJs.sort(comparePathnames).forEach((ressourceName) => {
-      const buildRelativeUrl = buildManifest[ressourceName]
+      const buildRelativeUrl = ressourceMappings[ressourceName]
       if (
         ressourceName &&
         buildRelativeUrl &&
@@ -213,12 +205,6 @@ export const createRollupPlugins = async ({
     }
   }
 
-  // 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)
@@ -334,6 +320,7 @@ export const createRollupPlugins = async ({
             : resolveUrl(chunk.fileName, buildDirectoryUrl),
           code,
           map,
+          module: format === "esmodule",
           ...(format === "global" ? { toplevel: false } : { toplevel: true }),
         })
 
@@ -463,9 +450,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) {
@@ -488,16 +487,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
           }
         }
 
@@ -624,32 +626,27 @@ export const createRollupPlugins = async ({
             }
 
             const originalUrl = asOriginalUrl(projectUrl)
-            const workerBuildRelativeUrl = workerUrls[originalUrl]
-            if (workerBuildRelativeUrl) {
+            if (workerUrls.includes(originalUrl)) {
               return {
                 isWorker: true,
                 isJsModule: true,
                 url: ressourceUrl,
               }
             }
-            const serviceWorkerBuildRelativeUrl = serviceWorkerUrls[originalUrl]
-            if (serviceWorkerBuildRelativeUrl) {
+            if (serviceWorkerUrls.includes(originalUrl)) {
               return {
                 isServiceWorker: true,
                 isJsModule: true,
                 url: ressourceUrl,
               }
             }
-            const classicWorkerBuildRelativeUrl = classicWorkerUrls[originalUrl]
-            if (classicWorkerBuildRelativeUrl) {
+            if (classicWorkerUrls.includes(originalUrl)) {
               return {
                 isWorker: true,
                 url: ressourceUrl,
               }
             }
-            const classicServiceWorkerBuildRelativeUrl =
-              classicServiceWorkerUrls[originalUrl]
-            if (classicServiceWorkerBuildRelativeUrl) {
+            if (classicServiceWorkerUrls.includes(originalUrl)) {
               return {
                 isServiceWorker: true,
                 url: ressourceUrl,
@@ -781,7 +778,7 @@ export const createRollupPlugins = async ({
       }
     },
 
-    async resolveId(specifier, importer, { custom }) {
+    async resolveId(specifier, importer, { custom = {} } = {}) {
       if (specifier === EMPTY_CHUNK_URL) {
         return specifier
       }
@@ -819,7 +816,7 @@ export const createRollupPlugins = async ({
       }
 
       if (inlineModuleScripts.hasOwnProperty(specifier)) {
-        return specifier
+        return asRollupUrl(specifier)
       }
 
       const importUrl = await importResolver.resolveImport(
@@ -868,31 +865,28 @@ export const createRollupPlugins = async ({
 
     resolveFileUrl: ({ referenceId, 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) {
           return `window.__resolveImportUrl__("./${fileName}", import.meta.url)`
         }
-        return `new URL("${fileName}", import.meta.url)`
+        return `new URL("${getBuildRelativeUrl()}", import.meta.url)`
       }
       if (format === "systemjs") {
         return `new URL(System.resolve("./${fileName}", module.meta.url))`
       }
       if (format === "global") {
-        const ressource = ressourceBuilder.findRessource((ressource) => {
-          return ressource.rollupReferenceId === referenceId
-        })
-        ressource.fileName = fileName
-        const buildRelativeUrl = ressource.buildRelativeUrl
-        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") {
-        const ressource = ressourceBuilder.findRessource((ressource) => {
-          return ressource.rollupReferenceId === referenceId
-        })
-        ressource.fileName = fileName
-        const buildRelativeUrl = ressource.buildRelativeUrl
-        return `new URL("${buildRelativeUrl}", "file:///" + __filename.replace(/\\/g, "/"))`
+        return `new URL("${getBuildRelativeUrl()}", "file:///" + __filename.replace(/\\/g, "/"))`
       }
       return null
     },
@@ -973,12 +967,22 @@ export const createRollupPlugins = async ({
         onReferenceWithImportMetaUrlPattern: async ({ importNode }) => {
           const specifier = importNode.arguments[0].value
           const { line, column } = importNode.loc.start
+
+          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: specifier,
+            ressourceSpecifier: ressourceUrl,
+            isJsModule,
           })
           if (!reference) {
             return
@@ -1270,45 +1274,65 @@ 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 rollupJsFileInfos = {}
-      const rollupAssetFileInfos = {}
+      // 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 rollupFileInfo = rollupResult[fileName]
-
         // there is 3 types of file: "placeholder", "asset", "chunk"
-        if (rollupFileInfo.type === "asset") {
-          rollupAssetFileInfos[fileName] = rollupFileInfo
-          return
-        }
-
         if (rollupFileInfo.type === "chunk") {
           const { facadeModuleId } = rollupFileInfo
           if (facadeModuleId === EMPTY_CHUNK_URL) {
+            delete rollupResult[fileName]
             return
           }
-          const fileCopy = { ...rollupFileInfo }
           if (facadeModuleId) {
-            fileCopy.url = asServerUrl(facadeModuleId)
+            rollupFileInfo.url = asServerUrl(facadeModuleId)
           } else {
             const sourcePath =
               rollupFileInfo.map.sources[rollupFileInfo.map.sources.length - 1]
-            const fileBuildUrl = resolveUrl(
-              rollupFileInfo.fileName,
-              buildDirectoryUrl,
-            )
+            const fileBuildUrl = resolveUrl(fileName, buildDirectoryUrl)
             const originalProjectUrl = resolveUrl(sourcePath, fileBuildUrl)
-            fileCopy.url = asCompiledServerUrl(originalProjectUrl, {
+            rollupFileInfo.url = asCompiledServerUrl(originalProjectUrl, {
               projectDirectoryUrl,
               compileServerOrigin,
               compileDirectoryRelativeUrl,
             })
           }
 
-          if (fileCopy.url in inlineModuleScripts && format === "systemjs") {
+          if (
+            rollupFileInfo.url in inlineModuleScripts &&
+            format === "systemjs"
+          ) {
             const code = rollupFileInfo.code
             const systemRegisterIndex = code.indexOf("System.register([")
             const magicString = new MagicString(code)
@@ -1317,27 +1341,24 @@ export const createRollupPlugins = async ({
               systemRegisterIndex + "System.register([".length,
               `System.register("${fileName}", [`,
             )
-            fileCopy.code = magicString.toString()
+            rollupFileInfo.code = magicString.toString()
           }
 
+          const jsRessource = ressourceBuilder.findRessource((ressource) => {
+            return ressource.url === rollupFileInfo.url
+          })
           if (
             isReferencedByJs({
-              rollupFileInfo: fileCopy,
+              rollupFileInfo,
               jsConcatenation,
-              ressourceBuilder,
+              jsRessource,
             })
           ) {
-            ressourcesReferencedByJs.push(fileCopy.fileName)
+            ressourcesReferencedByJs.push(fileName)
           }
-
-          rollupJsFileInfos[fileName] = fileCopy
         }
       })
 
-      // 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
@@ -1345,8 +1366,7 @@ export const createRollupPlugins = async ({
       // et donc les assets peuvent connaitre le nom du chunk
       // et mettre a jour leur dépendance vers ce fichier js
       const { jsRessources } = ressourceBuilder.rollupBuildEnd({
-        rollupJsFileInfos,
-        rollupAssetFileInfos,
+        rollupResult,
         useImportMapToMaximizeCacheReuse,
       })
       Object.keys(jsRessources).forEach((ressourceUrl) => {
@@ -1354,9 +1374,9 @@ export const createRollupPlugins = async ({
         if (jsRessource.isInline) {
           buildInlineFileContents[jsRessource.buildRelativeUrl] =
             jsRessource.bufferAfterBuild
-          if (format === "systemjs") {
-            ressourcesReferencedByJs.push(jsRessource.fileName)
-          }
+          // if (format === "systemjs") {
+          //   ressourcesReferencedByJs.push(jsRessource.fileName)
+          // }
         } else {
           const originalProjectUrl = asOriginalUrl(ressourceUrl)
           const originalProjectRelativeUrl = urlToRelativeUrl(
@@ -1366,10 +1386,8 @@ export const createRollupPlugins = async ({
           buildMappings[originalProjectRelativeUrl] =
             jsRessource.buildRelativeUrl
         }
-
-        buildManifest[jsRessource.fileName] = jsRessource.buildRelativeUrl
+        ressourceMappings[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)
@@ -1380,68 +1398,70 @@ export const createRollupPlugins = async ({
           })
           if (ressource && !ressource.isJsModule) {
             await ressource.getReadyPromise()
-            buildManifest[ressourceName] = ressource.buildRelativeUrl
+            ressourceMappings[ressourceName] = ressource.buildRelativeUrl
           }
         }),
       )
-
       // wait html files to be emitted
       await ressourceBuilder.getAllEntryPointsEmittedPromise()
       onBundleEnd()
-      const jsModuleBuild = {
-        ...rollupJsFileInfos,
-      }
+
+      const jsModuleBuild = {}
       const assetBuild = {}
       Object.keys(rollupResult).forEach((fileName) => {
-        const file = rollupResult[fileName]
-        if (file.type !== "asset") {
-          return
-        }
-
-        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
-        }
+        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
-        if (assetRessource.isInline) {
-          buildInlineFileContents[buildRelativeUrl] = file.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
-        buildManifest[assetRessource.fileName] = buildRelativeUrl
-        if (assetRessource.bufferBeforeBuild) {
-          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,
           )
-          buildMappings[originalProjectRelativeUrl] = buildRelativeUrl
+          // 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
+          rollupFileInfo.source = assetRessource.bufferAfterBuild
+          assetBuild[buildRelativeUrl] = rollupFileInfo
+          ressourceMappings[assetRessource.fileName] = buildRelativeUrl
+          if (assetRessource.bufferBeforeBuild) {
+            const originalProjectUrl = asOriginalUrl(assetRessource.url)
+            const originalProjectRelativeUrl = urlToRelativeUrl(
+              originalProjectUrl,
+              projectDirectoryUrl,
+            )
+            buildMappings[originalProjectRelativeUrl] = buildRelativeUrl
+          }
+          return
         }
       })
       rollupBuild = {
@@ -1450,12 +1470,12 @@ export const createRollupPlugins = async ({
       }
       rollupBuild = sortObjectByPathnames(rollupBuild)
       // fill "buildFileContents", "buildInlineFilesContents"
-      // and update "buildManifest" and "buildMappings" in case some ressource where inlined
-      // by ressourceBuilder.rollupBuildEnd
-      Object.keys(rollupBuild).forEach((fileName) => {
-        const rollupFileInfo = rollupBuild[fileName]
+      // and update "buildMappings"
+      // in case some ressource where inlined by ressourceBuilder.rollupBuildEnd
+      Object.keys(rollupBuild).forEach((buildRelativeUrl) => {
+        const rollupFileInfo = rollupBuild[buildRelativeUrl]
         const ressource = ressourceBuilder.findRessource((ressource) => {
-          if (ressource.buildRelativeUrl === fileName) {
+          if (ressource.buildRelativeUrl === buildRelativeUrl) {
             return true
           }
           if (ressource.url === rollupFileInfo.url) {
@@ -1464,7 +1484,11 @@ export const createRollupPlugins = async ({
           return false
         })
         if (ressource.isInline) {
-          delete buildManifest[fileName]
+          if (ressource.isJsModule) {
+            delete jsModuleBuild[buildRelativeUrl]
+          } else {
+            delete assetBuild[buildRelativeUrl]
+          }
           const originalProjectUrl = asOriginalUrl(ressource.url)
           const originalRelativeUrl = urlToRelativeUrl(
             originalProjectUrl,
@@ -1479,22 +1503,18 @@ export const createRollupPlugins = async ({
         }
       })
 
-      await finalizeServiceWorkers({
-        serviceWorkers,
-        classicServiceWorkers,
-        serviceWorkerFinalizer,
+      ressourceMappings = sortObjectByPathnames(ressourceMappings)
+      buildMappings = sortObjectByPathnames(buildMappings)
+      await visitServiceWorkers({
         projectDirectoryUrl,
-        buildDirectoryUrl,
-        rollupBuild,
+        serviceWorkerUrls,
+        classicServiceWorkerUrls,
+        serviceWorkerFinalizer,
         buildMappings,
-        buildManifest,
+        ressourceMappings,
         buildFileContents,
         lineBreakNormalization,
-        minify,
       })
-
-      buildManifest = sortObjectByPathnames(buildManifest)
-      buildMappings = sortObjectByPathnames(buildMappings)
       const buildDuration = Date.now() - buildStartMs
       buildStats = createBuildStats({
         buildFileContents,
@@ -1534,7 +1554,11 @@ export const createRollupPlugins = async ({
         rollupBuild,
         urlResponseBodyMap: urlLoader.getUrlResponseBodyMap(),
         buildMappings,
-        buildManifest,
+        ressourceMappings,
+        // Object mapping build relative urls without hash to build relative urls
+        buildManifest: createBuildManifest({
+          buildFileContents,
+        }),
         buildImportMap: createImportMapForFilesUsedInJs(),
         buildFileContents,
         buildInlineFileContents,
@@ -1547,6 +1571,21 @@ export const createRollupPlugins = async ({
   }
 }
 
+const createBuildManifest = ({ buildFileContents }) => {
+  const buildManifest = {}
+  Object.keys(buildFileContents).forEach((buildRelativeUrl) => {
+    const relativeUrlWithoutHash = asFileNameWithoutHash(buildRelativeUrl)
+    buildManifest[relativeUrlWithoutHash] = buildRelativeUrl
+  })
+  return buildManifest
+}
+
+const asFileNameWithoutHash = (fileName) => {
+  return fileName.replace(/_[a-z0-9]{8,}(\..*?)?$/, (_, afterHash = "") => {
+    return afterHash
+  })
+}
+
 const prepareEntryPoints = async (
   entryPoints,
   {
@@ -1670,17 +1709,10 @@ const acceptsJsonContentType = ({ node, format }) => {
   return false
 }
 
-const isReferencedByJs = ({
-  rollupFileInfo,
-  jsConcatenation,
-  ressourceBuilder,
-}) => {
+const isReferencedByJs = ({ rollupFileInfo, jsConcatenation, jsRessource }) => {
   if (rollupFileInfo.isDynamicEntry) {
     return true
   }
-  const jsRessource = ressourceBuilder.findRessource((ressource) => {
-    return ressource.url === rollupFileInfo.url
-  })
   if (!jsConcatenation && rollupFileInfo.isEntry) {
     return true
   }
@@ -1693,50 +1725,38 @@ const isReferencedByJs = ({
   return false
 }
 
-const finalizeServiceWorkers = async ({
-  serviceWorkers,
-  classicServiceWorkers,
+const visitServiceWorkers = async ({
+  projectDirectoryUrl,
+  serviceWorkerUrls,
+  classicServiceWorkerUrls,
   serviceWorkerFinalizer,
   buildMappings,
-  buildManifest,
   buildFileContents,
   lineBreakNormalization,
 }) => {
-  const serviceWorkerKeys = Object.keys(serviceWorkers)
-  const classicServiceWorkerKeys = Object.keys(classicServiceWorkers)
-  const projectRelativeUrls = [
-    ...serviceWorkerKeys,
-    ...classicServiceWorkerKeys,
+  const allServiceWorkerUrls = [
+    ...serviceWorkerUrls,
+    ...classicServiceWorkerUrls,
   ]
 
   await Promise.all(
-    projectRelativeUrls.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`,
         )
       }
 
-      // module service worker
-      if (serviceWorkerKeys.includes(projectRelativeUrl)) {
-        let code = buildFileContents[serviceWorkerBuildRelativeUrl]
-        code = await serviceWorkerFinalizer(code, {
-          serviceWorkerBuildRelativeUrl,
-          buildManifest,
-          buildFileContents,
-          lineBreakNormalization,
-        })
-        buildFileContents[serviceWorkerBuildRelativeUrl] = code
-      }
-      // "classic" service worker
-      else {
+      if (serviceWorkerFinalizer) {
         let code = buildFileContents[serviceWorkerBuildRelativeUrl]
         code = await serviceWorkerFinalizer(code, {
           serviceWorkerBuildRelativeUrl,
-          buildManifest,
           buildFileContents,
           lineBreakNormalization,
         })