@jsenv/core 40.0.9 → 40.1.0

package/src/build/build.js

@@ -21,19 +21,43 @@ import { parseHtml, stringifyHtmlAst } from "@jsenv/ast";
 import {
   assertAndNormalizeDirectoryUrl,
   clearDirectorySync,
+  compareFileUrls,
   ensureEmptyDirectory,
   lookupPackageDirectory,
   writeFileSync,
 } from "@jsenv/filesystem";
-import { createLogger, createTaskLog } from "@jsenv/humanize";
+import {
+  ANSI,
+  createDynamicLog,
+  createLogger,
+  createTaskLog,
+  humanizeDuration,
+  humanizeMemory,
+  UNICODE,
+} from "@jsenv/humanize";
+import { applyNodeEsmResolution } from "@jsenv/node-esm-resolution";
+import {
+  startMonitoringCpuUsage,
+  startMonitoringMemoryUsage,
+} from "@jsenv/os-metrics";
 import { jsenvPluginBundling } from "@jsenv/plugin-bundling";
 import { jsenvPluginMinification } from "@jsenv/plugin-minification";
 import { jsenvPluginJsModuleFallback } from "@jsenv/plugin-transpilation";
-import { urlIsInsideOf } from "@jsenv/urls";
+import {
+  browserDefaultRuntimeCompat,
+  inferRuntimeCompatFromClosestPackage,
+  nodeDefaultRuntimeCompat,
+} from "@jsenv/runtime-compat";
+import {
+  urlIsInsideOf,
+  urlToBasename,
+  urlToExtension,
+  urlToRelativeUrl,
+} from "@jsenv/urls";
+import { memoryUsage as processMemoryUsage } from "node:process";
 import { watchSourceFiles } from "../helpers/watch_source_files.js";
 import { jsenvCoreDirectoryUrl } from "../jsenv_core_directory_url.js";
 import { createKitchen } from "../kitchen/kitchen.js";
-import { createUrlGraphSummary } from "../kitchen/url_graph/url_graph_report.js";
 import { GRAPH_VISITOR } from "../kitchen/url_graph/url_graph_visitor.js";
 import { jsenvPluginDirectoryReferenceEffect } from "../plugins/directory_reference_effect/jsenv_plugin_directory_reference_effect.js";
 import { jsenvPluginInlining } from "../plugins/inlining/jsenv_plugin_inlining.js";
@@ -43,15 +67,12 @@ import {
 } from "../plugins/plugin_controller.js";
 import { getCorePlugins } from "../plugins/plugins.js";
 import { jsenvPluginReferenceAnalysis } from "../plugins/reference_analysis/jsenv_plugin_reference_analysis.js";
-import {
-  defaultRuntimeCompat,
-  getDefaultBase,
-  logsDefault,
-} from "./build_params.js";
+import { renderBuildDoneLog } from "./build_content_report.js";
+import { defaultRuntimeCompat, logsDefault } from "./build_params.js";
 import { createBuildSpecifierManager } from "./build_specifier_manager.js";
+import { createBuildUrlsGenerator } from "./build_urls_generator.js";
 import { jsenvPluginLineBreakNormalization } from "./jsenv_plugin_line_break_normalization.js";
 import { jsenvPluginMappings } from "./jsenv_plugin_mappings.js";
