@jsenv/core 27.0.0-alpha.51 → 27.0.0-alpha.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "27.0.0-alpha.51",
+  "version": "27.0.0-alpha.54",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {
@@ -68,7 +68,7 @@
     "@jsenv/node-esm-resolution": "0.0.6",
     "@jsenv/server": "12.6.2",
     "@jsenv/uneval": "1.6.0",
-    "@jsenv/utils": "1.7.1",
+    "@jsenv/utils": "1.7.3",
     "construct-style-sheets-polyfill": "3.1.0",
     "cssnano": "5.1.7",
     "cssnano-preset-default": "5.2.7",

package/src/build/build.js

@@ -22,6 +22,7 @@ import {
   injectQueryParams,
   setUrlFilename,
   asUrlUntilPathname,
+  normalizeUrl,
 } 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"
@@ -29,6 +30,7 @@ import {
   parseHtmlString,
   stringifyHtmlAst,
 } from "@jsenv/utils/html_ast/html_ast.js"
+import { sortByDependencies } from "@jsenv/utils/graph/sort_by_dependencies.js"
 
 import { jsenvPluginUrlAnalysis } from "../plugins/url_analysis/jsenv_plugin_url_analysis.js"
 import { jsenvPluginInline } from "../plugins/inline/jsenv_plugin_inline.js"
@@ -38,7 +40,6 @@ import { getCorePlugins } from "../plugins/plugins.js"
 import { createKitchen } from "../omega/kitchen.js"
 import { loadUrlGraph } from "../omega/url_graph/url_graph_load.js"
 import { createUrlGraphSummary } from "../omega/url_graph/url_graph_report.js"
-import { sortUrlGraphByDependencies } from "../omega/url_graph/url_graph_sort.js"
 import { isWebWorkerEntryPointReference } from "../omega/web_workers.js"
 
 import { GRAPH } from "./graph_utils.js"
@@ -223,9 +224,16 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
     })
   })
   const addToBundlerIfAny = (rawUrlInfo) => {
-    // if (rawUrlInfo.dependencies.size === 0) {
-    //   return
-    // }
+    if (
+      // entry point must be given to the bundler (rollup)
+      // so that the bundler know it's an entry point, even if it has no dependency
+      // this way the bundler can share code properly and avoid inlining an entry point
+      // if it's used by an other entry point
+      !rawUrlInfo.data.isEntryPoint &&
+      rawUrlInfo.dependencies.size === 0
+    ) {
+      return
+    }
     const bundler = bundlers[rawUrlInfo.type]
     if (bundler) {
       bundler.urlInfos.push(rawUrlInfo)
@@ -253,6 +261,21 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
           }
           addToBundlerIfAny(dependencyUrlInfo)
         })
+        rawUrlInfo.references.forEach((reference) => {
+          if (
+            reference.isRessourceHint &&
+            reference.expectedType === "js_module"
+          ) {
+            const referencedUrlInfo = rawGraph.getUrlInfo(reference.url)
+            if (
+              referencedUrlInfo &&
+              // something else than the ressource hint is using this url
+              referencedUrlInfo.dependents.size > 0
+            ) {
+              addToBundlerIfAny(referencedUrlInfo)
+            }
+          }
+        })
         return
       }
     }
@@ -361,25 +384,10 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
           if (urlRedirectedByBundle) {
             return urlRedirectedByBundle
           }
-          const parentIsFromBundle = Boolean(
-            bundleUrlInfos[reference.parentUrl],
-          )
-          // urls inside css bundled by parcel
-          // contains url relative to the bundle file (which is considered inside build directory)
-          // if the file is not itself a bundle file it must be resolved against
-          // the original css url
-          if (
-            parentIsFromBundle &&
-            !bundleUrlInfos[url] &&
-            urlIsInsideOf(url, buildDirectoryUrl)
-          ) {
-            const parentRawUrl = rawUrls[reference.parentUrl]
-            url = new URL(reference.specifier, parentRawUrl).href
-          }
           const urlRedirected = rawUrlRedirections[url]
           return urlRedirected || url
         },
