@jsenv/core 27.0.0-alpha.63 → 27.0.0-alpha.66

package/main.js

@@ -24,3 +24,4 @@ export { startBuildServer } from "./src/build/start_build_server.js"
 
 // advanced
 export { execute } from "./src/execute/execute.js"
+export { injectGlobals } from "./src/plugins/inject_globals/jsenv_plugin_inject_globals.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "27.0.0-alpha.63",
+  "version": "27.0.0-alpha.66",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -23,7 +23,10 @@
   "imports": {},
   "exports": {
     ".": {
-      "import": "./main.js"
+      "import": {
+        "development": "./main.js",
+        "default": "./dist/main.js"
+      }
     },
     "./*": "./*"
   },
@@ -34,13 +37,14 @@
     "/main.js"
   ],
   "workspaces": [
-    "./packages/*"
+    "./packages/*",
+    "./packages/create-jsenv/*"
   ],
   "scripts": {
     "eslint": "npx eslint . --ext=.js,.mjs,.cjs,.html",
-    "dev": "node ./scripts/dev/dev.mjs",
-    "build": "node ./scripts/build/build.mjs",
-    "test": "node ./scripts/test/test.mjs",
+    "dev": "node --conditions=development ./scripts/dev/dev.mjs",
+    "build": "node --conditions=development ./scripts/build/build.mjs",
+    "test": "node --conditions=development ./scripts/test/test.mjs",
     "test-packages": "npm run test --workspaces --if-present",
     "start_file_server": "node ./scripts/dev/start_file_server.mjs",
     "workspace-versions": "node ./scripts/publish/workspace_versions.mjs",
@@ -68,12 +72,12 @@
     "@jsenv/filesystem": "3.2.2",
     "@jsenv/importmap": "1.2.0",
     "@jsenv/integrity": "0.0.1",
-    "@jsenv/log": "1.6.1",
-    "@jsenv/logger": "4.0.1",
-    "@jsenv/node-esm-resolution": "0.0.7",
-    "@jsenv/server": "12.6.2",
+    "@jsenv/log": "1.6.2",
+    "@jsenv/logger": "4.1.1",
+    "@jsenv/node-esm-resolution": "0.0.10",
+    "@jsenv/server": "12.6.3",
     "@jsenv/uneval": "1.6.0",
-    "@jsenv/utils": "1.7.7",
+    "@jsenv/utils": "1.8.2",
     "construct-style-sheets-polyfill": "3.1.0",
     "cssnano": "5.1.7",
     "cssnano-preset-default": "5.2.7",
@@ -97,11 +101,11 @@
     "@babel/plugin-syntax-import-assertions": "7.16.7",
     "@jsenv/assert": "2.5.4",
     "@jsenv/eslint-config": "16.0.9",
-    "@jsenv/file-size-impact": "12.1.11",
+    "@jsenv/file-size-impact": "12.1.12",
     "@jsenv/https-local": "1.0.11",
     "@jsenv/importmap-node-module": "5.1.3",
-    "@jsenv/package-workspace": "0.1.2",
-    "@jsenv/performance-impact": "2.2.10",
+    "@jsenv/package-workspace": "0.2.0",
+    "@jsenv/performance-impact": "2.2.11",
     "@jsenv/pwa": "5.0.0",
     "eslint": "8.13.0",
     "eslint-plugin-html": "6.2.0",

package/src/build/build.js

@@ -25,6 +25,8 @@ import {
   setUrlFilename,
   asUrlUntilPathname,
   normalizeUrl,
+  asUrlWithoutSearch,
+  ensurePathnameTrailingSlash,
 } from "@jsenv/utils/urls/url_utils.js"
 import { createVersionGenerator } from "@jsenv/utils/versioning/version_generator.js"
 import { generateSourcemapUrl } from "@jsenv/utils/sourcemap/sourcemap_utils.js"
@@ -34,10 +36,10 @@ import {
 } from "@jsenv/utils/html_ast/html_ast.js"
 import { sortByDependencies } from "@jsenv/utils/graph/sort_by_dependencies.js"
 
+import { createUrlGraph } from "../omega/url_graph.js"
 import { jsenvPluginUrlAnalysis } from "../plugins/url_analysis/jsenv_plugin_url_analysis.js"
 import { jsenvPluginInline } from "../plugins/inline/jsenv_plugin_inline.js"
 import { jsenvPluginAsJsClassic } from "../plugins/transpilation/as_js_classic/jsenv_plugin_as_js_classic.js"
-import { createUrlGraph } from "../omega/url_graph.js"
 import { getCorePlugins } from "../plugins/plugins.js"
 import { createKitchen } from "../omega/kitchen.js"
 import { loadUrlGraph } from "../omega/url_graph/url_graph_load.js"
@@ -86,13 +88,27 @@ export const build = async ({
   rootDirectoryUrl,
   buildDirectoryUrl,
   entryPoints = {},
+  baseUrl = "/",
 
+  // default runtimeCompat corresponds to dynamic import
+  // (meaning we can keep <script type="module">)
+  runtimeCompat = {
+    // android: "8",
+    chrome: "63",
+    edge: "79",
+    firefox: "67",
+    ios: "11.3",
+    opera: "50",
+    safari: "11.3",
+    samsung: "8.2",
+  },
   plugins = [],
   sourcemaps = false,
+  urlAnalysis = {},
   nodeEsmResolution,
   fileSystemMagicResolution,
+  directoryReferenceAllowed,
   injectedGlobals,
-  runtimeCompat,
   transpilation = {},
   bundling = true,
   minification = true,
@@ -112,7 +128,6 @@ export const build = async ({
   buildDirectoryClean = true,
   writeOnFileSystem = true,
   writeGeneratedFiles = false,
-  baseUrl = "/",
   assetManifest = true,
   assetManifestFileRelativeUrl = "asset-manifest.json",
 }) => {
@@ -151,12 +166,16 @@ build "${entryPointKeys[0]}"`)
       logger.info(`
 build ${entryPointKeys.length} entry points`)
     }
+    const useExplicitJsClassicConversion = entryPointKeys.some((key) =>
+      entryPoints[key].includes("?as_js_classic"),
+    )
 
     const rawGraph = createUrlGraph()
     const prebuildTask = createTaskLog("prebuild", {
       disabled: infoLogsAreDisabled,
     })
     let urlCount = 0
+    const prebuildRedirections = new Map()
     const rawGraphKitchen = createKitchen({
       signal,
       logger,
@@ -176,16 +195,37 @@ build ${entryPointKeys.length} entry points`)
             prebuildTask.setRightText(urlCount)
           },
         },
+        {
+          appliesDuring: "build",
+          fetchUrlContent: (urlInfo, context) => {
+            if (context.reference.original) {
+              prebuildRedirections.set(
+                context.reference.original.url,
+                context.reference.url,
+              )
+            }
+          },
+          formatUrl: (reference) => {
+            if (!reference.shouldHandle) {
+              return `ignore:${reference.specifier}`
+            }
+            return null
+          },
+        },
         ...getCorePlugins({
           rootDirectoryUrl,
           urlGraph: rawGraph,
           scenario: "build",
+          runtimeCompat,
 
+          urlAnalysis,
           nodeEsmResolution,
           fileSystemMagicResolution,
+          directoryReferenceAllowed,
           injectedGlobals,
           transpilation: {
             ...transpilation,
+            babelHelpersAsImport: !useExplicitJsClassicConversion,
             jsModuleAsJsClassic: false,
           },
           minification,
@@ -199,6 +239,7 @@ build ${entryPointKeys.length} entry points`)
         operation: buildOperation,
         urlGraph: rawGraph,
         kitchen: rawGraphKitchen,
+        writeGeneratedFiles,
         outDirectoryUrl: new URL(`.jsenv/build/`, rootDirectoryUrl),
         startLoading: (cookEntryFile) => {
           Object.keys(entryPoints).forEach((key) => {
@@ -209,6 +250,7 @@ build ${entryPointKeys.length} entry points`)
             })
             entryUrls.push(entryUrlInfo.url)
             entryUrlInfo.filename = entryPoints[key]