-import { jsenvPluginSubbuilds } from "./jsenv_plugin_subbuilds.js";
 
 /**
  * Generate an optimized version of source files into a directory.
@@ -66,8 +87,8 @@ import { jsenvPluginSubbuilds } from "./jsenv_plugin_subbuilds.js";
  *        Keys are relative to sourceDirectoryUrl
  * @param {object} params.runtimeCompat
  *        Code generated will be compatible with these runtimes
- * @param {string} [params.assetsDirectory=""]
- *        Directory where asset files will be written
+ * @param {string} [params.assetsDirectory]
+ *        Directory where asset files will be written. By default sibling to the entry build file.
  * @param {string|url} [params.base=""]
  *        Urls in build file contents will be prefixed with this string
  * @param {boolean|object} [params.bundling=true]
@@ -89,54 +110,29 @@ import { jsenvPluginSubbuilds } from "./jsenv_plugin_subbuilds.js";
  *        Map build file paths without versioning to versioned file paths
  */
 export const build = async ({
-  signal = new AbortController().signal,
-  handleSIGINT = true,
-  logs = logsDefault,
   sourceDirectoryUrl,
   buildDirectoryUrl,
   entryPoints = {},
-  assetsDirectory = "",
-  runtimeCompat = defaultRuntimeCompat,
-  base = getDefaultBase(runtimeCompat),
-  ignore,
-
-  mappings,
-  subbuilds = [],
-  plugins = [],
-  referenceAnalysis = {},
-  nodeEsmResolution,
-  magicExtensions,
-  magicDirectoryIndex,
-  directoryReferenceEffect,
-  scenarioPlaceholders,
-  injections,
-  transpilation = {},
-  bundling = true,
-  minification = !runtimeCompat.node,
-  versioning = !runtimeCompat.node,
-  versioningMethod = "search_param", // "filename", "search_param"
-  versioningViaImportmap = true,
-  versionLength = 8,
-  lineBreakNormalization = process.platform === "win32",
+  logs,
 
-  sourceFilesConfig = {},
-  cooldownBetweenFileEvents,
-  watch = false,
-  http = false,
-
-  buildDirectoryCleanPatterns = {
-    "**/*": true,
-  },
-  sourcemaps = "none",
-  sourcemapsSourcesContent,
-  writeOnFileSystem = true,
   outDirectoryUrl,
-  assetManifest = versioningMethod === "filename",
-  assetManifestFileRelativeUrl = "asset-manifest.json",
+  buildDirectoryCleanPatterns = { "**/*": true },
   returnBuildInlineContents,
   returnBuildManifest,
+  returnBuildFileVersions,
+  signal = new AbortController().signal,
+  handleSIGINT = true,
+
+  writeOnFileSystem = true,
+
+  watch = false,
+  sourceFilesConfig = {},
+  cooldownBetweenFileEvents,
+
   ...rest
 }) => {
+  const entryPointArray = [];
+
   // param validation
   {
     const unexpectedParamNames = Object.keys(rest);
@@ -145,88 +141,166 @@ export const build = async ({
         `${unexpectedParamNames.join(",")}: there is no such param`,
       );
     }
-    // logs
+    // source and build directory
     {
-      if (typeof logs !== "object") {
-        throw new TypeError(`logs must be an object, got ${logs}`);
-      }
-      const unexpectedLogsKeys = Object.keys(logs).filter(
-        (key) => !Object.hasOwn(logsDefault, key),
+      sourceDirectoryUrl = assertAndNormalizeDirectoryUrl(
+        sourceDirectoryUrl,
+        "sourceDirectoryUrl",
       );
-      if (unexpectedLogsKeys.length > 0) {
+      buildDirectoryUrl = assertAndNormalizeDirectoryUrl(
+        buildDirectoryUrl,
+        "buildDirectoryUrl",
+      );
+    }
+    // entry points
+    {
+      if (typeof entryPoints !== "object" || entryPoints === null) {
         throw new TypeError(
-          `${unexpectedLogsKeys.join(",")}: no such key on logs`,
+          `The value "${entryPoints}" for "entryPoints" is invalid: it must be an object.`,
         );
       }
-      logs = { ...logsDefault, ...logs };
-    }
-    sourceDirectoryUrl = assertAndNormalizeDirectoryUrl(
-      sourceDirectoryUrl,
-      "sourceDirectoryUrl",
-    );
-    buildDirectoryUrl = assertAndNormalizeDirectoryUrl(
-      buildDirectoryUrl,
-      "buildDirectoryUrl",
-    );
-    if (outDirectoryUrl === undefined) {
-      if (
-        process.env.CAPTURING_SIDE_EFFECTS ||
-        (!import.meta.build &&
-          urlIsInsideOf(sourceDirectoryUrl, jsenvCoreDirectoryUrl))
-      ) {
-        outDirectoryUrl = new URL("../.jsenv_b/", sourceDirectoryUrl);
-      } else {
-        const packageDirectoryUrl = lookupPackageDirectory(sourceDirectoryUrl);
-        if (packageDirectoryUrl) {
-          outDirectoryUrl = `${packageDirectoryUrl}.jsenv/`;
+      const keys = Object.keys(entryPoints);
+      const isSingleEntryPoint = keys.length === 1;
+      for (const key of keys) {
+        // key (sourceRelativeUrl)
+        let sourceUrl;
+        let runtimeType;
+        {
+          if (isBareSpecifier(key)) {
+            const packageConditions = ["development", "node", "import"];
+            try {
+              const { url, type } = applyNodeEsmResolution({
+                conditions: packageConditions,
+                parentUrl: sourceDirectoryUrl,
+                specifier: key,
+              });
+              if (type === "field:browser") {
+                runtimeType = "browser";
+              }
+              sourceUrl = url;
+            } catch (e) {
+              throw new Error(
+                `The key "${key}" in "entryPoints" is invalid: it cannot be resolved.`,
+                { cause: e },
+              );
+            }
+          } else {
+            if (!key.startsWith("./")) {
+              throw new TypeError(
+                `The key "${key}" in "entryPoints" is invalid: it must start with "./".`,
+              );
+            }
+
+            try {
+              sourceUrl = new URL(key, sourceDirectoryUrl).href;
+            } catch {
+              throw new TypeError(
+                `The key "${key}" in "entryPoints" is invalid: it must be a relative url.`,
+              );
+            }
+          }
+          if (!urlIsInsideOf(sourceUrl, sourceDirectoryUrl)) {
+            throw new Error(
+              `The key "${key}" in "entryPoints" is invalid: it must be inside the source directory at ${sourceDirectoryUrl}.`,
+            );
+          }
+
+          if (!runtimeType) {
+            const ext = urlToExtension(sourceUrl);
+            if (ext === ".html" || ext === ".css") {
+              runtimeType = "browser";
+            }
+          }
         }
-      }
-    } else if (outDirectoryUrl) {
-      outDirectoryUrl = assertAndNormalizeDirectoryUrl(
-        outDirectoryUrl,
-        "outDirectoryUrl",
-      );
-    }
 
-    if (typeof entryPoints !== "object" || entryPoints === null) {
-      throw new TypeError(`entryPoints must be an object, got ${entryPoints}`);
-    }
-    const keys = Object.keys(entryPoints);
-    keys.forEach((key) => {
-      if (!key.startsWith("./")) {
-        throw new TypeError(
-          `entryPoints keys must start with "./", found ${key}`,
-        );
+        // value (entryPointParams)
+        const value = entryPoints[key];
+        {
+          if (value === null || typeof value !== "object") {
+            throw new TypeError(
+              `The value "${value}" in "entryPoints" is invalid: it must be an object.`,
+            );
+          }
+          const forEntryPointOrEmpty = isSingleEntryPoint
+            ? ""
+            : ` for entry point "${key}"`;
+          const unexpectedEntryPointParamNames = Object.keys(value).filter(
+            (key) => !Object.hasOwn(entryPointDefaultParams, key),
+          );
+          if (unexpectedEntryPointParamNames.length) {
+            throw new TypeError(
+              `The value${forEntryPointOrEmpty} contains unknown keys: ${unexpectedEntryPointParamNames.join(",")}.`,
+            );
+          }
+          const { versioningMethod } = value;
+          if (versioningMethod !== undefined) {
+            if (!["filename", "search_param"].includes(versioningMethod)) {
+              throw new TypeError(
+                `The versioningMethod "${versioningMethod}"${forEntryPointOrEmpty} is invalid: it must be "filename" or "search_param".`,
+              );
+            }
+          }
+          const { buildRelativeUrl } = value;
+          if (buildRelativeUrl !== undefined) {
+            let buildUrl;
+            try {
+              buildUrl = new URL(buildRelativeUrl, buildDirectoryUrl);
+            } catch {
+              throw new TypeError(
+                `The buildRelativeUrl "${buildRelativeUrl}"${forEntryPointOrEmpty} is invalid: it must be a relative url.`,
+              );
+            }
+            if (!urlIsInsideOf(buildUrl, buildDirectoryUrl)) {
+              throw new Error(
+                `The buildRelativeUrl "${buildRelativeUrl}"${forEntryPointOrEmpty} is invalid: it must be inside the build directory at ${buildDirectoryUrl}.`,
+              );
+            }
+          }
+          const { runtimeCompat } = value;
+          if (runtimeCompat !== undefined) {
+            if (runtimeCompat === null || typeof runtimeCompat !== "object") {
+              throw new TypeError(
+                `The runtimeCompat "${runtimeCompat}"${forEntryPointOrEmpty} is invalid: it must be an object.`,
+              );
+            }
+          }
+        }
+
+        entryPointArray.push({
+          key,
+          sourceUrl,
+          sourceRelativeUrl: `./${urlToRelativeUrl(sourceUrl, sourceDirectoryUrl)}`,
+          params: { ...value },
+          runtimeType,
+        });
       }
-      const value = entryPoints[key];
-      if (typeof value !== "string") {
+    }
+    // logs
+    if (logs === undefined) {
+      logs = logsDefault;
+    } else {
+      if (typeof logs !== "object") {
         throw new TypeError(
-          `entryPoints values must be strings, found "${value}" on key "${key}"`,
+          `The value "${logs}" is invalid for param logs: it must be an object.`,
         );
       }
-      if (value.includes("/")) {
+      const unexpectedLogsKeys = Object.keys(logs).filter(
+        (key) => !Object.hasOwn(logsDefault, key),
+      );
+      if (unexpectedLogsKeys.length > 0) {
         throw new TypeError(
-          `entryPoints values must be plain strings (no "/"), found "${value}" on key "${key}"`,
+          `The param logs have unknown params: ${unexpectedLogsKeys.join(",")}.`,
         );
       }
-    });
-    if (!["filename", "search_param"].includes(versioningMethod)) {
-      throw new TypeError(
-        `versioningMethod must be "filename" or "search_param", got ${versioning}`,
-      );
-    }
-    if (bundling === true) {
-      bundling = {};
     }
-    if (minification === true) {
-      minification = {};
+    if (outDirectoryUrl !== undefined) {
+      outDirectoryUrl = assertAndNormalizeDirectoryUrl(
+        outDirectoryUrl,
+        "outDirectoryUrl",
+      );
     }
   }
 
-  if (assetsDirectory && assetsDirectory[assetsDirectory.length - 1] !== "/") {
-    assetsDirectory = `${assetsDirectory}/`;
-  }
-
   const operation = Abort.startOperation();
   operation.addAbortSignal(signal);
   if (handleSIGINT) {
@@ -240,463 +314,340 @@ export const build = async ({
     });
   }
 
-  const runBuild = async ({ signal, logLevel }) => {
-    const logger = createLogger({ logLevel });
-    const createBuildTask = (label) => {
-      return createTaskLog(label, {
-        disabled:
-          logs.disabled || (!logger.levels.debug && !logger.levels.info),
-        animated: logs.animation && !logger.levels.debug,
-      });
-    };
+  const cpuMonitoring = startMonitoringCpuUsage();
+  operation.addEndCallback(cpuMonitoring.stop);
+  const [processCpuUsageMonitoring] = cpuMonitoring;
+  const memoryMonitoring = startMonitoringMemoryUsage();
+  const [processMemoryUsageMonitoring] = memoryMonitoring;
+  const interval = setInterval(() => {
+    processCpuUsageMonitoring.measure();
+    processMemoryUsageMonitoring.measure();
+  }, 500).unref();
+  operation.addEndCallback(() => {
+    clearInterval(interval);
+  });
 
-    const buildOperation = Abort.startOperation();
-    buildOperation.addAbortSignal(signal);
-    const entryPointKeys = Object.keys(entryPoints);
-    if (entryPointKeys.length === 1) {
-      logger.info(`
-build "${entryPointKeys[0]}"`);
-    } else {
-      logger.info(`
-build ${entryPointKeys.length} entry points`);
-    }
-    let explicitJsModuleConversion = false;
-    for (const entryPointKey of entryPointKeys) {
-      if (entryPointKey.includes("?js_module_fallback")) {
-        explicitJsModuleConversion = true;
-        break;
-      }
-      if (entryPointKey.includes("?as_js_classic")) {
-        explicitJsModuleConversion = true;
-        break;
-      }
-    }
-    const entryUrls = [];
-    const contextSharedDuringBuild = {
-      buildStep: "craft",
-      buildDirectoryUrl,
-      assetsDirectory,
-      versioning,
-      versioningViaImportmap,
-    };
-    const rawKitchen = createKitchen({
-      signal,
-      logLevel: logs.level,
-      rootDirectoryUrl: sourceDirectoryUrl,
-      ignore,
-      // during first pass (craft) we keep "ignore:" when a reference is ignored
-      // so that the second pass (shape) properly ignore those urls
-      ignoreProtocol: "keep",
-      build: true,
-      runtimeCompat,
-      initialContext: contextSharedDuringBuild,
-      sourcemaps,
-      sourcemapsSourcesContent,
-      outDirectoryUrl: outDirectoryUrl
-        ? new URL("craft/", outDirectoryUrl)
-        : undefined,
+  const logLevel = logs.level;
+  const logger = createLogger({ logLevel });
+  const animatedLogEnabled =
+    logs.animated &&
+    // canEraseProcessStdout
+    process.stdout.isTTY &&
+    // if there is an error during execution npm will mess up the output
+    // (happens when npm runs several command in a workspace)
+    // so we enable hot replace only when !process.exitCode (no error so far)
+    process.exitCode !== 1;
+  let startBuildLogs = () => {};
+
+  const renderEntyPointBuildDoneLog = (
+    entryBuildInfo,
+    { sourceUrlToLog, buildUrlToLog },
+  ) => {
+    let content = "";
+    content += `${UNICODE.OK} ${ANSI.color(sourceUrlToLog, ANSI.GREY)} ${ANSI.color("->", ANSI.GREY)} ${ANSI.color(buildUrlToLog, "")}`;
+    // content += " ";
+    // content += ANSI.color("(", ANSI.GREY);
+    // content += ANSI.color(
+    //   humanizeDuration(entryBuildInfo.duration, { short: true }),
+    //   ANSI.GREY,
+    // );
+    // content += ANSI.color(")", ANSI.GREY);
+    content += "\n";
+    return content;
+  };
+  const renderBuildEndLog = ({ duration, buildFileContents }) => {
+    // tell how many files are generated in build directory
+    // tell the repartition?
+    // this is not really useful for single build right?
+
+    processCpuUsageMonitoring.end();
+    processMemoryUsageMonitoring.end();
+
+    return renderBuildDoneLog({
+      duration,
+      buildFileContents,
+      processCpuUsage: processCpuUsageMonitoring.info,
+      processMemoryUsage: processMemoryUsageMonitoring.info,
     });
+  };
 
-    let subbuildResults = [];
+  if (animatedLogEnabled) {
+    startBuildLogs = () => {
+      const startMs = Date.now();
+      let dynamicLog = createDynamicLog();
+      const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+      let frameIndex = 0;
+      let oneWrite = false;
+      const memoryHeapUsedAtStart = processMemoryUsage().heapUsed;
+      const renderDynamicLog = () => {
+        frameIndex = frameIndex === frames.length - 1 ? 0 : frameIndex + 1;
+        let dynamicLogContent = "";
+        dynamicLogContent += `${frames[frameIndex]} `;
+        dynamicLogContent += `building ${entryPointArray.length} entry points`;
 
-    const rawPluginStore = createPluginStore([
-      ...(mappings ? [jsenvPluginMappings(mappings)] : []),
-      ...jsenvPluginSubbuilds(subbuilds, {
-        parentBuildParams: {
-          sourceDirectoryUrl,
-          buildDirectoryUrl,
-          runtimeCompat,
-          bundling,
-          minification,
-          versioning,
-          versioningMethod,
-          outDirectoryUrl,
-        },
-        onCustomBuildDirectory: (subBuildRelativeUrl) => {
-          buildDirectoryCleanPatterns = {
-            ...buildDirectoryCleanPatterns,
-            [`${subBuildRelativeUrl}**/*`]: false,
+        const msEllapsed = Date.now() - startMs;
+        const infos = [];
+        const duration = humanizeDuration(msEllapsed, {
+          short: true,
+          decimals: 0,
+          rounded: false,
+        });
+        infos.push(ANSI.color(duration, ANSI.GREY));
+        let memoryUsageColor = ANSI.GREY;
+        const memoryHeapUsed = processMemoryUsage().heapUsed;
+        if (memoryHeapUsed > 2.5 * memoryHeapUsedAtStart) {
+          memoryUsageColor = ANSI.YELLOW;
+        } else if (memoryHeapUsed > 1.5 * memoryHeapUsedAtStart) {
+          memoryUsageColor = null;
+        }
+        const memoryHeapUsedFormatted = humanizeMemory(memoryHeapUsed, {
+          short: true,
+          decimals: 0,
+        });
+        infos.push(ANSI.color(memoryHeapUsedFormatted, memoryUsageColor));
+
+        const infoFormatted = infos.join(ANSI.color(`/`, ANSI.GREY));
+        dynamicLogContent += ` ${ANSI.color(
+          "[",
+          ANSI.GREY,
+        )}${infoFormatted}${ANSI.color("]", ANSI.GREY)}`;
+
+        if (oneWrite) {
+          dynamicLogContent = `\n${dynamicLogContent}`;
+        }
+        dynamicLogContent = `${dynamicLogContent}\n`;
+        return dynamicLogContent;
+      };
+      dynamicLog.update(renderDynamicLog());
+      const interval = setInterval(() => {
+        dynamicLog.update(renderDynamicLog());
+      }, 150).unref();
+      signal.addEventListener("abort", () => {
+        clearInterval(interval);
+      });
+      return {
+        onEntryPointBuildStart: (
+          entryBuildInfo,
+          { sourceUrlToLog, buildUrlToLog },
+        ) => {
+          return () => {
+            oneWrite = true;
+            dynamicLog.clearDuringFunctionCall((write) => {
+              const log = renderEntyPointBuildDoneLog(entryBuildInfo, {
+                sourceUrlToLog,
+                buildUrlToLog,
+              });
+              write(log);
+            }, renderDynamicLog());
           };
         },
-        buildStart: async (params, index) => {
-          const result = await build({
-            ...params,
-            signal,
-            handleSIGINT: false,
-          });
-          subbuildResults[index] = result;
-          return result;
+        onBuildEnd: ({ buildFileContents, duration }) => {
+          clearInterval(interval);
+          dynamicLog.update("");
+          dynamicLog.destroy();
+          dynamicLog = null;
+          logger.info("");
+          logger.info(renderBuildEndLog({ duration, buildFileContents }));
         },
-      }),
-      ...plugins,
-      ...(bundling ? [jsenvPluginBundling(bundling)] : []),
-      ...(minification ? [jsenvPluginMinification(minification)] : []),
-      ...getCorePlugins({
-        rootDirectoryUrl: sourceDirectoryUrl,
-        runtimeCompat,
-        referenceAnalysis,
-        nodeEsmResolution,
-        magicExtensions,
-        magicDirectoryIndex,
-        directoryReferenceEffect,
-        injections,
-        transpilation: {
-          babelHelpersAsImport: !explicitJsModuleConversion,
-          ...transpilation,
-          jsModuleFallback: false,
+      };
+    };
+  } else {
+    startBuildLogs = () => {
+      if (entryPointArray.length === 1) {
+        const [singleEntryPoint] = entryPointArray;
+        logger.info(`building ${singleEntryPoint.key}`);
+      } else {
+        logger.info(`building ${entryPointArray.length} entry points`);
+      }
+      logger.info("");
+      return {
+        onEntryPointBuildStart: (
+          entryBuildInfo,
+          { sourceUrlToLog, buildUrlToLog },
+        ) => {
+          return () => {
+            logger.info(
+              renderEntyPointBuildDoneLog(entryBuildInfo, {
+                sourceUrlToLog,
+                buildUrlToLog,
+              }),
+            );
+          };
         },
-        inlining: false,
-        http,
-        scenarioPlaceholders,
-      }),
-    ]);
-    const rawPluginController = createPluginController(
-      rawPluginStore,
-      rawKitchen,
-    );
-    rawKitchen.setPluginController(rawPluginController);
+        onBuildEnd: ({ buildFileContents, duration }) => {
+          logger.info("");
+          logger.info(renderBuildEndLog({ duration, buildFileContents }));
+        },
+      };
+    };
+  }
 
-    craft: {
-      const generateSourceGraph = createBuildTask("generate source graph");
-      try {
-        if (outDirectoryUrl) {
-          await ensureEmptyDirectory(new URL(`craft/`, outDirectoryUrl));
-        }
-        const rawRootUrlInfo = rawKitchen.graph.rootUrlInfo;
-        await rawRootUrlInfo.dependencies.startCollecting(() => {
-          Object.keys(entryPoints).forEach((key) => {
-            const entryReference = rawRootUrlInfo.dependencies.found({
-              trace: { message: `"${key}" in entryPoints parameter` },
-              isEntryPoint: true,
-              type: "entry_point",
-              specifier: key,
-              filenameHint: entryPoints[key],
-            });
-            entryUrls.push(entryReference.url);
-          });
-        });
-        await rawRootUrlInfo.cookDependencies({
-          operation: buildOperation,
-        });
-      } catch (e) {
-        generateSourceGraph.fail();
-        throw e;
-      }
-      generateSourceGraph.done();
+  // we want to start building the entry point that are deeper
+  // - they are more likely to be small
+  // - they are more likely to be referenced by highter files that will depend on them
+  entryPointArray.sort((a, b) => {
+    return compareFileUrls(a.sourceUrl, b.sourceUrl);
+  });
+
+  const packageDirectoryUrl = lookupPackageDirectory(sourceDirectoryUrl);
+  if (outDirectoryUrl === undefined) {
+    if (
+      process.env.CAPTURING_SIDE_EFFECTS ||
+      (!import.meta.build &&
+        urlIsInsideOf(sourceDirectoryUrl, jsenvCoreDirectoryUrl))
+    ) {
+      outDirectoryUrl = new URL("../.jsenv_b/", sourceDirectoryUrl).href;
+    } else if (packageDirectoryUrl) {
+      outDirectoryUrl = `${packageDirectoryUrl}.jsenv/`;
     }
+  }
+  let rootPackageDirectoryUrl = packageDirectoryUrl;
+  if (packageDirectoryUrl) {
+    const parentPackageDirectoryUrl = lookupPackageDirectory(
+      new URL("../", packageDirectoryUrl),
+    );
+    if (parentPackageDirectoryUrl) {
+      rootPackageDirectoryUrl = parentPackageDirectoryUrl;
+    }
+  }
 
-    const finalKitchen = createKitchen({
-      name: "shape",
-      logLevel: logs.level,
-      rootDirectoryUrl: sourceDirectoryUrl,
-      // here most plugins are not there
-      // - no external plugin
-      // - no plugin putting reference.mustIgnore on https urls
-      // At this stage it's only about redirecting urls to the build directory
-      // consequently only a subset or urls are supported
-      supportedProtocols: ["file:", "data:", "virtual:", "ignore:"],
-      ignore,
-      ignoreProtocol: "remove",
-      build: true,
-      runtimeCompat,
-      initialContext: contextSharedDuringBuild,
-      sourcemaps,
-      sourcemapsComment: "relative",
-      sourcemapsSourcesContent,
-      outDirectoryUrl: outDirectoryUrl
-        ? new URL("shape/", outDirectoryUrl)
-        : undefined,
-    });
-    const buildSpecifierManager = createBuildSpecifierManager({
-      rawKitchen,
-      finalKitchen,
-      logger,
+  const runBuild = async ({ signal }) => {
+    const startDate = Date.now();
+    const { onBuildEnd, onEntryPointBuildStart } = startBuildLogs();
+
+    const buildUrlsGenerator = createBuildUrlsGenerator({
       sourceDirectoryUrl,
       buildDirectoryUrl,
-      base,
-      assetsDirectory,
-
-      versioning,
-      versioningMethod,
-      versionLength,
-      canUseImportmap:
-        versioningViaImportmap &&
-        entryUrls.every((finalEntryUrl) => {
-          const entryUrlInfo = rawKitchen.graph.getUrlInfo(finalEntryUrl);
-          return entryUrlInfo.type === "html";
-        }) &&
-        rawKitchen.context.isSupportedOnCurrentClients("importmap"),
     });
-    const finalPluginStore = createPluginStore([
-      jsenvPluginReferenceAnalysis({
-        ...referenceAnalysis,
-        fetchInlineUrls: false,
-        // inlineContent: false,
-      }),
-      jsenvPluginDirectoryReferenceEffect(directoryReferenceEffect),
-      ...(lineBreakNormalization ? [jsenvPluginLineBreakNormalization()] : []),
-      jsenvPluginJsModuleFallback({
-        remapImportSpecifier: (specifier, parentUrl) => {
-          return buildSpecifierManager.remapPlaceholder(specifier, parentUrl);
-        },
-      }),
-      jsenvPluginInlining(),
-      {
-        name: "jsenv:optimize",
-        appliesDuring: "build",
-        transformUrlContent: async (urlInfo) => {
-          await rawKitchen.pluginController.callAsyncHooks(
-            "optimizeUrlContent",
-            urlInfo,
-            (optimizeReturnValue) => {
-              urlInfo.mutateContent(optimizeReturnValue);
-            },
-          );
-        },
-      },
-      buildSpecifierManager.jsenvPluginMoveToBuildDirectory,
-    ]);
-    const finalPluginController = createPluginController(
-      finalPluginStore,
-      finalKitchen,
-      {
-        initialPuginsMeta: rawKitchen.pluginController.pluginsMeta,
-      },
-    );
-    finalKitchen.setPluginController(finalPluginController);
-
-    const bundlers = {};
-    bundle: {
-      for (const plugin of rawKitchen.pluginController.activePlugins) {
-        const bundle = plugin.bundle;
-        if (!bundle) {
-          continue;
-        }
-        if (typeof bundle !== "object") {
-          throw new Error(
-            `bundle must be an object, found "${bundle}" on plugin named "${plugin.name}"`,
-          );
-        }
-        for (const type of Object.keys(bundle)) {
-          const bundleFunction = bundle[type];
-          if (!bundleFunction) {
-            continue;
-          }
-          const bundlerForThatType = bundlers[type];
-          if (bundlerForThatType) {
-            // first plugin to define a bundle hook wins
-            continue;
-          }
-          bundlers[type] = {
-            plugin,
-            bundleFunction: bundle[type],
-            urlInfoMap: new Map(),
-          };
+
+    let someEntryPointUseNode = false;
+    for (const entryPoint of entryPointArray) {
+      let { runtimeCompat } = entryPoint.params;
+      if (runtimeCompat === undefined) {
+        const runtimeCompatFromPackage = inferRuntimeCompatFromClosestPackage(
+          entryPoint.sourceUrl,
+          {
+            runtimeType: entryPoint.runtimeType,
+          },
+        );
+        if (runtimeCompatFromPackage) {
+          entryPoint.params.runtimeCompat = runtimeCompat =
+            runtimeCompatFromPackage;
+        } else {
+          entryPoint.params.runtimeCompat = runtimeCompat =
+            entryPoint.runtimeType === "browser"
+              ? browserDefaultRuntimeCompat
+              : nodeDefaultRuntimeCompat;
         }
       }
-      const addToBundlerIfAny = (rawUrlInfo) => {
-        const bundler = bundlers[rawUrlInfo.type];
-        if (bundler) {
-          bundler.urlInfoMap.set(rawUrlInfo.url, rawUrlInfo);
-        }
-      };
-      // ignore unused urls thanks to "forEachUrlInfoStronglyReferenced"
-      // it avoid bundling things that are not actually used
-      // happens for:
-      // - js import assertions
-      // - conversion to js classic using ?as_js_classic or ?js_module_fallback
-      GRAPH_VISITOR.forEachUrlInfoStronglyReferenced(
-        rawKitchen.graph.rootUrlInfo,
-        (rawUrlInfo) => {
-          if (rawUrlInfo.isEntryPoint) {
-            addToBundlerIfAny(rawUrlInfo);
-          }
-          if (rawUrlInfo.type === "html") {
-            for (const referenceToOther of rawUrlInfo.referenceToOthersSet) {
-              if (
-                referenceToOther.isResourceHint &&
-                referenceToOther.expectedType === "js_module"
-              ) {
-                const referencedUrlInfo = referenceToOther.urlInfo;
-                if (
-                  referencedUrlInfo &&
-                  // something else than the resource hint is using this url
-                  referencedUrlInfo.referenceFromOthersSet.size > 0
-                ) {
-                  addToBundlerIfAny(referencedUrlInfo);
-                  continue;
-                }
-              }
-              if (referenceToOther.isWeak) {
-                continue;
-              }
-              const referencedUrlInfo = referenceToOther.urlInfo;
-              if (referencedUrlInfo.isInline) {
-                if (referencedUrlInfo.type !== "js_module") {
-                  continue;
-                }
-                addToBundlerIfAny(referencedUrlInfo);
-                continue;
-              }
-              addToBundlerIfAny(referencedUrlInfo);
-            }
-            return;
-          }
-          // File referenced with
-          // - new URL("./file.js", import.meta.url)
-          // - import.meta.resolve("./file.js")
-          // are entry points that should be bundled
-          // For instance we will bundle service worker/workers detected like this
-          if (rawUrlInfo.type === "js_module") {
-            for (const referenceToOther of rawUrlInfo.referenceToOthersSet) {
-              if (
-                referenceToOther.type === "js_url" ||
-                referenceToOther.subtype === "import_meta_resolve"
-              ) {
-                const referencedUrlInfo = referenceToOther.urlInfo;
-                let isAlreadyBundled = false;
-                for (const referenceFromOther of referencedUrlInfo.referenceFromOthersSet) {
-                  if (referenceFromOther.url === referencedUrlInfo.url) {
-                    if (
-                      referenceFromOther.subtype === "import_dynamic" ||
-                      referenceFromOther.type === "script"
-                    ) {
-                      isAlreadyBundled = true;
-                      break;
-                    }
-                  }
-                }
-                if (!isAlreadyBundled) {
-                  addToBundlerIfAny(referencedUrlInfo);
-                }
-                continue;
-              }
-              if (referenceToOther.type === "js_inline_content") {
-                // we should bundle it too right?
-              }
-            }
-          }
-        },
-      );
-      for (const type of Object.keys(bundlers)) {
-        const bundler = bundlers[type];
-        const urlInfosToBundle = Array.from(bundler.urlInfoMap.values());
-        if (urlInfosToBundle.length === 0) {
-          continue;
-        }
-        const bundleTask = createBuildTask(`bundle "${type}"`);
-        try {
-          await buildSpecifierManager.applyBundling({
-            bundler,
-            urlInfosToBundle,
-          });
-        } catch (e) {
-          bundleTask.fail();
-          throw e;
-        }
-        bundleTask.done();
+      if (!someEntryPointUseNode && "node" in runtimeCompat) {
+        someEntryPointUseNode = true;
       }
     }
 
-    shape: {
-      finalKitchen.context.buildStep = "shape";
-      const generateBuildGraph = createBuildTask("generate build graph");
-      try {
-        if (outDirectoryUrl) {
-          await ensureEmptyDirectory(new URL(`shape/`, outDirectoryUrl));
-        }
-        const finalRootUrlInfo = finalKitchen.graph.rootUrlInfo;
-        await finalRootUrlInfo.dependencies.startCollecting(() => {
-          entryUrls.forEach((entryUrl) => {
-            finalRootUrlInfo.dependencies.found({
-              trace: { message: `entryPoint` },
-              isEntryPoint: true,
-              type: "entry_point",
-              specifier: entryUrl,
-            });
-          });
-        });
-        await finalRootUrlInfo.cookDependencies({
-          operation: buildOperation,
-        });
-      } catch (e) {
-        generateBuildGraph.fail();
-        throw e;
+    const entryBuildInfoMap = new Map();
+    let entryPointIndex = 0;
+    const entryOutDirSet = new Set();
+    for (const entryPoint of entryPointArray) {
+      let entryOutDirCandidate = `entry_${urlToBasename(entryPoint.sourceRelativeUrl)}/`;
+      let entryInteger = 1;
+      while (entryOutDirSet.has(entryOutDirCandidate)) {
+        entryInteger++;
+        entryOutDirCandidate = `entry_${urlToBasename(entryPoint.sourceRelativeUrl)}_${entryInteger}/`;
       }
-      generateBuildGraph.done();
-    }
-
-    refine: {
-      finalKitchen.context.buildStep = "refine";
+      const entryOutDirname = entryOutDirCandidate;
+      entryOutDirSet.add(entryOutDirname);
+      const entryOutDirectoryUrl = new URL(entryOutDirname, outDirectoryUrl);
+      const { entryReference, buildEntryPoint } = await prepareEntryPointBuild(
+        {
+          signal,
+          sourceDirectoryUrl,
+          buildDirectoryUrl,
+          outDirectoryUrl: entryOutDirectoryUrl,
+          sourceRelativeUrl: entryPoint.sourceRelativeUrl,
+          buildUrlsGenerator,
+          someEntryPointUseNode,
+        },
+        entryPoint.params,
+      );
+      const entryPointBuildRelativeUrl = entryPoint.params.buildRelativeUrl;
+      const entryBuildInfo = {
+        index: entryPointIndex,
+        entryReference,
+        entryUrlInfo: entryReference.urlInfo,
+        buildRelativeUrl: entryPointBuildRelativeUrl,
+        buildFileContents: undefined,
+        buildFileVersions: undefined,
+        buildInlineContents: undefined,
+        buildManifest: undefined,
+        duration: null,
+        buildEntryPoint: () => {
+          const sourceUrl = new URL(
+            entryPoint.sourceRelativeUrl,
+            sourceDirectoryUrl,
+          );
+          const buildUrl = new URL(
+            entryPointBuildRelativeUrl,
+            buildDirectoryUrl,
+          );
+          const sourceUrlToLog = rootPackageDirectoryUrl
+            ? urlToRelativeUrl(sourceUrl, rootPackageDirectoryUrl)
+            : entryPoint.key;
+          const buildUrlToLog = rootPackageDirectoryUrl
+            ? urlToRelativeUrl(buildUrl, rootPackageDirectoryUrl)
+            : entryPointBuildRelativeUrl;
 
-      const htmlRefineSet = new Set();
-      const registerHtmlRefine = (htmlRefine) => {
-        htmlRefineSet.add(htmlRefine);
+          const entryPointBuildStartMs = Date.now();
+          const onEntryPointBuildEnd = onEntryPointBuildStart(entryBuildInfo, {
+            sourceUrlToLog,
+            buildUrlToLog,
+          });
+          const promise = (async () => {
+            const result = await buildEntryPoint({
+              getOtherEntryBuildInfo: (url) => {
+                if (url === entryReference.url) {
+                  return null;
+                }
+                const otherEntryBuildInfo = entryBuildInfoMap.get(url);
+                if (!otherEntryBuildInfo) {
+                  return null;
+                }
+                return otherEntryBuildInfo;
+              },
+            });
+            entryBuildInfo.buildFileContents = result.buildFileContents;
+            entryBuildInfo.buildFileVersions = result.buildFileVersions;
+            entryBuildInfo.buildInlineContents = result.buildInlineContents;
+            entryBuildInfo.buildManifest = result.buildManifest;
+            entryBuildInfo.duration = Date.now() - entryPointBuildStartMs;
+            onEntryPointBuildEnd();
+          })();
+          entryBuildInfo.promise = promise;
+          return promise;
+        },
       };
+      entryBuildInfoMap.set(entryReference.url, entryBuildInfo);
+      entryPointIndex++;
+    }
 
-      replace_placeholders: {
-        await buildSpecifierManager.replacePlaceholders();
-      }
-
-      /*
-       * Update <link rel="preload"> and friends after build (once we know everything)
-       * - Used to remove resource hint targeting an url that is no longer used:
-       *   - because of bundlings
-       *   - because of import assertions transpilation (file is inlined into JS)
-       */
-      resync_resource_hints: {
-        buildSpecifierManager.prepareResyncResourceHints({
-          registerHtmlRefine,
-        });
-      }
-
-      mutate_html: {
-        GRAPH_VISITOR.forEach(finalKitchen.graph, (urlInfo) => {
-          if (!urlInfo.url.startsWith("file:")) {
-            return;
-          }
-          if (urlInfo.type !== "html") {
-            return;
-          }
-          const htmlAst = parseHtml({
-            html: urlInfo.content,
-            url: urlInfo.url,
-            storeOriginalPositions: false,
-          });
-          for (const htmlRefine of htmlRefineSet) {
-            const htmlMutationCallbackSet = new Set();
-            const registerHtmlMutation = (callback) => {
-              htmlMutationCallbackSet.add(callback);
-            };
-            htmlRefine(htmlAst, { registerHtmlMutation });
-            for (const htmlMutationCallback of htmlMutationCallbackSet) {
-              htmlMutationCallback();
-            }
-          }
-          // cleanup jsenv attributes from html as a last step
-          urlInfo.content = stringifyHtmlAst(htmlAst, {
-            cleanupJsenvAttributes: true,
-            cleanupPositionAttributes: true,
-          });
-        });
-      }
+    const promises = [];
+    for (const [, entryBuildInfo] of entryBuildInfoMap) {
+      const promise = entryBuildInfo.buildEntryPoint();
+      promises.push(promise);
+    }
+    await Promise.all(promises);
 
-      inject_urls_in_service_workers: {
-        const inject = buildSpecifierManager.prepareServiceWorkerUrlInjection();
-        if (inject) {
-          const urlsInjectionInSw = createBuildTask(
-            "inject urls in service worker",
-          );
-          await inject();
-          urlsInjectionInSw.done();
-          buildOperation.throwIfAborted();
-        }
-      }
+    const buildFileContents = {};
+    const buildFileVersions = {};
+    const buildInlineContents = {};
+    const buildManifest = {};
+    for (const [, entryBuildInfo] of entryBuildInfoMap) {
+      Object.assign(buildFileContents, entryBuildInfo.buildFileContents);
+      Object.assign(buildFileVersions, entryBuildInfo.buildFileVersions);
+      Object.assign(buildInlineContents, entryBuildInfo.buildInlineContents);
+      Object.assign(buildManifest, entryBuildInfo.buildManifest);
     }
-    const { buildFileContents, buildInlineContents, buildManifest } =
-      buildSpecifierManager.getBuildInfo();
     if (writeOnFileSystem) {
-      const writingFiles = createBuildTask("write files in build directory");
       clearDirectorySync(buildDirectoryUrl, buildDirectoryCleanPatterns);
       const buildRelativeUrls = Object.keys(buildFileContents);
       buildRelativeUrls.forEach((buildRelativeUrl) => {
@@ -705,23 +656,17 @@ build ${entryPointKeys.length} entry points`);
           buildFileContents[buildRelativeUrl],
         );
       });
-      if (versioning && assetManifest && Object.keys(buildManifest).length) {
-        writeFileSync(
-          new URL(assetManifestFileRelativeUrl, buildDirectoryUrl),
-          JSON.stringify(buildManifest, null, "  "),
-        );
-      }
-      writingFiles.done();
     }
-    logger.info(
-      createUrlGraphSummary(finalKitchen.graph, {
-        title: "build files",
-      }),
-    );
+    onBuildEnd({
+      buildFileContents,
+      buildInlineContents,
+      buildManifest,
+      duration: Date.now() - startDate,
+    });
     return {
       ...(returnBuildInlineContents ? { buildInlineContents } : {}),
       ...(returnBuildManifest ? { buildManifest } : {}),
-      ...(subbuilds.length ? { subbuilds: subbuildResults } : {}),
+      ...(returnBuildFileVersions ? { buildFileVersions } : {}),
     };
   };
 
@@ -729,7 +674,6 @@ build ${entryPointKeys.length} entry points`);
     try {
       const result = await runBuild({
         signal: operation.signal,
-        logLevel: logs.level,
       });
       return result;
     } finally {
@@ -801,3 +745,584 @@ build ${entryPointKeys.length} entry points`);
   await firstBuildPromise;
   return stopWatchingSourceFiles;
 };
+
+const entryPointDefaultParams = {
+  buildRelativeUrl: undefined,
+  runtimeCompat: defaultRuntimeCompat,
+  plugins: [],
+  mappings: undefined,
+  assetsDirectory: undefined,
+  base: undefined,
+  ignore: undefined,
+
+  bundling: true,
+  minification: true,
+  versioning: true,
+
+  referenceAnalysis: {},
+  nodeEsmResolution: undefined,
+  packageConditions: undefined,
+  magicExtensions: undefined,
+  magicDirectoryIndex: undefined,
+  directoryReferenceEffect: undefined,
+  scenarioPlaceholders: undefined,
+  injections: undefined,
+  transpilation: {},
+
+  versioningMethod: "search_param", // "filename", "search_param"
+  versioningViaImportmap: true,
+  versionLength: 8,
+  lineBreakNormalization: process.platform === "win32",
+
+  http: false,
+
+  sourcemaps: "none",
+  sourcemapsSourcesContent: undefined,
+  assetManifest: false,
+  assetManifestFileRelativeUrl: "asset-manifest.json",
+};
+
+const prepareEntryPointBuild = async (
+  {
+    signal,
+    sourceDirectoryUrl,
+    buildDirectoryUrl,
+    sourceRelativeUrl,
+    outDirectoryUrl,
+    buildUrlsGenerator,
+    someEntryPointUseNode,
+  },
+  entryPointParams,
+) => {
+  let {
+    buildRelativeUrl,
+    runtimeCompat,
+    plugins,
+    mappings,
+    assetsDirectory,
+    base,
+    ignore,
+
+    bundling,
+    minification,
+    versioning,
+
+    referenceAnalysis,
+    nodeEsmResolution,
+    packageConditions,
+    magicExtensions,
+    magicDirectoryIndex,
+    directoryReferenceEffect,
+    scenarioPlaceholders,
+    injections,
+    transpilation,
+
+    versioningMethod,
+    versioningViaImportmap,
+    versionLength,
+    lineBreakNormalization,
+
+    http,
+
+    sourcemaps,
+    sourcemapsSourcesContent,
+    assetManifest,
+    assetManifestFileRelativeUrl,
+  } = {
+    ...entryPointDefaultParams,
+    ...entryPointParams,
+  };
+
+  // param defaults and normalization
+  {
+    if (entryPointParams.buildRelativeUrl === undefined) {
+      buildRelativeUrl = entryPointParams.buildRelativeUrl = sourceRelativeUrl;
+    }
+    const buildUrl = new URL(buildRelativeUrl, buildDirectoryUrl);
+    entryPointParams.buildRelativeUrl = buildRelativeUrl = urlToRelativeUrl(
+      buildUrl,
+      buildDirectoryUrl,
+    );
+    if (entryPointParams.assetsDirectory === undefined) {
+      const entryBuildUrl = new URL(buildRelativeUrl, buildDirectoryUrl).href;
+      const entryBuildRelativeUrl = urlToRelativeUrl(
+        entryBuildUrl,
+        buildDirectoryUrl,
+      );
+      if (entryBuildRelativeUrl.includes("/")) {
+        const assetDirectoryUrl = new URL("./", entryBuildUrl);
+        assetsDirectory = urlToRelativeUrl(
+          assetDirectoryUrl,
+          buildDirectoryUrl,
+        );
+      } else {
+        assetsDirectory = "";
+      }
+    }
+    if (
+      assetsDirectory &&
+      assetsDirectory[assetsDirectory.length - 1] !== "/"
+    ) {
+      assetsDirectory = `${assetsDirectory}/`;
+    }
+    if (entryPointParams.base === undefined) {
+      base = someEntryPointUseNode ? "./" : "/";
+    }
+    if (entryPointParams.bundling === undefined) {
+      bundling = true;
+    }
+    if (bundling === true) {
+      bundling = {};
+    }
+    if (entryPointParams.minification === undefined) {
+      minification = !someEntryPointUseNode;
+    }
+    if (minification === true) {
+      minification = {};
+    }
+    if (entryPointParams.versioning === undefined) {
+      versioning = !someEntryPointUseNode;
+    }
+    if (entryPointParams.versioningMethod === undefined) {
+      versioningMethod = entryPointDefaultParams.versioningMethod;
+    }
+    if (entryPointParams.assetManifest === undefined) {
+      assetManifest = versioningMethod === "filename";
+    }
+  }
+
+  const buildOperation = Abort.startOperation();
+  buildOperation.addAbortSignal(signal);
+
+  const explicitJsModuleConversion =
+    sourceRelativeUrl.includes("?js_module_fallback") ||
+    sourceRelativeUrl.includes("?as_js_classic");
+  const contextSharedDuringBuild = {
+    buildStep: "craft",
+    buildDirectoryUrl,
+    assetsDirectory,
+    versioning,
+    versioningViaImportmap,
+  };
+  const rawKitchen = createKitchen({
+    signal,
+    logLevel: "warn",
+    rootDirectoryUrl: sourceDirectoryUrl,
+    ignore,
+    // during first pass (craft) we keep "ignore:" when a reference is ignored
+    // so that the second pass (shape) properly ignore those urls
+    ignoreProtocol: "keep",
+    build: true,
+    runtimeCompat,
+    initialContext: contextSharedDuringBuild,
+    sourcemaps,
+    sourcemapsSourcesContent,
+    outDirectoryUrl: outDirectoryUrl
+      ? new URL("craft/", outDirectoryUrl)
+      : undefined,
+  });
+
+  let _getOtherEntryBuildInfo;
+  const rawPluginStore = createPluginStore([
+    ...(mappings ? [jsenvPluginMappings(mappings)] : []),
+    {
+      name: "jsenv:other_entry_point_build_during_craft",
+      fetchUrlContent: async (urlInfo) => {
+        if (!_getOtherEntryBuildInfo) {
+          return null;
+        }
+        const otherEntryBuildInfo = _getOtherEntryBuildInfo(urlInfo.url);
+        if (!otherEntryBuildInfo) {
+          return null;
+        }
+        urlInfo.otherEntryBuildInfo = otherEntryBuildInfo;
+        return {
+          type: "entry_build", // this ensure the rest of jsenv do not try to scan or modify the content
+          content: "", // we don't know yet the content it will be known later
+          filenameHint: otherEntryBuildInfo.entryUrlInfo.filenameHint,
+        };
+      },
+    },
+    ...plugins,
+    ...(bundling ? [jsenvPluginBundling(bundling)] : []),
+    ...(minification ? [jsenvPluginMinification(minification)] : []),
+    ...getCorePlugins({
+      rootDirectoryUrl: sourceDirectoryUrl,
+      runtimeCompat,
+      referenceAnalysis,
+      nodeEsmResolution,
+      packageConditions,
+      magicExtensions,
+      magicDirectoryIndex,
+      directoryReferenceEffect,
+      injections,
+      transpilation: {
+        babelHelpersAsImport: !explicitJsModuleConversion,
+        ...transpilation,
+        jsModuleFallback: false,
+      },
+      inlining: false,
+      http,
+      scenarioPlaceholders,
+    }),
+  ]);
+  const rawPluginController = createPluginController(
+    rawPluginStore,
+    rawKitchen,
+  );
+  rawKitchen.setPluginController(rawPluginController);
+
+  const rawRootUrlInfo = rawKitchen.graph.rootUrlInfo;
+  let entryReference;
+  await rawRootUrlInfo.dependencies.startCollecting(() => {
+    entryReference = rawRootUrlInfo.dependencies.found({
+      trace: { message: `"${sourceRelativeUrl}" from "entryPoints"` },
+      isEntryPoint: true,
+      type: "entry_point",
+      specifier: sourceRelativeUrl,
+      filenameHint: buildRelativeUrl,
+    });
+  });
+
+  return {
+    entryReference,
+    buildEntryPoint: async ({ getOtherEntryBuildInfo }) => {
+      craft: {
+        _getOtherEntryBuildInfo = getOtherEntryBuildInfo;
+        if (outDirectoryUrl) {
+          await ensureEmptyDirectory(new URL(`craft/`, outDirectoryUrl));
+        }
+        await rawRootUrlInfo.cookDependencies({ operation: buildOperation });
+      }
+
+      const finalKitchen = createKitchen({
+        name: "shape",
+        logLevel: "warn",
+        rootDirectoryUrl: sourceDirectoryUrl,
+        // here most plugins are not there
+        // - no external plugin
+        // - no plugin putting reference.mustIgnore on https urls
+        // At this stage it's only about redirecting urls to the build directory
+        // consequently only a subset or urls are supported
+        supportedProtocols: ["file:", "data:", "virtual:", "ignore:"],
+        ignore,
+        ignoreProtocol: "remove",
+        build: true,
+        runtimeCompat,
+        initialContext: contextSharedDuringBuild,
+        sourcemaps,
+        sourcemapsComment: "relative",
+        sourcemapsSourcesContent,
+        outDirectoryUrl: outDirectoryUrl
+          ? new URL("shape/", outDirectoryUrl)
+          : undefined,
+      });
+      const buildSpecifierManager = createBuildSpecifierManager({
+        rawKitchen,
+        finalKitchen,
+        logger: createLogger({ logLevel: "warn" }),
+        sourceDirectoryUrl,
+        buildDirectoryUrl,
+        base,
+        assetsDirectory,
+        buildUrlsGenerator,
+
+        versioning,
+        versioningMethod,
+        versionLength,
+        canUseImportmap:
+          versioningViaImportmap &&
+          rawKitchen.graph.getUrlInfo(entryReference.url).type === "html" &&
+          rawKitchen.context.isSupportedOnCurrentClients("importmap"),
+      });
+      const finalPluginStore = createPluginStore([
+        jsenvPluginReferenceAnalysis({
+          ...referenceAnalysis,
+          fetchInlineUrls: false,
+          // inlineContent: false,
+        }),
+        jsenvPluginDirectoryReferenceEffect(directoryReferenceEffect, {
+          rootDirectoryUrl: sourceDirectoryUrl,
+        }),
+        ...(lineBreakNormalization
+          ? [jsenvPluginLineBreakNormalization()]
+          : []),
+        jsenvPluginJsModuleFallback({
+          remapImportSpecifier: (specifier, parentUrl) => {
+            return buildSpecifierManager.remapPlaceholder(specifier, parentUrl);
+          },
+        }),
+        jsenvPluginInlining(),
+        {
+          name: "jsenv:optimize",
+          appliesDuring: "build",
+          transformUrlContent: async (urlInfo) => {
+            await rawKitchen.pluginController.callAsyncHooks(
+              "optimizeUrlContent",
+              urlInfo,
+              (optimizeReturnValue) => {
+                urlInfo.mutateContent(optimizeReturnValue);
+              },
+            );
+          },
+        },
+        buildSpecifierManager.jsenvPluginMoveToBuildDirectory,
+      ]);
+      const finalPluginController = createPluginController(
+        finalPluginStore,
+        finalKitchen,
+        {
+          initialPuginsMeta: rawKitchen.pluginController.pluginsMeta,
+        },
+      );
+      finalKitchen.setPluginController(finalPluginController);
+
+      bundle: {
+        const bundlerMap = new Map();
+        for (const plugin of rawKitchen.pluginController.activePlugins) {
+          const bundle = plugin.bundle;
+          if (!bundle) {
+            continue;
+          }
+          if (typeof bundle !== "object") {
+            throw new Error(
+              `bundle must be an object, found "${bundle}" on plugin named "${plugin.name}"`,
+            );
+          }
+          for (const type of Object.keys(bundle)) {
+            const bundleFunction = bundle[type];
+            if (!bundleFunction) {
+              continue;
+            }
+            if (bundlerMap.has(type)) {
+              // first plugin to define a bundle hook wins
+              continue;
+            }
+            bundlerMap.set(type, {
+              plugin,
+              bundleFunction: bundle[type],
+              urlInfoMap: new Map(),
+            });
+          }
+        }
+        if (bundlerMap.size === 0) {
+          break bundle;
+        }
+        const addToBundlerIfAny = (rawUrlInfo) => {
+          const bundler = bundlerMap.get(rawUrlInfo.type);
+          if (bundler) {
+            bundler.urlInfoMap.set(rawUrlInfo.url, rawUrlInfo);
+          }
+        };
+        // ignore unused urls thanks to "forEachUrlInfoStronglyReferenced"
+        // it avoid bundling things that are not actually used
+        // happens for:
+        // - js import assertions
+        // - conversion to js classic using ?as_js_classic or ?js_module_fallback
+        GRAPH_VISITOR.forEachUrlInfoStronglyReferenced(
+          rawKitchen.graph.rootUrlInfo,
+          (rawUrlInfo) => {
+            if (rawUrlInfo.isEntryPoint) {
+              addToBundlerIfAny(rawUrlInfo);
+            }
+            if (rawUrlInfo.type === "html") {
+              for (const referenceToOther of rawUrlInfo.referenceToOthersSet) {
+                if (
+                  referenceToOther.isResourceHint &&
+                  referenceToOther.expectedType === "js_module"
+                ) {
+                  const referencedUrlInfo = referenceToOther.urlInfo;
+                  if (
+                    referencedUrlInfo &&
+                    // something else than the resource hint is using this url
+                    referencedUrlInfo.referenceFromOthersSet.size > 0
+                  ) {
+                    addToBundlerIfAny(referencedUrlInfo);
+                    continue;
+                  }
+                }
+                if (referenceToOther.isWeak) {
+                  continue;
+                }
+                const referencedUrlInfo = referenceToOther.urlInfo;
+                if (referencedUrlInfo.isInline) {
+                  if (referencedUrlInfo.type !== "js_module") {
+                    continue;
+                  }
+                  addToBundlerIfAny(referencedUrlInfo);
+                  continue;
+                }
+                addToBundlerIfAny(referencedUrlInfo);
+              }
+              return;
+            }
+            // File referenced with
+            // - new URL("./file.js", import.meta.url)
+            // - import.meta.resolve("./file.js")
+            // are entry points that should be bundled
+            // For instance we will bundle service worker/workers detected like this
+            if (rawUrlInfo.type === "js_module") {
+              for (const referenceToOther of rawUrlInfo.referenceToOthersSet) {
+                if (
+                  referenceToOther.type === "js_url" ||
+                  referenceToOther.subtype === "import_meta_resolve"
+                ) {
+                  const referencedUrlInfo = referenceToOther.urlInfo;
+                  let isAlreadyBundled = false;
+                  for (const referenceFromOther of referencedUrlInfo.referenceFromOthersSet) {
+                    if (referenceFromOther.url === referencedUrlInfo.url) {
+                      if (
+                        referenceFromOther.subtype === "import_dynamic" ||
+                        referenceFromOther.type === "script"
+                      ) {
+                        isAlreadyBundled = true;
+                        break;
+                      }
+                    }
+                  }
+                  if (!isAlreadyBundled) {
+                    addToBundlerIfAny(referencedUrlInfo);
+                  }
+                  continue;
+                }
+                if (referenceToOther.type === "js_inline_content") {
+                  // we should bundle it too right?
+                }
+              }
+            }
+          },
+        );
+        for (const [, bundler] of bundlerMap) {
+          const urlInfosToBundle = Array.from(bundler.urlInfoMap.values());
+          if (urlInfosToBundle.length === 0) {
+            continue;
+          }
+          await buildSpecifierManager.applyBundling({
+            bundler,
+            urlInfosToBundle,
+          });
+        }
+      }
+
+      shape: {
+        finalKitchen.context.buildStep = "shape";
+        if (outDirectoryUrl) {
+          await ensureEmptyDirectory(new URL(`shape/`, outDirectoryUrl));
+        }
+        const finalRootUrlInfo = finalKitchen.graph.rootUrlInfo;
+        await finalRootUrlInfo.dependencies.startCollecting(() => {
+          finalRootUrlInfo.dependencies.found({
+            trace: { message: `entryPoint` },
+            isEntryPoint: true,
+            type: "entry_point",
+            specifier: entryReference.url,
+          });
+        });
+        await finalRootUrlInfo.cookDependencies({
+          operation: buildOperation,
+        });
+      }
+
+      refine: {
+        finalKitchen.context.buildStep = "refine";
+
+        const htmlRefineSet = new Set();
+        const registerHtmlRefine = (htmlRefine) => {
+          htmlRefineSet.add(htmlRefine);
+        };
+
+        replace_placeholders: {
+          await buildSpecifierManager.replacePlaceholders();
+        }
+
+        /*
+         * Update <link rel="preload"> and friends after build (once we know everything)
+         * - Used to remove resource hint targeting an url that is no longer used:
+         *   - because of bundlings
+         *   - because of import assertions transpilation (file is inlined into JS)
+         */
+        resync_resource_hints: {
+          buildSpecifierManager.prepareResyncResourceHints({
+            registerHtmlRefine,
+          });
+        }
+
+        mutate_html: {
+          GRAPH_VISITOR.forEach(finalKitchen.graph, (urlInfo) => {
+            if (!urlInfo.url.startsWith("file:")) {
+              return;
+            }
+            if (urlInfo.type !== "html") {
+              return;
+            }
+            const htmlAst = parseHtml({
+              html: urlInfo.content,
+              url: urlInfo.url,
+              storeOriginalPositions: false,
+            });
+            for (const htmlRefine of htmlRefineSet) {
+              const htmlMutationCallbackSet = new Set();
+              const registerHtmlMutation = (callback) => {
+                htmlMutationCallbackSet.add(callback);
+              };
+              htmlRefine(htmlAst, { registerHtmlMutation });
+              for (const htmlMutationCallback of htmlMutationCallbackSet) {
+                htmlMutationCallback();
+              }
+            }
+            // cleanup jsenv attributes from html as a last step
+            urlInfo.content = stringifyHtmlAst(htmlAst, {
+              cleanupJsenvAttributes: true,
+              cleanupPositionAttributes: true,
+            });
+          });
+        }
+
+        inject_urls_in_service_workers: {
+          const inject =
+            buildSpecifierManager.prepareServiceWorkerUrlInjection();
+          if (inject) {
+            await inject();
+            buildOperation.throwIfAborted();
+          }
+        }
+      }
+      const {
+        buildFileContents,
+        buildFileVersions,
+        buildInlineContents,
+        buildManifest,
+      } = buildSpecifierManager.getBuildInfo();
+      if (versioning && assetManifest && Object.keys(buildManifest).length) {
+        buildFileContents[assetManifestFileRelativeUrl] = JSON.stringify(
+          buildManifest,
+          null,
+          "  ",
+        );
+      }
+      return {
+        buildFileContents,
+        buildFileVersions,
+        buildInlineContents,
+        buildManifest,
+      };
+    },
+  };
+};
+
+const isBareSpecifier = (specifier) => {
+  if (
+    specifier[0] === "/" ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../")
+  ) {
+    return false;
+  }
+  try {
+    // eslint-disable-next-line no-new
+    new URL(specifier);
+    return false;
+  } catch {
+    return true;
+  }
+};