@jsenv/core 24.1.0-alpha.0 → 24.3.1

package/src/internal/building/css_module.js

@@ -1,6 +1,6 @@
 import { resolveUrl, urlToRelativeUrl } from "@jsenv/filesystem"
 
-import { replaceCssUrls } from "@jsenv/core/src/internal/building/css/replaceCssUrls.js"
+import { moveCssUrls } from "@jsenv/core/src/internal/building/css/moveCssUrls.js"
 import { escapeTemplateStringSpecialCharacters } from "@jsenv/core/src/internal/escapeTemplateStringSpecialCharacters.js"
 import {
   getCssSourceMappingUrl,
@@ -16,18 +16,14 @@ export const convertCssTextToJavascriptModule = async ({
   const directoryUrl = resolveUrl("./", cssUrl)
   const jsDirectoryUrl = resolveUrl("./", jsUrl)
   if (directoryUrl !== jsDirectoryUrl) {
-    const cssUrlReplaceResult = await replaceCssUrls({
-      url: cssUrl,
+    const moveUrlResult = await moveCssUrls({
+      from: cssUrl,
+      to: jsUrl,
       code,
       map,
-      getUrlReplacementValue: ({ specifier }) => {
-        const urlForCss = resolveUrl(specifier, cssUrl)
-        const urlForJs = urlToRelativeUrl(urlForCss, jsUrl)
-        return urlForJs
-      },
     })
-    code = cssUrlReplaceResult.code
-    map = cssUrlReplaceResult.map
+    code = moveUrlResult.code
+    map = moveUrlResult.map
     const sourcemapUrlSpecifier = getCssSourceMappingUrl(code)
     const sourcemapUrlForCss = resolveUrl(sourcemapUrlSpecifier, cssUrl)
     const sourcemapUrlForJs = urlToRelativeUrl(sourcemapUrlForCss, jsUrl)

package/src/internal/building/html/parseHtmlRessource.js

@@ -51,6 +51,7 @@ import {
 import { collectNodesMutations } from "../parsing.utils.js"
 
 import { collectSvgMutations } from "../svg/parseSvgRessource.js"
+import { moveCssUrls } from "../css/moveCssUrls.js"
 
 export const parseHtmlRessource = async (
   htmlRessource,
@@ -144,11 +145,12 @@ export const parseHtmlRessource = async (
   ]
 
   return async (params) => {
-    htmlMutations.forEach((mutationCallback) => {
-      mutationCallback({
+    await htmlMutations.reduce(async (previous, mutationCallback) => {
+      await previous
+      await mutationCallback({
         ...params,
       })
-    })
+    }, Promise.resolve())
 
     const htmlAfterTransformation = htmlAstToHtmlString(htmlAst)
     const html = minify
@@ -507,7 +509,11 @@ const linkStylesheetHrefVisitor = (
     ressourceSpecifier: hrefAttribute.value,
     ...referenceLocationFromHtmlNode(link, "href"),
   })
-  return ({ getUrlRelativeToImporter }) => {
+  return async ({
+    getUrlRelativeToImporter,
+    precomputeBuildRelativeUrl,
+    buildDirectoryUrl,
+  }) => {
     const { ressource } = cssReference
 
     if (ressource.isExternal) {
@@ -516,18 +522,38 @@ const linkStylesheetHrefVisitor = (
 
     if (shouldInline({ ressource, htmlNode: link })) {
       const { bufferAfterBuild } = ressource
-      let cssString = String(bufferAfterBuild)
-      const sourcemapRelativeUrl = getCssSourceMappingUrl(cssString)
+      let code = String(bufferAfterBuild)
+      const { buildRelativeUrl } = ressource
+      const cssBuildUrl = resolveUrl(buildRelativeUrl, buildDirectoryUrl)
+      const htmlUrl = resolveUrl(
+        precomputeBuildRelativeUrl(htmlRessource),
+        buildDirectoryUrl,
+      )
+
+      const moveResult = await moveCssUrls({
+        code,
+        from: cssBuildUrl,
+        to: htmlUrl,
+        // moveCssUrls will change the css source code
+        // Ideally we should update the sourcemap referenced by css
+        // to target the one after css urls are moved.
+        // It means we should force sourcemap ressource to the new one
+        // until it's supported we prevent postcss from updating the
+        // sourcemap comment, othwise css would reference a sourcemap
+        // that won't by in the build directory
+        sourcemapMethod: null,
+      })
+      code = moveResult.code
+
+      const sourcemapRelativeUrl = getCssSourceMappingUrl(code)
       if (sourcemapRelativeUrl) {
-        const { buildRelativeUrl } = ressource
-        const cssBuildUrl = resolveUrl(buildRelativeUrl, "file:///")
+        const cssBuildUrl = resolveUrl(buildRelativeUrl, buildDirectoryUrl)
         const sourcemapBuildUrl = resolveUrl(sourcemapRelativeUrl, cssBuildUrl)
-        const htmlUrl = resolveUrl(htmlRessource.fileNamePattern, "file:///")
         const sourcemapInlineUrl = urlToRelativeUrl(sourcemapBuildUrl, htmlUrl)
-        cssString = setCssSourceMappingUrl(cssString, sourcemapInlineUrl)
+        code = setCssSourceMappingUrl(code, sourcemapInlineUrl)
       }
 
-      replaceHtmlNode(link, `<style>${cssString}</style>`, {
+      replaceHtmlNode(link, `<style>${code}</style>`, {
         attributesToIgnore: ["href", "rel", "as", "crossorigin", "type"],
       })
       cssReference.inlinedCallback()

package/src/internal/building/parseRessource.js

@@ -39,6 +39,7 @@ export const parseRessource = (
     minifyJs,
     minifyHtml,
     minifyCssOptions,
+    cssConcatenation,
   },
 ) => {
   const { contentType } = ressource
@@ -124,10 +125,12 @@ export const parseRessource = (
 
   if (contentType === "text/css") {
     return parseCssRessource(ressource, notifiers, {
+      asProjectUrl,
       asOriginalUrl,
       asOriginalServerUrl,
       minify,
       minifyCssOptions,
+      cssConcatenation,
     })
   }
 

package/src/internal/building/ressource_builder.js

@@ -49,6 +49,7 @@ export const createRessourceBuilder = (
     entryUrl,
     entryBuffer,
     entryBuildRelativeUrl,
+    urlVersionningForEntryPoints,
   }) => {
     // The entry point is conceptually referenced by code passing "entryPointMap"
     // to buildProject. So we analyse stack trace to put this function caller
@@ -68,8 +69,12 @@ export const createRessourceBuilder = (
       isEntryPoint: true,
 
       // don't hash asset entry points
-      urlVersioningDisabled: true,
-      fileNamePattern: entryBuildRelativeUrl,
+      ...(urlVersionningForEntryPoints
+        ? {}
+        : {
+            urlVersioningDisabled: true,
+            fileNamePattern: entryBuildRelativeUrl,
+          }),
     })
     entryReference.isProgrammatic = true
 
@@ -567,6 +572,10 @@ export const createRessourceBuilder = (
       )
       await transform({
         buildDirectoryUrl,
+        precomputeBuildRelativeUrl: (ressource) =>
+          precomputeBuildRelativeUrlForRessource(ressource, {
+            lineBreakNormalization,
+          }),
         getUrlRelativeToImporter: (referencedRessource) => {
           const ressourceImporter = ressource
 
@@ -1021,7 +1030,7 @@ const isEmitChunkNeeded = ({ ressource, reference }) => {
  *
  * see also:
  * - https://rollupjs.org/guide/en/#thisemitfileemittedfile-emittedchunk--emittedasset--string
- * -https://github.com/rollup/rollup/issues/2872
+ * - https://github.com/rollup/rollup/issues/2872
  */
 const referenceShouldBeIgnoredWarning = ({
   isJsModule,

package/src/internal/compiling/babel_plugin_import_assertions.js

@@ -10,8 +10,7 @@ export const babelPluginImportAssertions = (
   return {
     ...babelPluginImportVisitor(
       babel,
-      // During the build we throw when for import call expression where
-      // sepcifier or type is dynamic.
+      // During build we throw on import call expression where "specifier" or "type" is dynamic
       // Here there is no strong need to throw because keeping the source code intact
       // will throw an error when browser will execute the code
       ({ importPath, specifierPath }) => {

package/src/internal/compiling/compile-directory/validateCache.js

@@ -20,11 +20,6 @@ export const validateCache = async ({
 }) => {
   const validity = { isValid: true }
 
-  // disable cahce for html files so that we always parse the importmap file
-  if (compiledFileUrl.endsWith(".html")) {
-    return { isValid: false }
-  }
-
   const metaJsonFileUrl = `${compiledFileUrl}__asset__meta.json`
   const metaValidity = await validateMetaFile(metaJsonFileUrl)
   mergeValidity(validity, "meta", metaValidity)

package/src/internal/compiling/compileFile.js

@@ -5,7 +5,6 @@ import {
   bufferToEtag,
   urlIsInsideOf,
 } from "@jsenv/filesystem"
-import { normalizeImportMap, resolveImport } from "@jsenv/importmap"
 import { convertFileSystemErrorToResponseProperties } from "@jsenv/server/src/internal/convertFileSystemErrorToResponseProperties.js"
 
 import { getOrGenerateCompiledFile } from "./compile-directory/getOrGenerateCompiledFile.js"
@@ -109,15 +108,10 @@ export const compileFile = async ({
     })
 
     if (request.http2) {
-      // js resolution is special, we cannot just do resolveUrl of the import specifier
-      // because there can be importmap (bare specifier, import without extension, custom remapping, ...)
-      // And we would push 404 to the browser
-      // Until we implement import map resolution pushing ressource for js imports is disabled
       const dependencyResolver = getDependencyResolver({
         compileResult,
         importmapInfos,
         request,
-        projectDirectoryUrl,
       })
       if (dependencyResolver) {
         compileResult.dependencies.forEach((dependency) => {
@@ -236,61 +230,30 @@ export const compileFile = async ({
   }
 }
 
-const getDependencyResolver = ({
-  compileResult,
-  importmapInfos,
-  request,
-  projectDirectoryUrl,
-}) => {
+const getDependencyResolver = ({ compileResult, importmapInfos, request }) => {
   const importmapKeys = Object.keys(importmapInfos)
   const requestUrl = resolveUrl(request.ressource, request.origin)
 
   if (
-    compileResult.contentType !== "application/javascript" ||
-    importmapKeys.length === 0
+    compileResult.contentType === "application/javascript" &&
+    // we cannot trust importmapKeys because when html is restored from cache
+    // it would be empty
+    importmapKeys.length > 0
   ) {
-    return {
-      type: "url_resolution",
-      resolve: (dependency) => {
-        const dependencyUrl = resolveUrl(dependency, requestUrl)
-        return dependencyUrl
-      },
-    }
-  }
-
-  const firstImportmapInfo = importmapInfos[importmapKeys[0]]
-  if (!firstImportmapInfo.text) {
+    // js resolution is special, we cannot just do resolveUrl of the import specifier
+    // because there can be importmap (bare specifier, import without extension, custom remapping, ...)
+    // And we would push 404 to the browser
+    // BUT I tried to push everything to the browser and it was a big fail:
+    // server is trying to push streams but browser rejects most push streams
+    // either because main file is already fetched or an other file request the same ressource
     return null
   }
 
-  if (
-    // we are aware only of 1 importmap
-    importmapKeys.length === 1 ||
-    // all importmaps are the same
-    importmapKeys.slice(1).every(({ url }) => url === firstImportmapInfo.url)
-  ) {
-    const importMapBaseUrl = resolveUrl(
-      urlToRelativeUrl(firstImportmapInfo.url, projectDirectoryUrl),
-      `${request.origin}/`,
-    )
-    const importMap = normalizeImportMap(
-      JSON.parse(firstImportmapInfo.text),
-      importMapBaseUrl,
-    )
-    return {
-      type: "importmap_resolution",
-      resolve: (dependency) => {
-        const dependencyUrl = resolveImport({
-          specifier: dependency,
-          importer: requestUrl,
-          importMap,
-        })
-        return dependencyUrl
-      },
-    }
+  return {
+    type: "url_resolution",
+    resolve: (dependency) => {
+      const dependencyUrl = resolveUrl(dependency, requestUrl)
+      return dependencyUrl
+    },
   }
-
-  // there is more than 2 importmaps, we cannot know which one to pick
-  // (not supposed ot happen because during dev you usually use a single importmap)
-  return null
 }

package/src/internal/compiling/createCompiledFileService.js

@@ -48,6 +48,7 @@ export const createCompiledFileService = ({
   groupMap,
   customCompilers,
 
+  jsenvEventSourceClientInjection,
   jsenvToolbarInjection,
 
   projectFileRequestedCallback,
@@ -197,6 +198,7 @@ export const createCompiledFileService = ({
 
           sourcemapMethod,
           sourcemapExcludeSources,
+          jsenvEventSourceClientInjection,
           jsenvToolbarInjection,
           onHtmlImportmapInfo: ({ htmlUrl, importmapInfo }) => {
             importmapInfos[htmlUrl] = importmapInfo

package/src/internal/compiling/html_source_file_service.js

@@ -21,12 +21,12 @@ import {
 import { moveImportMap } from "@jsenv/importmap"
 import { createDetailedMessage } from "@jsenv/logger"
 
-import { fetchUrl } from "@jsenv/core/src/internal/fetchUrl.js"
 import {
-  jsenvToolbarHtmlFileInfo,
-  jsenvBrowserSystemFileInfo,
-  jsenvToolbarInjectorFileInfo,
-} from "@jsenv/core/src/internal/jsenvInternalFiles.js"
+  BROWSER_RUNTIME_BUILD_URL,
+  EVENT_SOURCE_CLIENT_BUILD_URL,
+  TOOLBAR_INJECTOR_BUILD_URL,
+} from "@jsenv/core/dist/build_manifest.js"
+import { fetchUrl } from "@jsenv/core/src/internal/fetchUrl.js"
 import { stringifyDataUrl } from "@jsenv/core/src/internal/dataUrl.utils.js"
 import {
   parseHtmlString,
@@ -41,12 +41,17 @@ import {
   setHtmlNodeText,
   getUniqueNameForInlineHtmlNode,
 } from "./compileHtml.js"
+import { jsenvCoreDirectoryUrl } from "../jsenvCoreDirectoryUrl.js"
+
+const jsenvDistDirectoryUrl = new URL("./dist/", jsenvCoreDirectoryUrl).href
 
 export const createTransformHtmlSourceFileService = ({
   logger,
   projectDirectoryUrl,
+  projectFileRequestedCallback,
   inlineImportMapIntoHTML,
   jsenvScriptInjection,
+  jsenvEventSourceClientInjection,
   jsenvToolbarInjection,
 }) => {
   /**
@@ -66,6 +71,10 @@ export const createTransformHtmlSourceFileService = ({
     const relativeUrl = ressource.slice(1)
     const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
 
+    if (urlIsInsideOf(fileUrl, jsenvDistDirectoryUrl)) {
+      return null
+    }
+
     const inlineScript = htmlInlineScriptMap.get(fileUrl)
     if (inlineScript) {
       return {
@@ -93,6 +102,7 @@ export const createTransformHtmlSourceFileService = ({
       }
       throw e
     }
+    projectFileRequestedCallback(relativeUrl, request)
     htmlInlineScriptMap.forEach((inlineScript, inlineScriptUrl) => {
       if (inlineScript.htmlFileUrl === fileUrl) {
         htmlInlineScriptMap.delete(inlineScriptUrl)
@@ -107,6 +117,7 @@ export const createTransformHtmlSourceFileService = ({
       pushResponse,
       inlineImportMapIntoHTML,
       jsenvScriptInjection,
+      jsenvEventSourceClientInjection,
       jsenvToolbarInjection,
       onInlineModuleScript: ({ scriptContent, scriptIdentifier }) => {
         const inlineScriptUrl = resolveUrl(scriptIdentifier, fileUrl)
@@ -138,8 +149,11 @@ const transformHTMLSourceFile = async ({
   inlineImportMapIntoHTML,
   jsenvScriptInjection,
   jsenvToolbarInjection,
+  jsenvEventSourceClientInjection,
   onInlineModuleScript = () => {},
 }) => {
+  fileUrl = urlWithoutSearch(fileUrl)
+
   const htmlAst = parseHtmlString(fileContent)
   if (inlineImportMapIntoHTML) {
     await inlineImportmapScripts({
@@ -150,27 +164,43 @@ const transformHTMLSourceFile = async ({
     })
   }
 
-  const jsenvBrowserBuildUrlRelativeToProject = urlToRelativeUrl(
-    jsenvBrowserSystemFileInfo.jsenvBuildUrl,
+  const browserRuntimeBuildUrlRelativeToProject = urlToRelativeUrl(
+    BROWSER_RUNTIME_BUILD_URL,
     projectDirectoryUrl,
   )
-  const jsenvToolbarInjectorBuildRelativeUrlForProject = urlToRelativeUrl(
-    jsenvToolbarInjectorFileInfo.jsenvBuildUrl,
+
+  const eventSourceClientBuildRelativeUrlForProject = urlToRelativeUrl(
+    EVENT_SOURCE_CLIENT_BUILD_URL,
     projectDirectoryUrl,
   )
+
+  const toolbarInjectorBuildRelativeUrlForProject = urlToRelativeUrl(
+    TOOLBAR_INJECTOR_BUILD_URL,
+    projectDirectoryUrl,
+  )
+
   manipulateHtmlAst(htmlAst, {
     scriptInjections: [
-      ...(fileUrl !== jsenvToolbarHtmlFileInfo.url && jsenvScriptInjection
+      ...(jsenvScriptInjection
         ? [
             {
-              src: `/${jsenvBrowserBuildUrlRelativeToProject}`,
+              src: `/${browserRuntimeBuildUrlRelativeToProject}`,
             },
           ]
         : []),
-      ...(fileUrl !== jsenvToolbarHtmlFileInfo.url && jsenvToolbarInjection
+      ...(jsenvEventSourceClientInjection
         ? [
             {
-              src: `/${jsenvToolbarInjectorBuildRelativeUrlForProject}`,
+              src: `/${eventSourceClientBuildRelativeUrlForProject}`,
+            },
+          ]
+        : []),
+      ...(jsenvToolbarInjection
+        ? [
+            {
+              src: `/${toolbarInjectorBuildRelativeUrlForProject}`,
+              defer: "",
+              async: "",
             },
           ]
         : []),
@@ -401,3 +431,9 @@ const getJsenvForceInlineAttribute = (htmlNode) => {
   )
   return jsenvForceInlineAttribute
 }
+
+const urlWithoutSearch = (url) => {
+  const urlObject = new URL(url)
+  urlObject.search = ""
+  return urlObject.href
+}

package/src/internal/compiling/jsenvCompilerForHtml.js

@@ -3,12 +3,13 @@ import { moveImportMap, composeTwoImportMaps } from "@jsenv/importmap"
 import { createDetailedMessage } from "@jsenv/logger"
 
 import {
-  jsenvBrowserSystemFileInfo,
-  jsenvToolbarHtmlFileInfo,
-  jsenvToolbarInjectorFileInfo,
-} from "@jsenv/core/src/internal/jsenvInternalFiles.js"
+  BROWSER_RUNTIME_BUILD_URL,
+  EVENT_SOURCE_CLIENT_BUILD_URL,
+  TOOLBAR_INJECTOR_BUILD_URL,
+} from "@jsenv/core/dist/build_manifest.js"
 import { fetchUrl } from "@jsenv/core/src/internal/fetchUrl.js"
 import { getDefaultImportMap } from "@jsenv/core/src/internal/import-resolution/importmap-default.js"
+
 import {
   setJavaScriptSourceMappingUrl,
   sourcemapToBase64Url,
@@ -49,15 +50,22 @@ export const compileHtml = async ({
   sourcemapMethod,
 
   jsenvScriptInjection = true,
+  jsenvEventSourceClientInjection,
   jsenvToolbarInjection,
   onHtmlImportmapInfo,
 }) => {
-  const jsenvBrowserBuildUrlRelativeToProject = urlToRelativeUrl(
-    jsenvBrowserSystemFileInfo.jsenvBuildUrl,
+  const browserRuntimeBuildUrlRelativeToProject = urlToRelativeUrl(
+    BROWSER_RUNTIME_BUILD_URL,
     projectDirectoryUrl,
   )
-  const jsenvToolbarInjectorBuildRelativeUrlForProject = urlToRelativeUrl(
-    jsenvToolbarInjectorFileInfo.jsenvBuildUrl,
+
+  const eventSourceClientBuildRelativeUrlForProject = urlToRelativeUrl(
+    EVENT_SOURCE_CLIENT_BUILD_URL,
+    projectDirectoryUrl,
+  )
+
+  const toolbarInjectorBuildRelativeUrlForProject = urlToRelativeUrl(
+    TOOLBAR_INJECTOR_BUILD_URL,
     projectDirectoryUrl,
   )
 
@@ -70,17 +78,26 @@ export const compileHtml = async ({
 
   manipulateHtmlAst(htmlAst, {
     scriptInjections: [
-      ...(url !== jsenvToolbarHtmlFileInfo.url && jsenvScriptInjection
+      ...(jsenvScriptInjection
+        ? [
+            {
+              src: `/${browserRuntimeBuildUrlRelativeToProject}`,
+            },
+          ]
+        : []),
+      ...(jsenvEventSourceClientInjection
         ? [
             {
-              src: `/${jsenvBrowserBuildUrlRelativeToProject}`,
+              src: `/${eventSourceClientBuildRelativeUrlForProject}`,
             },
           ]
         : []),
-      ...(url !== jsenvToolbarHtmlFileInfo.url && jsenvToolbarInjection
+      ...(jsenvToolbarInjection
         ? [
             {
-              src: `/${jsenvToolbarInjectorBuildRelativeUrlForProject}`,
+              src: `/${toolbarInjectorBuildRelativeUrlForProject}`,
+              defer: "",
+              async: "",
             },
           ]
         : []),

package/src/internal/compiling/startCompileServer.js

@@ -29,12 +29,16 @@ import {
   createCallbackListNotifiedOnce,
 } from "@jsenv/abort"
 
+import {
+  TOOLBAR_INJECTOR_BUILD_URL,
+  EVENT_SOURCE_CLIENT_BUILD_URL,
+  BROWSER_RUNTIME_BUILD_URL,
+} from "@jsenv/core/dist/build_manifest.js"
 import { generateGroupMap } from "@jsenv/core/src/internal/generateGroupMap/generateGroupMap.js"
 import { isBrowserPartOfSupportedRuntimes } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
 import { loadBabelPluginMapFromFile } from "./load_babel_plugin_map_from_file.js"
 import { extractSyntaxBabelPluginMap } from "./babel_plugins.js"
 import {
-  jsenvCompileProxyFileInfo,
   sourcemapMainFileInfo,
   sourcemapMappingFileInfo,
 } from "../jsenvInternalFiles.js"
@@ -104,8 +108,9 @@ export const startCompileServer = async ({
   plugins,
   livereloadSSE = false,
   transformHtmlSourceFiles = true,
-  jsenvToolbarInjection = false,
   jsenvScriptInjection = true,
+  jsenvEventSourceClientInjection = false,
+  jsenvToolbarInjection = false,
   inlineImportMapIntoHTML = true,
 }) => {
   assertArguments({
@@ -294,9 +299,6 @@ export const startCompileServer = async ({
       outDirectoryUrl,
       compileServerMetaFileInfo,
     }),
-    "service: compile proxy": createCompileProxyService({
-      projectDirectoryUrl,
-    }),
     "service:compiled file": createCompiledFileService({
       logger,
 
@@ -312,6 +314,7 @@ export const startCompileServer = async ({
       customCompilers,
       moduleOutFormat,
       importMetaFormat,
+      jsenvEventSourceClientInjection,
       jsenvToolbarInjection,
 
       projectFileRequestedCallback,
@@ -327,8 +330,10 @@ export const startCompileServer = async ({
             createTransformHtmlSourceFileService({
               logger,
               projectDirectoryUrl,
+              projectFileRequestedCallback,
               inlineImportMapIntoHTML,
               jsenvScriptInjection,
+              jsenvEventSourceClientInjection,
               jsenvToolbarInjection,
             }),
         }
@@ -909,15 +914,24 @@ const createSourceFileService = ({
     const relativeUrl = request.pathname.slice(1)
     projectFileRequestedCallback(relativeUrl, request)
 
-    const responsePromise = fetchFileSystem(
-      new URL(request.ressource.slice(1), projectDirectoryUrl),
-      {
-        headers: request.headers,
-        etagEnabled: projectFileCacheStrategy === "etag",
-        mtimeEnabled: projectFileCacheStrategy === "mtime",
-      },
+    const fileUrl = new URL(request.ressource.slice(1), projectDirectoryUrl)
+      .href
+    const fileIsInsideJsenvDistDirectory = urlIsInsideOf(
+      fileUrl,
+      new URL("./dist/", jsenvCoreDirectoryUrl),
     )
 
+    const responsePromise = fetchFileSystem(fileUrl, {
+      headers: request.headers,
+      etagEnabled: projectFileCacheStrategy === "etag",
+      mtimeEnabled: projectFileCacheStrategy === "mtime",
+      ...(fileIsInsideJsenvDistDirectory
+        ? {
+            cacheControl: `private,max-age=${60 * 60 * 24 * 30},immutable`,
+          }
+        : {}),
+    })
+
     return responsePromise
   }
 }
@@ -961,6 +975,12 @@ const createCompileServerMetaFileInfo = ({
     sourcemapMappingFileInfo.url,
     projectDirectoryUrl,
   )
+  // The object below must list everything that can influence how the
+  // compiled files are generated. So that the cahce for those generated files is
+  // not reused when it should not
+  // In some cases the parameters influences only a subset of files and ideally
+  // this parameter should somehow invalidate a subset of the cache
+  // To keep things simple these parameters currently invalidates the whole cache
   const compileServerMeta = {
     jsenvDirectoryRelativeUrl,
     outDirectoryRelativeUrl,
@@ -979,8 +999,15 @@ const createCompileServerMetaFileInfo = ({
     sourcemapMappingFileRelativeUrl,
     errorStackRemapping: true,
 
+    // used to consider the logic generating files may have changed
     jsenvCorePackageVersion,
+
+    // impact only HTML files
     jsenvToolbarInjection,
+    TOOLBAR_INJECTOR_BUILD_URL,
+    EVENT_SOURCE_CLIENT_BUILD_URL,
+    BROWSER_RUNTIME_BUILD_URL,
+
     env,
   }
   return {
@@ -1050,27 +1077,6 @@ const createCompileServerMetaService = ({
   }
 }
 
-const createCompileProxyService = ({ projectDirectoryUrl }) => {
-  const jsenvCompileProxyRelativeUrlForProject = urlToRelativeUrl(
-    jsenvCompileProxyFileInfo.jsenvBuildUrl,
-    projectDirectoryUrl,
-  )
-
-  return (request) => {
-    if (request.ressource === "/.jsenv/jsenv_compile_proxy.js") {
-      const jsenvCompileProxyBuildServerUrl = `${request.origin}/${jsenvCompileProxyRelativeUrlForProject}`
-      return {
-        status: 307,
-        headers: {
-          location: jsenvCompileProxyBuildServerUrl,
-        },
-      }
-    }
-
-    return null
-  }
-}
-
 const readPackage = (packagePath) => {
   const buffer = readFileSync(packagePath)
   const string = String(buffer)