+            // entryUrlInfo.data.entryPointKey = key
           })
         },
       })
@@ -222,8 +264,8 @@ build ${entryPointKeys.length} entry points`)
       buildDirectoryUrl,
     })
     const rawUrls = {}
+    const bundleRedirections = {}
     const buildUrls = {}
-    const rawUrlRedirections = {}
     const bundleUrlInfos = {}
     const bundlers = {}
     rawGraphKitchen.pluginController.plugins.forEach((plugin) => {
@@ -313,7 +355,7 @@ build ${entryPointKeys.length} entry points`)
         })
       }
     })
-    const bundleUrlRedirections = {}
+    const bundleInternalRedirections = {}
     await Object.keys(bundlers).reduce(async (previous, type) => {
       await previous
       const bundler = bundlers[type]
@@ -334,7 +376,7 @@ build ${entryPointKeys.length} entry points`)
             },
             urlInfosToBundle,
             {
-              ...rawGraphKitchen.baseContext,
+              ...rawGraphKitchen.kitchenContext,
               buildDirectoryUrl,
             },
           )
@@ -355,15 +397,20 @@ build ${entryPointKeys.length} entry points`)
           const buildUrl = buildUrlsGenerator.generate(url, {
             urlInfo: bundleUrlInfo,
           })
-          rawUrlRedirections[url] = buildUrl
+          bundleRedirections[url] = buildUrl
           rawUrls[buildUrl] = url
           bundleUrlInfos[buildUrl] = bundleUrlInfo
+          if (buildUrl.includes("?")) {
+            bundleUrlInfos[asUrlWithoutSearch(buildUrl)] = bundleUrlInfo
+          }
           if (bundlerGeneratedUrlInfo.data.bundleRelativeUrl) {
             const urlForBundler = new URL(
               bundlerGeneratedUrlInfo.data.bundleRelativeUrl,
               buildDirectoryUrl,
             ).href
-            bundleUrlRedirections[urlForBundler] = buildUrl
+            if (urlForBundler !== buildUrl) {
+              bundleInternalRedirections[urlForBundler] = buildUrl
+            }
           }
         })
       } catch (e) {
@@ -373,7 +420,11 @@ build ${entryPointKeys.length} entry points`)
       bundleTask.done()
     }, Promise.resolve())
 
-    const buildUrlRedirections = {}
+    const urlAnalysisPlugin = jsenvPluginUrlAnalysis({
+      rootDirectoryUrl,
+      ...urlAnalysis,
+    })
+    const postBuildRedirections = {}
     const finalGraph = createUrlGraph()
     const optimizeUrlContentHooks =
       rawGraphKitchen.pluginController.addHook("optimizeUrlContent")
@@ -387,31 +438,58 @@ build ${entryPointKeys.length} entry points`)
       runtimeCompat,
       writeGeneratedFiles,
       plugins: [
-        jsenvPluginUrlAnalysis(),
-        jsenvPluginAsJsClassic({
-          systemJsInjection: true,
-        }),
-        jsenvPluginInline({
-          fetchInlineUrls: false,
-        }),
+        urlAnalysisPlugin,
+        jsenvPluginAsJsClassic({ systemJsInjection: true }),
+        jsenvPluginInline({ fetchInlineUrls: false }),
         {
           name: "jsenv:postbuild",
-          appliesDuring: { build: true },
+          appliesDuring: "build",
           resolveUrl: (reference) => {
-            if (reference.specifier[0] === "#") {
-              reference.external = true
+            const performInternalRedirections = (url) => {
+              const prebuildRedirection = prebuildRedirections.get(url)
+              if (prebuildRedirection) {
+                logger.debug(
+                  `\nprebuild redirection\n${url} ->\n${prebuildRedirection}\n`,
+                )
+                url = prebuildRedirection
+              }
+              const bundleRedirection = bundleRedirections[url]
+              if (bundleRedirection) {
+                logger.debug(
+                  `\nbundler redirection\n${url} ->\n${bundleRedirection}\n`,
+                )
+                url = bundleRedirection
+              }
+              const bundleInternalRedirection = bundleInternalRedirections[url]
+              if (bundleInternalRedirection) {
+                logger.debug(
+                  `\nbundler internal redirection\n${url} ->\n${bundleInternalRedirection}\n`,
+                )
+                url = bundleInternalRedirection
+              }
+              return url
             }
-            let url =
-              reference.specifier[0] === "/"
-                ? new URL(reference.specifier.slice(1), buildDirectoryUrl).href
-                : new URL(reference.specifier, reference.parentUrl).href
-            const urlRedirectedByBundle = bundleUrlRedirections[url]
-            if (urlRedirectedByBundle) {
-              return urlRedirectedByBundle
+
+            if (reference.type === "filesystem") {
+              const parentRawUrl = rawUrls[reference.parentUrl]
+              const baseUrl = ensurePathnameTrailingSlash(parentRawUrl)
+              return performInternalRedirections(
+                new URL(reference.specifier, baseUrl).href,
+              )
+            }
+            if (reference.specifier[0] === "/") {
+              return performInternalRedirections(
+                new URL(reference.specifier.slice(1), buildDirectoryUrl).href,
+              )
             }
-            const urlRedirected = rawUrlRedirections[url]
-            return urlRedirected || url
+            return performInternalRedirections(
+              new URL(
+                reference.specifier,
+                reference.baseUrl || reference.parentUrl,
+              ).href,
+            )
           },
+          // redirecting urls into the build directory
           redirectUrl: (reference) => {
             if (!reference.url.startsWith("file:")) {
               return null
@@ -421,11 +499,6 @@ build ${entryPointKeys.length} entry points`)
             if (rawUrl) {
               return reference.url
             }
-            // from rollup or postcss
-            const bundleUrlInfo = bundleUrlInfos[reference.url]
-            if (bundleUrlInfo) {
-              return reference.url
-            }
             // from "js_module_as_js_classic":
             //   - injecting "?as_js_classic" for the first time
             //   - injecting "?as_js_classic" because the parentUrl has it
@@ -441,9 +514,8 @@ build ${entryPointKeys.length} entry points`)
               }
               let rawUrl
               if (urlIsInsideOf(reference.url, buildDirectoryUrl)) {
-                // rawUrl = rawUrls[reference.url] || reference.url
                 const originalBuildUrl =
-                  buildUrlRedirections[referenceOriginalUrl]
+                  postBuildRedirections[referenceOriginalUrl]
                 rawUrl = originalBuildUrl
                   ? rawUrls[originalBuildUrl]
                   : reference.url
@@ -465,7 +537,7 @@ build ${entryPointKeys.length} entry points`)
                   filename: reference.filename,
                 },
               })
-              buildUrlRedirections[originalBuildUrl] = buildUrl
+              postBuildRedirections[originalBuildUrl] = buildUrl
               rawUrls[buildUrl] = rawUrl
               return buildUrl
             }
@@ -509,11 +581,16 @@ build ${entryPointKeys.length} entry points`)
               return buildUrl
             }
             const rawUrlInfo = rawGraph.getUrlInfo(reference.url)
+            const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl)
             // files from root directory but not given to rollup nor postcss
             if (rawUrlInfo) {
               const buildUrl = buildUrlsGenerator.generate(reference.url, {
                 urlInfo: rawUrlInfo,
+                parentUrlInfo,
               })
+              if (buildUrl.includes("?")) {
+                rawUrls[asUrlWithoutSearch(buildUrl)] = rawUrlInfo.url
+              }
               rawUrls[buildUrl] = rawUrlInfo.url
               return buildUrl
             }
@@ -534,6 +611,9 @@ build ${entryPointKeys.length} entry points`)
           },
           formatUrl: (reference) => {
             if (!reference.generatedUrl.startsWith("file:")) {
+              if (!versioning && reference.generatedUrl.startsWith("ignore:")) {
+                return reference.generatedUrl.slice("ignore:".length)
+              }
               return null
             }
             if (!urlIsInsideOf(reference.generatedUrl, buildDirectoryUrl)) {
@@ -541,6 +621,10 @@ build ${entryPointKeys.length} entry points`)
                 `urls should be inside build directory at this stage, found "${reference.url}"`,
               )
             }