-        normalizeUrl: (reference) => {
+        redirectUrl: (reference) => {
           if (!reference.url.startsWith("file:")) {
             return null
           }
@@ -618,6 +626,7 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
       urlGraph: finalGraph,
       kitchen: finalGraphKitchen,
       outDirectoryUrl: new URL(".jsenv/postbuild/", rootDirectoryUrl),
+      skipRessourceHint: true,
       startLoading: (cookEntryFile) => {
         entryUrls.forEach((entryUrl) => {
           const [, postBuildEntryUrlInfo] = cookEntryFile({
@@ -698,7 +707,7 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
       urlInfo.dependents.size === 0
     ) {
       cleanupActions.push(() => {
-        delete finalGraph.urlInfos[urlInfo.url]
+        finalGraph.deleteUrlInfo(urlInfo.url)
       })
     }
   })
@@ -783,7 +792,7 @@ const applyUrlVersioning = async ({
 }) => {
   const versioningTask = createTaskLog(logger, "inject version in urls")
   try {
-    const urlsSorted = sortUrlGraphByDependencies(finalGraph)
+    const urlsSorted = sortByDependencies(finalGraph.urlInfos)
     urlsSorted.forEach((url) => {
       if (url.startsWith("data:")) {
         return
@@ -859,11 +868,13 @@ const applyUrlVersioning = async ({
       })
       urlInfo.data.version = versionGenerator.generate()
 
-      urlInfo.data.versionedUrl = injectVersionIntoBuildUrl({
-        buildUrl: urlInfo.url,
-        version: urlInfo.data.version,
-        versioningMethod,
-      })
+      urlInfo.data.versionedUrl = normalizeUrl(
+        injectVersionIntoBuildUrl({
+          buildUrl: urlInfo.url,
+          version: urlInfo.data.version,
+          versioningMethod,
+        }),
+      )
     })
     const versionMappings = {}
     const usedVersionMappings = []
@@ -969,6 +980,7 @@ const applyUrlVersioning = async ({
     await loadUrlGraph({
       urlGraph: finalGraph,
       kitchen: versioningKitchen,
+      skipRessourceHint: true,
       startLoading: (cookEntryFile) => {
         postBuildEntryUrls.forEach((postBuildEntryUrl) => {
           cookEntryFile({

package/src/build/build_urls_generator.js

@@ -56,8 +56,8 @@ export const createBuilUrlsGenerator = ({ buildDirectoryUrl }) => {
 // To keep in mind: if you have "user.jsx" and "user.js" AND both file are not bundled
 // you end up with "dist/js/user.js" and "dist/js/user2.js"
 const extensionMappings = {
-  ".ts": ".js",
   ".jsx": ".js",
+  ".ts": ".js",
   ".tsx": ".js",
 }
 

package/src/execute/runtimes/browsers/from_playwright.js

@@ -280,6 +280,9 @@ export const createRuntimeFromPlaywright = ({
                 /* eslint-disable no-undef */
                 /* istanbul ignore next */
                 () => {
+                  if (!window.__html_supervisor__) {
+                    throw new Error(`window.__html_supervisor__ not found`)
+                  }
                   return window.__html_supervisor__.getScriptExecutionResults()
                 },
                 /* eslint-enable no-undef */

package/src/omega/kitchen.js

@@ -10,7 +10,7 @@ import { createDetailedMessage } from "@jsenv/logger"
 
 import { stringifyUrlSite } from "@jsenv/utils/urls/url_trace.js"
 import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
-import { setUrlFilename } from "@jsenv/utils/urls/url_utils.js"
+import { normalizeUrl, setUrlFilename } from "@jsenv/utils/urls/url_utils.js"
 
 import { createPluginController } from "../plugins/plugin_controller.js"
 import { createUrlInfoTransformer } from "./url_graph/url_info_transformations.js"
@@ -142,7 +142,7 @@ export const createKitchen = ({
   }
   const resolveReference = (reference) => {
     try {
-      const resolvedUrl = pluginController.callHooksUntil(
+      let resolvedUrl = pluginController.callHooksUntil(
         "resolveUrl",
         reference,
         baseContext,
@@ -150,6 +150,7 @@ export const createKitchen = ({
       if (!resolvedUrl) {
         throw new Error(`NO_RESOLVE`)
       }
+      resolvedUrl = normalizeUrl(resolvedUrl)
       reference.url = resolvedUrl
       if (reference.external) {
         reference.generatedUrl = resolvedUrl
@@ -157,29 +158,20 @@ export const createKitchen = ({
         return urlGraph.reuseOrCreateUrlInfo(reference.url)
       }
       pluginController.callHooks(
-        "normalizeUrl",
+        "redirectUrl",
         reference,
         baseContext,
         (returnValue) => {
-          if (returnValue === reference.url) {
+          const normalizedReturnValue = normalizeUrl(returnValue)
+          if (normalizedReturnValue === reference.url) {
             return
           }
           const previousReference = { ...reference }
-          reference.url = returnValue
+          reference.url = normalizedReturnValue
           mutateReference(previousReference, reference)
         },
       )
-      // force a last normalization on url search params
-      // some plugin use URLSearchParams to alter the url search params
-      // which can result into "file:///file.css?css_module"
-      // becoming "file:///file.css?css_module="
-      // we want to get rid of the "=" and consider it's the same url
-      if (
-        // disable on data urls (would mess up base64 encoding)
-        !reference.url.startsWith("data:")
-      ) {
-        reference.url = reference.url.replace(/[=](?=&|$)/g, "")
-      }
+
       const urlInfo = urlGraph.reuseOrCreateUrlInfo(reference.url)
       applyReferenceEffectsOnUrlInfo(reference, urlInfo, baseContext)
 
@@ -275,12 +267,13 @@ export const createKitchen = ({
       return
     }
     try {
-      const returnValue = await pluginController.callAsyncHooksUntil(
-        "fetchUrlContent",
-        urlInfo,
-        context,
-      )
-      if (!returnValue) {
+      const fetchUrlContentReturnValue =
+        await pluginController.callAsyncHooksUntil(
+          "fetchUrlContent",
+          urlInfo,
+          context,
+        )
+      if (!fetchUrlContentReturnValue) {
         logger.warn(
           createDetailedMessage(
             `no plugin has handled the url during "fetchUrlContent" hook -> consider url as external (ignore it)`,
@@ -293,7 +286,7 @@ export const createKitchen = ({
         urlInfo.external = true
         return
       }
-      if (returnValue.external) {
+      if (fetchUrlContentReturnValue.external) {
         urlInfo.external = true
         return
       }
@@ -306,7 +299,7 @@ export const createKitchen = ({
         content,
         sourcemap,
         filename,
-      } = returnValue
+      } = fetchUrlContentReturnValue
       urlInfo.type =
         type ||
         reference.expectedType ||

package/src/omega/url_graph/url_graph_load.js

@@ -33,6 +33,13 @@ export const loadUrlGraph = async ({
     })
     const { references } = urlInfo
     references.forEach((reference) => {
+      // we don't cook ressource hints
+      // because they might refer to ressource that will be modified during build
+      // It also means something else have to reference that url in order to cook it
+      // so that the preload is deleted by "resync_ressource_hints.js" otherwise
+      if (reference.isRessourceHint) {
+        return
+      }
       // we use reference.generatedUrl to mimic what a browser would do:
       // do a fetch to the specifier as found in the file
       const referencedUrlInfo = urlGraph.reuseOrCreateUrlInfo(

package/src/plugins/autoreload/jsenv_plugin_hmr.js

@@ -2,7 +2,7 @@ export const jsenvPluginHmr = () => {
   return {
     name: "jsenv:hmr",
     appliesDuring: { dev: true },
-    normalizeUrl: (reference) => {
+    redirectUrl: (reference) => {
       const urlObject = new URL(reference.url)
       if (!urlObject.searchParams.has("hmr")) {
         reference.data.hmr = false

package/src/plugins/bundling/css/bundle_css.js

@@ -1,21 +1,140 @@
-import { bundleWithParcel } from "@jsenv/utils/css_ast/parcel_css.js"
+/*
+ * Each @import found in css is replaced by the file content
+ * - There is no need to worry about urls (such as background-image: url())
+ *   because they are absolute (file://*) and will be made relative again by jsenv build
+ * - The sourcemap are not generated but ideally they should be
+ *   It can be quite challenging, see "bundle_sourcemap.js"
+ */
 
+import { applyPostCss } from "@jsenv/utils/css_ast/apply_post_css.js"
+import { postCssPluginUrlVisitor } from "@jsenv/utils/css_ast/postcss_plugin_url_visitor.js"
+import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
+import { sortByDependencies } from "@jsenv/utils/graph/sort_by_dependencies.js"
+
+// Do not use until https://github.com/parcel-bundler/parcel-css/issues/181
 export const bundleCss = async ({ cssUrlInfos, context }) => {
   const bundledCssUrlInfos = {}
+  const cssBundleInfos = await performCssBundling({
+    cssEntryUrlInfos: cssUrlInfos,
+    context,
+  })
   cssUrlInfos.forEach((cssUrlInfo) => {
-    const { code, map } = bundleWithParcel(cssUrlInfo, context)
-    const content = String(code)
-    const sourcemap = map
-    // here we need to replace css urls to ensure
-    // all urls targets the correct stuff
     bundledCssUrlInfos[cssUrlInfo.url] = {
       data: {
         generatedBy: "parcel",
       },
       contentType: "text/css",
-      content,
-      sourcemap,
+      content: cssBundleInfos[cssUrlInfo.url].bundleContent,
     }
   })
   return bundledCssUrlInfos
 }
+
+const performCssBundling = async ({ cssEntryUrlInfos, context }) => {
+  const cssBundleInfos = await loadCssUrls({
+    cssEntryUrlInfos,
+    context,
+  })
+  const cssUrlsSorted = sortByDependencies(cssBundleInfos)
+  cssUrlsSorted.forEach((cssUrl) => {
+    const cssBundleInfo = cssBundleInfos[cssUrl]
+    const magicSource = createMagicSource(cssBundleInfo.content)
+    cssBundleInfo.cssUrls.forEach((cssUrl) => {
+      if (cssUrl.type === "@import") {
+        magicSource.replace({
+          start: cssUrl.atRuleStart,
+          end: cssUrl.atRuleEnd,
+          replacement: cssBundleInfos[cssUrl.url].bundleContent,
+        })
+      }
+    })
+    const { content } = magicSource.toContentAndSourcemap()
+    cssBundleInfo.bundleContent = content.trim()
+  })
+  return cssBundleInfos
+}
+
+const parseCssUrls = async ({ css, url }) => {
+  const cssUrls = []
+  await applyPostCss({
+    sourcemaps: false,
+    plugins: [
+      postCssPluginUrlVisitor({
+        urlVisitor: ({
+          type,
+          specifier,
+          specifierStart,
+          specifierEnd,
+          atRuleStart,
+          atRuleEnd,
+        }) => {
+          cssUrls.push({
+            type,
+            url: new URL(specifier, url).href,
+            specifierStart,
+            specifierEnd,
+            atRuleStart,
+            atRuleEnd,
+          })
+        },
+      }),
+    ],
+    url,
+    content: css,
+  })
+
+  return cssUrls
+}
+
+const loadCssUrls = async ({ cssEntryUrlInfos, context }) => {
+  const cssBundleInfos = {}
+  const promises = []
+  const promiseMap = new Map()
+
+  const load = (cssUrlInfo) => {
+    const promiseFromData = promiseMap.get(cssUrlInfo.url)
+    if (promiseFromData) return promiseFromData
+    const promise = _load(cssUrlInfo)
+    promises.push(promise)
+    promiseMap.set(cssUrlInfo.url, promise)
+    return promise
+  }
+
+  const _load = async (cssUrlInfo) => {
+    const cssUrls = await parseCssUrls({
+      css: cssUrlInfo.content,
+      url: cssUrlInfo.url,
+    })
+    const cssBundleInfo = {
+      content: cssUrlInfo.content,
+      cssUrls,
+      dependencies: [],
+    }
+    cssBundleInfos[cssUrlInfo.url] = cssBundleInfo
+    cssUrls.forEach((cssUrl) => {
+      if (cssUrl.type === "@import") {
+        cssBundleInfo.dependencies.push(cssUrl.url)
+        const importedCssUrlInfo = context.urlGraph.getUrlInfo(cssUrl.url)
+        load(importedCssUrlInfo)
+      }
+    })
+  }
+
+  cssEntryUrlInfos.forEach((cssEntryUrlInfo) => {
+    load(cssEntryUrlInfo)
+  })
+
+  const waitAll = async () => {
+    if (promises.length === 0) {
+      return
+    }
+    const promisesToWait = promises.slice()
+    promises.length = 0
+    await Promise.all(promisesToWait)
+    await waitAll()
+  }
+  await waitAll()
+  promiseMap.clear()
+
+  return cssBundleInfos
+}

package/src/plugins/bundling/js_module/bundle_js_module.js

@@ -247,20 +247,9 @@ const rollupPluginJsenv = ({
         code: urlInfo.content,
         map: urlInfo.sourcemap
           ? sourcemapConverter.toFilePaths(urlInfo.sourcemap)
-          : urlInfo.sourcemap,
+          : null,
       }
     },
-    // resolveFileUrl: ({ moduleId }) => {
-    //   return `${fileUrlConverter.asFileUrl(moduleId)}`
-    // },
-    renderChunk: (code, chunkInfo) => {
-      const { facadeModuleId } = chunkInfo
-      if (!facadeModuleId) {
-        // happens for inline module scripts for instance
-        return null
-      }
-      return null
-    },
   }
 }
 

package/src/plugins/filesystem_magic/jsenv_plugin_filesystem_magic.js

@@ -13,7 +13,7 @@ export const jsenvPluginFileSystemMagic = ({
   return {
     name: "jsenv:filesystem_magic",
     appliesDuring: "*",
-    normalizeUrl: (reference) => {
+    redirectUrl: (reference) => {
       // http, https, data, about, etc
       if (!reference.url.startsWith("file:")) {
         return null

package/src/plugins/inline/jsenv_plugin_js_inline_content.js

@@ -274,8 +274,9 @@ const getOriginalName = (path, name) => {
     return getOriginalName(path, importedName)
   }
   if (binding.path.type === "VariableDeclarator") {
-    if (binding.path.node.init.type === "Identifier") {
-      const previousName = binding.path.node.init.name
+    const { init } = binding.path.node
+    if (init && init.type === "Identifier") {
+      const previousName = init.name
       return getOriginalName(path, previousName)
     }
   }

package/src/plugins/plugin_controller.js

@@ -5,7 +5,7 @@ export const createPluginController = ({
   scenario,
   hooks = [
     "resolveUrl",
-    "normalizeUrl",
+    "redirectUrl",
     "fetchUrlContent",
     "transformUrlContent",
     "transformUrlSearchParams",
@@ -226,7 +226,7 @@ const assertAndNormalizeReturnValue = (hookName, returnValue) => {
 const returnValueAssertions = [
   {
     name: "url_assertion",
-    appliesTo: ["resolveUrl", "normalizeUrl"],
+    appliesTo: ["resolveUrl", "redirectUrl"],
     assertion: (valueReturned) => {
       if (valueReturned instanceof URL) {
         return valueReturned.href

package/src/plugins/transpilation/as_js_classic/jsenv_plugin_as_js_classic.js

@@ -44,34 +44,42 @@ export const jsenvPluginAsJsClassic = ({ systemJsInjection }) => {
 }
 
 const asJsClassic = ({ systemJsInjection, systemJsClientFileUrl }) => {
+  const propagateJsClassicSearchParam = (reference, context) => {
+    const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl)
+    if (
+      !parentUrlInfo ||
+      !new URL(parentUrlInfo.url).searchParams.has("as_js_classic")
+    ) {
+      return null
+    }
+    const urlTransformed = injectQueryParams(reference.url, {
+      as_js_classic: "",
+    })
+    reference.filename = generateJsClassicFilename(reference.url)
+    return urlTransformed
+  }
+
   return {
     name: "jsenv:as_js_classic",
     appliesDuring: "*",
     // forward ?as_js_classic to referenced urls
-    normalizeUrl: (reference, context) => {
-      // We want to propagate transformation of js module to js classic
-      // but only for import specifier (static/dynamic import + re-export)
-      // All other references won't get the ?as_js_classic
-      // otherwise we could try to transform inline ressources, specifiers inside new URL(). ...
-      if (
-        reference.type !== "js_import_export" &&
-        reference.subtype !== "system_register_arg" &&
-        reference.subtype !== "system_import_arg"
-      ) {
-        return null
-      }
-      const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl)
-      if (
-        !parentUrlInfo ||
-        !new URL(parentUrlInfo.url).searchParams.has("as_js_classic")
-      ) {
+    redirectUrl: {
+      // We want to propagate transformation of js module to js classic to:
+      // - import specifier (static/dynamic import + re-export)
+      // - url specifier when inside System.register/_context.import()
+      //   (because it's the transpiled equivalent of static and dynamic imports)
+      // And not other references otherwise we could try to transform inline ressources
+      // or specifiers inside new URL()...
+      js_import_export: propagateJsClassicSearchParam,
+      js_url_specifier: (reference, context) => {
+        if (
+          reference.subtype === "system_register_arg" ||
+          reference.subtype === "system_import_arg"
+        ) {
+          return propagateJsClassicSearchParam(reference, context)
+        }
         return null
-      }
-      const urlTransformed = injectQueryParams(reference.url, {
-        as_js_classic: "",
-      })
-      reference.filename = generateJsClassicFilename(reference.url)
-      return urlTransformed
+      },
     },
     fetchUrlContent: async (urlInfo, context) => {
       const originalUrlInfo = await fetchOriginalUrlInfo({
@@ -119,7 +127,15 @@ const asJsClassic = ({ systemJsInjection, systemJsClientFileUrl }) => {
 
 const generateJsClassicFilename = (url) => {
   const filename = urlToFilename(url)
-  const [basename, extension] = splitFileExtension(filename)
+  let [basename, extension] = splitFileExtension(filename)
+  const { searchParams } = new URL(url)
+  if (
+    searchParams.has("as_json_module") ||
+    searchParams.has("as_css_module") ||
+    searchParams.has("as_text_module")
+  ) {
+    extension = ".js"
+  }
   return `${basename}.es5${extension}`
 }
 

package/src/plugins/transpilation/as_js_classic/jsenv_plugin_script_type_module_as_classic.js

@@ -98,7 +98,16 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
         })
 
         const jsModuleUrls = []
-        const getReferenceAsJsClassic = async (reference) => {
+        const getReferenceAsJsClassic = async (
+          reference,
+          {
+            // we don't cook ressource hints
+            // because they might refer to ressource that will be modified during build
+            // It also means something else HAVE to reference that url in order to cook it
+            // so that the preload is deleted by "resync_ressource_hints.js" otherwise
+            cookIt = false,
+          } = {},
+        ) => {
           const [newReference, newUrlInfo] = context.referenceUtils.update(
             reference,
             {
@@ -112,6 +121,8 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
           const jsModuleUrl = newUrlInfo.url
           if (!jsModuleUrls.includes(jsModuleUrl)) {
             jsModuleUrls.push(newUrlInfo.url)
+          }
+          if (cookIt) {
             // during dev it means js modules will be cooked before server sends the HTML
             // it's ok because:
             // - during dev script_type_module are supported (dev use a recent browser)
@@ -141,9 +152,9 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
           // but it's unlikely to happen and people should use "modulepreload" in that case anyway
           if (expectedScriptType === "module") {
             actions.push(async () => {
-              const [newReference] = await getReferenceAsJsClassic(
-                context.referenceUtils.findByGeneratedSpecifier(href),
-              )
+              const reference =
+                context.referenceUtils.findByGeneratedSpecifier(href)
+              const [newReference] = await getReferenceAsJsClassic(reference)
               assignHtmlNodeAttributes(preloadAsScriptNode, {
                 href: newReference.generatedSpecifier,
               })
@@ -158,9 +169,9 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
           )
           const href = hrefAttribute.value
           actions.push(async () => {
-            const [newReference] = await getReferenceAsJsClassic(
-              context.referenceUtils.findByGeneratedSpecifier(href),
-            )
+            const reference =
+              context.referenceUtils.findByGeneratedSpecifier(href)
+            const [newReference] = await getReferenceAsJsClassic(reference)
             assignHtmlNodeAttributes(modulePreloadNode, {
               rel: "preload",
               as: "script",
@@ -176,9 +187,11 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
           if (srcAttribute) {
             actions.push(async () => {
               const specifier = srcAttribute.value
-              const [newReference] = await getReferenceAsJsClassic(
-                context.referenceUtils.findByGeneratedSpecifier(specifier),
-              )
+              const reference =
+                context.referenceUtils.findByGeneratedSpecifier(specifier)
+              const [newReference] = await getReferenceAsJsClassic(reference, {
+                cookIt: true,
+              })
               removeHtmlNodeAttributeByName(moduleScriptNode, "type")
               srcAttribute.value = newReference.generatedSpecifier
             })
@@ -214,6 +227,7 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
             })
             const [, newUrlInfo] = await getReferenceAsJsClassic(
               inlineReference,
+              { cookIt: true },
             )
             removeHtmlNodeAttributeByName(moduleScriptNode, "type")
             setHtmlNodeGeneratedText(moduleScriptNode, {

package/src/plugins/transpilation/as_js_classic/jsenv_plugin_workers_type_module_as_classic.js

@@ -21,7 +21,7 @@ export const jsenvPluginWorkersTypeModuleAsClassic = ({
   return {
     name: "jsenv:workers_type_module_as_classic",
     appliesDuring: "*",
-    normalizeUrl: {
+    redirectUrl: {
       js_url_specifier: (reference, context) => {
         if (reference.expectedType !== "js_module") {
           return null

package/src/plugins/transpilation/import_assertions/jsenv_plugin_import_assertions.js

@@ -27,16 +27,16 @@ export const jsenvPluginImportAssertions = () => {
         end: reference.assertNode.end,
       })
     }
-
-    return injectQueryParams(reference.url, {
+    const newUrl = injectQueryParams(reference.url, {
       [searchParam]: "",
     })
+    return newUrl
   }
 
   const importAssertions = {
     name: "jsenv:import_assertions",
     appliesDuring: "*",
-    normalizeUrl: {
+    redirectUrl: {
       js_import_export: (reference, context) => {
         if (!reference.assert) {
           return null

package/src/plugins/url_analysis/css/css_urls.js

@@ -13,19 +13,26 @@ export const parseAndTransformCssUrls = async (urlInfo, context) => {
     sourcemaps: false,
     plugins: [
       postCssPluginUrlVisitor({
-        urlVisitor: ({ type, specifier, line, column, start, end }) => {
+        urlVisitor: ({
+          type,
+          specifier,
+          specifierStart,
+          specifierEnd,
+          specifierLine,
+          specifierColumn,
+        }) => {
           const [reference] = context.referenceUtils.found({
             type: `css_${type}`,
             specifier,
-            specifierStart: start,
-            specifierEnd: end,
-            specifierLine: line,
-            specifierColumn: column,
+            specifierStart,
+            specifierEnd,
+            specifierLine,
+            specifierColumn,
           })
           actions.push(async () => {
             magicSource.replace({
-              start,
-              end,
+              start: specifierStart,
+              end: specifierEnd,
               replacement: await context.referenceUtils.readGeneratedSpecifier(
                 reference,
               ),

package/src/plugins/url_analysis/html/html_urls.js

@@ -96,8 +96,8 @@ const visitHtmlUrls = ({ url, htmlAst, onUrl }) => {
       ...readFetchMetas(node),
     })
   }
-  const onNode = (node) => {
-    if (node.nodeName === "link") {
+  const visitors = {
+    link: (node) => {
       const relAttribute = getHtmlNodeAttributeByName(node, "rel")
       const rel = relAttribute ? relAttribute.value : undefined
       const typeAttribute = getHtmlNodeAttributeByName(node, "type")
@@ -114,13 +114,9 @@ const visitHtmlUrls = ({ url, htmlAst, onUrl }) => {
           stylesheet: "css",
         }[rel],
       })
-      return
-    }
-    // if (node.nodeName === "style") {
-    //   // styles.push(node)
-    //   return
-    // }
-    if (node.nodeName === "script") {
+    },
+    // style: () => {},
+    script: (node) => {
       const typeAttributeNode = getHtmlNodeAttributeByName(node, "type")
       visitAttributeAsUrlSpecifier({
         type: "script_src",
@@ -133,23 +129,22 @@ const visitHtmlUrls = ({ url, htmlAst, onUrl }) => {
         node,
         attributeName: "src",
       })
-      return
-    }
-    if (node.nodeName === "a") {
+    },
+    a: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "a_href",
         node,
         attributeName: "href",
       })
-    }
-    if (node.nodeName === "iframe") {
+    },
+    iframe: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "iframe_src",
         node,
         attributeName: "src",
       })
-    }
-    if (node.nodeName === "img") {
+    },
+    img: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "img_src",
         node,
@@ -159,9 +154,8 @@ const visitHtmlUrls = ({ url, htmlAst, onUrl }) => {
         type: "img_srcset",
         node,
       })
-      return
-    }
-    if (node.nodeName === "source") {
+    },
+    souce: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "source_src",
         node,
@@ -171,25 +165,22 @@ const visitHtmlUrls = ({ url, htmlAst, onUrl }) => {
         type: "source_srcset",
         node,
       })
-      return
-    }
+    },
     // svg <image> tag
-    if (node.nodeName === "image") {
+    image: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "image_href",
         node,
         attributeName: "href",
       })
-      return
-    }
-    if (node.nodeName === "use") {
+    },
+    use: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "use_href",
         node,
         attributeName: "href",
       })
-      return
-    }
+    },
   }
   const visitAttributeAsUrlSpecifier = ({
     type,
@@ -252,7 +243,12 @@ const visitHtmlUrls = ({ url, htmlAst, onUrl }) => {
       })
     }
   }
-  visitHtmlAst(htmlAst, onNode)
+  visitHtmlAst(htmlAst, (node) => {
+    const visitor = visitors[node.nodeName]
+    if (visitor) {
+      visitor(node)
+    }
+  })
 }
 
 const crossOriginCompatibleTagNames = ["script", "link", "img", "source"]

package/src/plugins/url_version/jsenv_plugin_url_version.js

@@ -2,7 +2,7 @@ export const jsenvPluginUrlVersion = ({ longTermCache = true } = {}) => {
   return {
     name: "jsenv:url_version",
     appliesDuring: "*", // maybe only during dev?
-    normalizeUrl: (reference) => {
+    redirectUrl: (reference) => {
       // "v" search param goal is to enable long-term cache
       // for server response headers
       // it is also used by hmr to bypass browser cache

package/src/omega/url_graph/url_graph_sort.js

@@ -1,29 +0,0 @@
-export const sortUrlGraphByDependencies = (urlGraph) => {
-  const { urlInfos } = urlGraph
-
-  const visited = []
-  const sorted = []
-  const circular = []
-  const visit = (url) => {
-    const isSorted = sorted.includes(url)
-    if (isSorted) {
-      return
-    }
-    const isVisited = visited.includes(url)
-    if (isVisited) {
-      circular.push(url)
-      sorted.push(url)
-    } else {
-      visited.push(url)
-      urlInfos[url].dependencies.forEach((dependencyUrl) => {
-        visit(dependencyUrl, url)
-      })
-      sorted.push(url)
-    }
-  }
-  Object.keys(urlInfos).forEach((url) => {
-    visit(url)
-  })
-  sorted.circular = circular
-  return sorted
-}