+            if (reference.isRessourceHint) {
+              // return the raw url, we will resync at the end
+              return rawUrls[reference.url]
+            }
             // remove eventual search params and hash
             const urlUntilPathname = asUrlUntilPathname(reference.generatedUrl)
             let specifier
@@ -566,23 +650,18 @@ build ${entryPointKeys.length} entry points`)
             return specifier
           },
           fetchUrlContent: async (finalUrlInfo, context) => {
-            if (!finalUrlInfo.url.startsWith("file:")) {
-              return { external: true }
-            }
             const fromBundleOrRawGraph = (url) => {
               const bundleUrlInfo = bundleUrlInfos[url]
               if (bundleUrlInfo) {
+                logger.debug(`fetching from bundle ${url}`)
                 return bundleUrlInfo
               }
               const rawUrl = rawUrls[url] || url
               const rawUrlInfo = rawGraph.getUrlInfo(rawUrl)
               if (!rawUrlInfo) {
-                const originalBuildUrl = buildUrlRedirections[url]
-                if (originalBuildUrl) {
-                  return fromBundleOrRawGraph(originalBuildUrl)
-                }
                 throw new Error(`Cannot find url`)
               }
+              logger.debug(`fetching from raw graph ${url}`)
               if (rawUrlInfo.isInline) {
                 // Inline content, such as <script> inside html, is transformed during the previous phase.
                 // If we read the inline content it would be considered as the original content.
@@ -609,10 +688,7 @@ build ${entryPointKeys.length} entry points`)
                 specifier: context.reference.specifier,
                 injected: true,
               })
-              await rawGraphKitchen.cook({
-                reference: ref,
-                urlInfo: rawUrlInfo,
-              })
+              await rawGraphKitchen.cook(rawUrlInfo, { reference: ref })
               return rawUrlInfo
             }
             // reference updated during "postbuild":
@@ -625,7 +701,7 @@ build ${entryPointKeys.length} entry points`)
         },
         {
           name: "jsenv:optimize",
-          appliesDuring: { build: true },
+          appliesDuring: "build",
           finalizeUrlContent: async (urlInfo, context) => {
             if (optimizeUrlContentHooks.length) {
               await rawGraphKitchen.pluginController.callAsyncHooks(
@@ -652,6 +728,7 @@ build ${entryPointKeys.length} entry points`)
         urlGraph: finalGraph,
         kitchen: finalGraphKitchen,
         outDirectoryUrl: new URL(".jsenv/postbuild/", rootDirectoryUrl),
+        writeGeneratedFiles,
         skipRessourceHint: true,
         startLoading: (cookEntryFile) => {
           entryUrls.forEach((entryUrl) => {
@@ -688,6 +765,7 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
         runtimeCompat,
         writeGeneratedFiles,
         rawGraph,
+        urlAnalysisPlugin,
         finalGraph,
         finalGraphKitchen,
         lineBreakNormalization,
@@ -695,10 +773,10 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
       })
     }
     GRAPH.forEach(finalGraph, (urlInfo) => {
-      if (!urlInfo.url.startsWith("file:")) {
+      if (!urlInfo.shouldHandle) {
         return
       }
-      if (urlInfo.external) {
+      if (!urlInfo.url.startsWith("file:")) {
         return
       }
       if (urlInfo.type === "html") {
@@ -720,10 +798,11 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
       urlInfo.data.buildUrlSpecifier = buildUrlSpecifier
     })
     await resyncRessourceHints({
+      logger,
       finalGraphKitchen,
       finalGraph,
       rawUrls,
-      buildUrls,
+      postBuildRedirections,
     })
     buildOperation.throwIfAborted()
     const cleanupActions = []
@@ -753,10 +832,13 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
     const buildFileContents = {}
     const buildInlineContents = {}
     GRAPH.forEach(finalGraph, (urlInfo) => {
-      if (urlInfo.external) {
+      if (!urlInfo.shouldHandle) {
         return
       }
-      if (urlInfo.url.startsWith("data:")) {
+      if (!urlInfo.url.startsWith("file:")) {
+        return
+      }
+      if (urlInfo.type === "directory") {
         return
       }
       const buildRelativeUrl = urlToRelativeUrl(
@@ -890,6 +972,7 @@ const applyUrlVersioning = async ({
   runtimeCompat,
   writeGeneratedFiles,
   rawGraph,
+  urlAnalysisPlugin,
   finalGraph,
   finalGraphKitchen,
   lineBreakNormalization,
@@ -911,7 +994,7 @@ const applyUrlVersioning = async ({
       // ignore:
       // - inline files:
       //   they are already taken into account in the file where they appear
-      // - external files
+      // - ignored files:
       //   we don't know their content
       // - unused files without reference
       //   File updated such as style.css -> style.css.js or file.js->file.es5.js
@@ -921,7 +1004,7 @@ const applyUrlVersioning = async ({
       if (urlInfo.isInline) {
         return
       }
-      if (urlInfo.external) {
+      if (!urlInfo.shouldHandle) {
         return
       }
       if (!urlInfo.data.isEntryPoint && urlInfo.dependents.size === 0) {
@@ -944,8 +1027,8 @@ const applyUrlVersioning = async ({
         lineBreakNormalization,
       })
       urlInfo.dependencies.forEach((dependencyUrl) => {
-        // this dependency is inline (data:) or remote (http://, https://)
-        if (!dependencyUrl.startsWith("file:")) {
+        // this dependency is inline
+        if (dependencyUrl.startsWith("data:")) {
           return
         }
         const dependencyUrlInfo = finalGraph.getUrlInfo(dependencyUrl)
@@ -953,7 +1036,7 @@ const applyUrlVersioning = async ({
           // this content is part of the file, no need to take into account twice
           dependencyUrlInfo.isInline ||
           // this dependency content is not known
-          dependencyUrlInfo.external
+          !dependencyUrlInfo.shouldHandle
         ) {
           return
         }
@@ -995,7 +1078,7 @@ const applyUrlVersioning = async ({
       runtimeCompat,
       writeGeneratedFiles,
       plugins: [
-        jsenvPluginUrlAnalysis(),
+        urlAnalysisPlugin,
         jsenvPluginInline({
           fetchInlineUrls: false,
           analyzeConvertedScripts: true, // to be able to version their urls
@@ -1005,18 +1088,44 @@ const applyUrlVersioning = async ({
           name: "jsenv:versioning",
           appliesDuring: { build: true },
           resolveUrl: (reference) => {
-            if (reference.specifier[0] === "#") {
-              reference.external = true
-            }
             const buildUrl = buildUrls[reference.specifier]
             if (buildUrl) {
               return buildUrl
             }
-            const url = new URL(reference.specifier, reference.parentUrl).href
+            const urlObject = new URL(
+              reference.specifier,
+              reference.baseUrl || reference.parentUrl,
+            )
+            const url = urlObject.href
+            // during versioning we revisit the deps
+            // but the code used to enforce trailing slash on directories
+            // is not applied because "jsenv:file_url_resolution" is not used
+            // so here we search if the url with a trailing slash exists
+            if (
+              reference.type === "filesystem" &&
+              !urlObject.pathname.endsWith("/")
+            ) {
+              const urlWithTrailingSlash = `${url}/`
+              const specifier = Object.keys(buildUrls).find(
+                (key) => buildUrls[key] === urlWithTrailingSlash,
+              )
+              if (specifier) {
+                return urlWithTrailingSlash
+              }
+            }
             return url
           },
           formatUrl: (reference) => {
-            if (reference.isInline) {
+            if (!reference.shouldHandle) {
+              if (reference.generatedUrl.startsWith("ignore:")) {
+                return reference.generatedUrl.slice("ignore:".length)
+              }
+              return null
+            }
+            if (reference.isInline || reference.url.startsWith("data:")) {
+              return null
+            }
+            if (reference.isRessourceHint) {
               return null
             }
             // specifier comes from "normalize" hook done a bit earlier in this file
@@ -1025,8 +1134,7 @@ const applyUrlVersioning = async ({
             if (!canUseVersionedUrl(referencedUrlInfo)) {
               return reference.specifier
             }
-            // data:* urls and so on
-            if (!referencedUrlInfo.url.startsWith("file:")) {
+            if (!referencedUrlInfo.shouldHandle) {
               return null
             }
             const versionedUrl = referencedUrlInfo.data.versionedUrl
@@ -1063,9 +1171,6 @@ const applyUrlVersioning = async ({
             return versionedSpecifier
           },
           fetchUrlContent: (versionedUrlInfo) => {
-            if (!versionedUrlInfo.url.startsWith("file:")) {
-              return { external: true }
-            }
             if (versionedUrlInfo.isInline) {
               const rawUrlInfo = rawGraph.getUrlInfo(
                 rawUrls[versionedUrlInfo.url],
@@ -1090,6 +1195,7 @@ const applyUrlVersioning = async ({
       urlGraph: finalGraph,
       kitchen: versioningKitchen,
       skipRessourceHint: true,
+      writeGeneratedFiles,
       startLoading: (cookEntryFile) => {
         postBuildEntryUrls.forEach((postBuildEntryUrl) => {
           cookEntryFile({

package/src/build/build_urls_generator.js

@@ -1,4 +1,4 @@
-import { urlToFilename } from "@jsenv/filesystem"
+import { urlToFilename, urlToRelativeUrl } from "@jsenv/filesystem"
 
 import { memoizeByFirstArgument } from "@jsenv/utils/memoize/memoize_by_first_argument.js"
 
@@ -17,6 +17,7 @@ export const createBuilUrlsGenerator = ({ buildDirectoryUrl }) => {
 
   const generate = memoizeByFirstArgument((url, { urlInfo, parentUrlInfo }) => {
     const directoryPath = determineDirectoryPath({
+      buildDirectoryUrl,
       urlInfo,
       parentUrlInfo,
     })
@@ -69,9 +70,24 @@ const splitFileExtension = (filename) => {
   return [filename.slice(0, dotLastIndex), filename.slice(dotLastIndex)]
 }
 
-const determineDirectoryPath = ({ urlInfo, parentUrlInfo }) => {
+const determineDirectoryPath = ({
+  buildDirectoryUrl,
+  urlInfo,
+  parentUrlInfo,
+}) => {
+  if (urlInfo.type === "directory") {
+    return ""
+  }
+  if (parentUrlInfo && parentUrlInfo.type === "directory") {
+    const parentDirectoryPath = urlToRelativeUrl(
+      parentUrlInfo.url,
+      buildDirectoryUrl,
+    )
+    return parentDirectoryPath
+  }
   if (urlInfo.isInline) {
     const parentDirectoryPath = determineDirectoryPath({
+      buildDirectoryUrl,
       urlInfo: parentUrlInfo,
     })
     return parentDirectoryPath